#include "support/lassert.h"
-#include "support/regex.h"
-
#include <stack>
#include <iostream>
#include <algorithm>
}
-xml::FontTag docbookStartFontTag(xml::FontTypes type)
-{
- return xml::FontTag(from_utf8(fontToDocBookTag(type)), from_utf8(fontToAttribute(type)), type);
-}
-
-
-xml::EndFontTag docbookEndFontTag(xml::FontTypes type)
-{
- return xml::EndFontTag(from_utf8(fontToDocBookTag(type)), type);
-}
-
-
// Convenience functions to open and close tags. First, very low-level ones to ensure a consistent new-line behaviour.
// Block style:
// Content before
void openTag(XMLStream & xs, const std::string & tag, const std::string & attr, const std::string & tagtype)
{
- if (tag.empty() || tag == "NONE")
+ if (tag.empty() || tag == "NONE") // Common check to be performed elsewhere, if it was not here.
return;
if (tag == "para" || tagtype == "paragraph") // Special case for <para>: always considered as a paragraph.
Layout const & prevlay = prevpar->layout();
if (prevlay.docbookwrappertag() != "NONE") {
openWrapper = prevlay.docbookwrappertag() == lay.docbookwrappertag()
- && !lay.docbookwrappermergewithprevious();
+ && !lay.docbookwrappermergewithprevious();
}
}
Layout const & nextlay = nextpar->layout();
if (nextlay.docbookwrappertag() != "NONE") {
closeWrapper = nextlay.docbookwrappertag() == lay.docbookwrappertag()
- && !nextlay.docbookwrappermergewithprevious();
+ && !nextlay.docbookwrappermergewithprevious();
}
}
}
-void makeAny(
- Text const &,
- Buffer const &,
- XMLStream &,
- OutputParams const &,
- ParagraphList::const_iterator);
+ParagraphList::const_iterator makeAny(Text const &,
+ Buffer const &,
+ XMLStream &,
+ OutputParams const &,
+ ParagraphList::const_iterator);
-void makeParagraphBibliography(
+void makeBibliography(
+ Text const & text,
Buffer const & buf,
XMLStream & xs,
OutputParams const & runparams,
- Text const & text,
ParagraphList::const_iterator const & par)
{
// If this is the first paragraph in a bibliography, open the bibliography tag.
// Don't forget the citation ID!
docstring attr;
for (auto i = 0; i < par->size(); ++i) {
- Inset const *ip = par->getInset(0);
- if (ip != nullptr && ip->lyxCode() == BIBITEM_CODE) {
- const auto * bibitem = dynamic_cast<const InsetBibitem*>(par->getInset(i));
+ Inset const *ip = par->getInset(i);
+ if (!ip)
+ continue;
+ if (const auto * bibitem = dynamic_cast<const InsetBibitem*>(ip)) {
attr = from_utf8("xml:id='") + bibitem->getParam("key") + from_utf8("'");
break;
}
}
xs << xml::StartTag(from_utf8("bibliomixed"), attr);
- // Generate the entry.
+ // Generate the entry. Concatenate the different parts of the paragraph if any.
auto const begin = text.paragraphs().begin();
- par->simpleDocBookOnePar(buf, xs, runparams, text.outerFont(std::distance(begin, par)), true, true, 0);
+ auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(std::distance(begin, par)), 0);
+ for (auto & parXML : pars)
+ xs << XMLStream::ESCAPE_NONE << parXML;
// End the precooked bibliography entry.
xs << xml::EndTag("bibliomixed");
void makeParagraph(
+ Text const & text,
Buffer const & buf,
XMLStream & xs,
OutputParams const & runparams,
- Text const & text,
ParagraphList::const_iterator const & par)
{
auto const begin = text.paragraphs().begin();
special_case = true;
}
+ size_t nInsets = std::distance(par->insetList().begin(), par->insetList().end());
+
// Plain layouts must be ignored.
- if (!special_case && buf.params().documentClass().isPlainLayout(par->layout()) && !runparams.docbook_force_pars)
- special_case = true;
- // TODO: Could get rid of this with a DocBook equivalent to htmlisblock?
+ special_case |= buf.params().documentClass().isPlainLayout(par->layout()) && !runparams.docbook_force_pars;
+ // Equations do not deserve their own paragraph (DocBook allows them outside paragraphs).
+ special_case |= nInsets == par->size() && std::all_of(par->insetList().begin(), par->insetList().end(), [](InsetList::Element inset) {
+ return inset.inset && inset.inset->asInsetMath();
+ });
+
+ // TODO: Could get rid of this with a DocBook equivalent to htmlisblock? Not for all cases, unfortunately... See above for those that have been determined not to be allowable for this potential refactoring.
if (!special_case && par->size() == 1 && par->getInset(0)) {
Inset const * firstInset = par->getInset(0);
if (!special_case && firstInset->asInsetCommand())
special_case = firstInset->asInsetCommand()->params().getCmdName() == "bibtex";
- // Equations do not deserve their own paragraph (DocBook allows them outside paragraphs).
- if (!special_case && firstInset->asInsetMath())
- special_case = true;
-
// ERTs are in comments, not paragraphs.
if (!special_case && firstInset->lyxCode() == lyx::ERT_CODE)
special_case = true;
// Determine if this paragraph has some real content. Things like new pages are not caught
// by Paragraph::empty(), even though they do not generate anything useful in DocBook.
- odocstringstream os2;
- XMLStream xs2(os2);
- par->simpleDocBookOnePar(buf, xs2, runparams, text.outerFont(distance(begin, par)), open_par, close_par, 0);
-
- docstring cleaned = os2.str();
- static const lyx::regex reg("[ \\r\\n]*");
- cleaned = from_utf8(lyx::regex_replace(to_utf8(cleaned), reg, string("")));
-
- if (!cleaned.empty()) {
- if (open_par)
- openParTag(xs, &*par, prevpar);
-
- xs << XMLStream::ESCAPE_NONE << os2.str();
-
- if (close_par)
- closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr);
+ // Thus, remove all spaces (including new lines: \r, \n) before checking for emptiness.
+ // std::all_of allows doing this check without having to copy the string.
+ // Open and close tags around each contained paragraph.
+ auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(distance(begin, par)), 0);
+ for (auto & parXML : pars) {
+ if (!std::all_of(parXML.begin(), parXML.end(), ::isspace)) {
+ if (open_par)
+ openParTag(xs, &*par, prevpar);
+
+ xs << XMLStream::ESCAPE_NONE << parXML;
+
+ if (close_par)
+ closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr);
+ }
}
}
-void makeEnvironment(
- Buffer const &buf,
- XMLStream &xs,
- OutputParams const &runparams,
- Text const &text,
- ParagraphList::const_iterator const & par)
+void makeEnvironment(Text const &text,
+ Buffer const &buf,
+ XMLStream &xs,
+ OutputParams const &runparams,
+ ParagraphList::const_iterator const & par)
{
+ // TODO: simplify me!
auto const end = text.paragraphs().end();
// Output the opening tag for this environment, but only if it has not been previously opened (condition
Layout const & style = par->layout();
if (style.latextype == LATEX_COMMAND) {
// Nothing to do (otherwise, infinite loops).
- } else if (style.latextype == LATEX_ENVIRONMENT ||
- style.latextype == LATEX_LIST_ENVIRONMENT ||
- style.latextype == LATEX_ITEM_ENVIRONMENT) {
+ } else if (style.latextype == LATEX_ENVIRONMENT) {
// Open a wrapper tag if needed.
- if (style.docbookitemwrappertag() != "NONE") {
- xs << xml::StartTag(style.docbookitemwrappertag(), style.docbookitemwrapperattr());
- xs << xml::CR();
- }
+ if (style.docbookitemwrappertag() != "NONE")
+ openTag(xs, style.docbookitemwrappertag(), style.docbookitemwrapperattr(), style.docbookitemwrappertagtype());
// Generate the label, if need be. If it is taken from the text, sep != 0 and corresponds to the first
// character after the label.
// Usual cases: maybe there is something specified at the layout level. Highly unlikely, though.
docstring const lbl = par->params().labelString();
- if (lbl.empty()) {
- xs << xml::CR();
- } else {
+ if (!lbl.empty()) {
openLabelTag(xs, style);
xs << lbl;
closeLabelTag(xs, style);
// TODO: this always worked only by magic...
xs << ' ';
} else {
- // Generate the rest of the paragraph, if need be.
- par->simpleDocBookOnePar(buf, xs, runparams, text.outerFont(std::distance(text.paragraphs().begin(), par)),
- true, true, sep);
+ // Generate the rest of the paragraph, if need be. Open as many inner tags as necessary.
+ auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(std::distance(text.paragraphs().begin(), par)), sep);
+ auto p = pars.begin();
+ while (true) {
+ xs << XMLStream::ESCAPE_NONE << *p;
+ ++p;
+ if (p != pars.end()) {
+ closeTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnertagtype());
+ openTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnerattr(), par->layout().docbookiteminnertagtype());
+ } else
+ break;
+ }
}
} else {
makeAny(text, buf, xs, runparams, par);
}
+ParagraphList::const_iterator findEndOfEnvironment(
+ ParagraphList::const_iterator const & pstart,
+ ParagraphList::const_iterator const & pend)
+{
+ // Copy-paste from XHTML. Should be factored out at some point...
+ ParagraphList::const_iterator p = pstart;
+ Layout const & bstyle = p->layout();
+ size_t const depth = p->params().depth();
+ for (++p; p != pend; ++p) {
+ Layout const & style = p->layout();
+ // It shouldn't happen that e.g. a section command occurs inside
+ // a quotation environment, at a higher depth, but as of 6/2009,
+ // it can happen. We pretend that it's just at lowest depth.
+ if (style.latextype == LATEX_COMMAND)
+ return p;
+
+ // If depth is down, we're done
+ if (p->params().depth() < depth)
+ return p;
+
+ // If depth is up, we're not done
+ if (p->params().depth() > depth)
+ continue;
+
+ // FIXME I am not sure about the first check.
+ // Surely we *could* have different layouts that count as
+ // LATEX_PARAGRAPH, right?
+ if (style.latextype == LATEX_PARAGRAPH || style != bstyle)
+ return p;
+ }
+ return pend;
+}
+
+
+ParagraphList::const_iterator makeListEnvironment(Text const &text,
+ Buffer const &buf,
+ XMLStream &xs,
+ OutputParams const &runparams,
+ ParagraphList::const_iterator const & begin)
+{
+ auto par = begin;
+ auto const end = text.paragraphs().end();
+ auto const envend = findEndOfEnvironment(par, end);
+
+ // Output the opening tag for this environment.
+ Layout const & envstyle = par->layout();
+ openTag(xs, envstyle.docbookwrappertag(), envstyle.docbookwrapperattr(), envstyle.docbookwrappertagtype());
+ openTag(xs, envstyle.docbooktag(), envstyle.docbookattr(), envstyle.docbooktagtype());
+
+ // Handle the content of the list environment, item by item.
+ while (par != envend) {
+ Layout const & style = par->layout();
+
+ // Open the item wrapper.
+ openTag(xs, style.docbookitemwrappertag(), style.docbookitemwrapperattr(), style.docbookitemwrappertagtype());
+
+ // Generate the label, if need be. If it is taken from the text, sep != 0 and corresponds to the first
+ // character after the label.
+ pos_type sep = 0;
+ if (style.labeltype != LABEL_NO_LABEL && style.docbookitemlabeltag() != "NONE") {
+ if (style.labeltype == LABEL_MANUAL) {
+ // Only variablelist gets here (or similar items defined as an extension in the layout).
+ openLabelTag(xs, style);
+ sep = 1 + par->firstWordDocBook(xs, runparams);
+ closeLabelTag(xs, style);
+ } else {
+ // Usual cases: maybe there is something specified at the layout level. Highly unlikely, though.
+ docstring const lbl = par->params().labelString();
+
+ if (!lbl.empty()) {
+ openLabelTag(xs, style);
+ xs << lbl;
+ closeLabelTag(xs, style);
+ }
+ }
+ }
+
+ // Open the item (after the wrapper and the label).
+ openTag(xs, style.docbookitemtag(), style.docbookitemattr(), style.docbookitemtagtype());
+
+ // Generate the content of the item.
+ if (sep < par->size()) {
+ auto pars = par->simpleDocBookOnePar(buf, runparams,
+ text.outerFont(std::distance(text.paragraphs().begin(), par)), sep);
+ for (auto &p : pars) {
+ openTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnerattr(),
+ par->layout().docbookiteminnertagtype());
+ xs << XMLStream::ESCAPE_NONE << p;
+ closeTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnertagtype());
+ }
+ } else {
+ // DocBook doesn't like emptiness.
+ openTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnerattr(),
+ par->layout().docbookiteminnertagtype());
+ closeTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnertagtype());
+ }
+
+ // If the next item is deeper, it must go entirely within this item (do it recursively).
+ // By construction, with findEndOfEnvironment, depth can only stay constant or increase, never decrease.
+ depth_type currentDepth = par->getDepth();
+ ++par;
+ while (par != envend && par->getDepth() != currentDepth)
+ par = makeAny(text, buf, xs, runparams, par);
+ // Usually, this loop only makes one iteration, except in complex scenarios, like an item with a paragraph,
+ // a list, and another paragraph; or an item with two types of list (itemise then enumerate, for instance).
+
+ // Close the item.
+ closeTag(xs, style.docbookitemtag(), style.docbookitemtagtype());
+ closeTag(xs, style.docbookitemwrappertag(), style.docbookitemwrappertagtype());
+ }
+
+ // Close this environment in exactly the same way as it was opened.
+ closeTag(xs, envstyle.docbooktag(), envstyle.docbooktagtype());
+ closeTag(xs, envstyle.docbookwrappertag(), envstyle.docbookwrappertagtype());
+
+ return envend;
+}
+
+
void makeCommand(
+ Text const & text,
Buffer const & buf,
XMLStream & xs,
OutputParams const & runparams,
- Text const & text,
ParagraphList::const_iterator const & par)
{
// Unlike XHTML, no need for labels, as they are handled by DocBook tags.
auto prevpar = text.paragraphs().getParagraphBefore(par);
openParTag(xs, &*par, prevpar);
- par->simpleDocBookOnePar(buf, xs, runparams,
- text.outerFont(distance(begin, par)));
+ auto pars = par->simpleDocBookOnePar(buf, runparams,text.outerFont(distance(begin, par)));
+ for (auto & parXML : pars)
+ // TODO: decide what to do with openParTag/closeParTag in new lines.
+ xs << XMLStream::ESCAPE_NONE << parXML;
closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr);
}
-void makeAny(
- Text const &text,
- Buffer const &buf,
- XMLStream &xs,
- OutputParams const &ourparams,
- ParagraphList::const_iterator par)
+ParagraphList::const_iterator makeAny(Text const &text,
+ Buffer const &buf,
+ XMLStream &xs,
+ OutputParams const &runparams,
+ ParagraphList::const_iterator par)
{
switch (par->layout().latextype) {
case LATEX_COMMAND:
- makeCommand(buf, xs, ourparams, text, par);
+ makeCommand(text, buf, xs, runparams, par);
break;
case LATEX_ENVIRONMENT:
+ makeEnvironment(text, buf, xs, runparams, par);
+ break;
case LATEX_LIST_ENVIRONMENT:
case LATEX_ITEM_ENVIRONMENT:
- makeEnvironment(buf, xs, ourparams, text, par);
- break;
+ // Only case when makeAny() might consume more than one paragraph.
+ return makeListEnvironment(text, buf, xs, runparams, par);
case LATEX_PARAGRAPH:
- makeParagraph(buf, xs, ourparams, text, par);
+ makeParagraph(text, buf, xs, runparams, par);
break;
case LATEX_BIB_ENVIRONMENT:
- makeParagraphBibliography(buf, xs, ourparams, text, par);
+ makeBibliography(text, buf, xs, runparams, par);
break;
}
+ ++par;
+ return par;
}
-} // end anonymous namespace
+
+bool isLayoutSectioning(Layout const & lay)
+{
+ return lay.category() == from_utf8("Sectioning");
+}
using DocBookDocumentSectioning = tuple<bool, pit_type>;
struct DocBookInfoTag
{
const set<pit_type> shouldBeInInfo;
- const set<pit_type> mustBeInInfo;
+ const set<pit_type> mustBeInInfo; // With the notable exception of the abstract!
const set<pit_type> abstract;
+ const bool abstractLayout;
pit_type bpit;
pit_type epit;
DocBookInfoTag(const set<pit_type> & shouldBeInInfo, const set<pit_type> & mustBeInInfo,
- const set<pit_type> & abstract, pit_type bpit, pit_type epit) :
+ const set<pit_type> & abstract, bool abstractLayout, pit_type bpit, pit_type epit) :
shouldBeInInfo(shouldBeInInfo), mustBeInInfo(mustBeInInfo), abstract(abstract),
- bpit(bpit), epit(epit) {}
+ abstractLayout(abstractLayout), bpit(bpit), epit(epit) {}
};
while (bpit < epit) {
Layout const &style = paragraphs[bpit].layout();
- documentHasSections |= style.category() == from_utf8("Sectioning");
+ documentHasSections |= isLayoutSectioning(style);
if (documentHasSections)
break;
}
-DocBookInfoTag getParagraphsWithInfo(ParagraphList const ¶graphs, pit_type bpit, pit_type const epit) {
+DocBookInfoTag getParagraphsWithInfo(ParagraphList const ¶graphs,
+ pit_type bpit, pit_type const epit,
+ // Typically, bpit is the beginning of the document and epit the end *or* the first section.
+ bool documentHasSections) {
set<pit_type> shouldBeInInfo;
set<pit_type> mustBeInInfo;
- set<pit_type> abstract;
+ set<pit_type> abstractWithLayout;
+ set<pit_type> abstractNoLayout;
// Find the first non empty paragraph by mutating bpit.
while (bpit < epit) {
break;
}
- // Find the last info-like paragraph.
- pit_type cpit = bpit;
+ // Traverse everything that might belong to <info>.
bool hasAbstractLayout = false;
- while (cpit < epit) {
- // Skip paragraphs only containing one note.
+ pit_type cpit = bpit;
+ for (; cpit < epit; ++cpit) {
+ // Skip paragraphs that don't generate anything in DocBook.
Paragraph const & par = paragraphs[cpit];
- if (hasOnlyNotes(par)) {
- cpit += 1;
+ if (par.empty() || par.emptyTag() || hasOnlyNotes(par))
continue;
+
+ // There should never be any section here. (Just a sanity check: if this fails, this function could end up
+ // processing the whole document.)
+ if (isLayoutSectioning(par.layout())) {
+ LYXERR0("Assertion failed: section found in potential <info> paragraphs.");
+ break;
}
- if (par.layout().docbookabstract())
+ // If this is marked as an abstract by the layout, put it in the right set.
+ if (par.layout().docbookabstract()) {
hasAbstractLayout = true;
+ abstractWithLayout.emplace(cpit);
+ continue;
+ }
- // Based on layout information, store this paragraph in one set: should be in <info>, must be.
+ // Based on layout information, store this paragraph in one set: should be in <info>, must be,
+ // or abstract ().
Layout const &style = par.layout();
- if (style.docbookininfo() == "always") {
+ if (style.docbookininfo() == "always")
mustBeInInfo.emplace(cpit);
- } else if (style.docbookininfo() == "maybe") {
+ else if (style.docbookininfo() == "maybe")
shouldBeInInfo.emplace(cpit);
- } else {
- // Hypothesis: the <info> parts should be grouped together near the beginning bpit.
- // There may be notes in between, but nothing else.
+ else if (!hasAbstractLayout)
+ abstractNoLayout.emplace(cpit);
+ else // This should definitely not be in <info>.
break;
- }
- cpit += 1;
}
- // Now, cpit points to the last paragraph that has things that could go in <info>.
+ // Now, cpit points to the first paragraph that no more has things that could go in <info>.
// bpit is the beginning of the <info> part.
- // Go once again through the list of paragraphs to find the abstract. If there is an abstract
- // layout, only consider it. Otherwise, an abstract is just a sequence of paragraphs with text.
- if (hasAbstractLayout) {
- pit_type pit = bpit;
- while (pit < cpit) { // Don't overshoot the <info> part.
- if (paragraphs[pit].layout().docbookabstract())
- abstract.emplace(pit);
- pit++;
- }
- } else {
- pit_type lastAbstract = epit + 1; // A nonsensical value.
- docstring lastAbstractLayout;
-
- pit_type pit = bpit;
- while (pit < cpit) { // Don't overshoot the <info> part.
- const Paragraph & par = paragraphs.at(pit);
- if (!par.insetList().empty()) {
- for (const auto &i : par.insetList()) {
- if (i.inset->getText(0) != nullptr) {
- if (lastAbstract == epit + 1) {
- // First paragraph that matches the heuristic definition of abstract.
- lastAbstract = pit;
- lastAbstractLayout = par.layout().name();
- } else if (pit > lastAbstract + 1 || par.layout().name() != lastAbstractLayout) {
- // This is either too far from the last abstract paragraph or doesn't
- // have the right layout name, BUT there has already been an abstract
- // in this document: done with detecting the abstract.
- goto done; // Easier to get out of two nested loops.
- }
+ return DocBookInfoTag(shouldBeInInfo, mustBeInInfo,
+ hasAbstractLayout ? abstractWithLayout : abstractNoLayout,
+ hasAbstractLayout, bpit, cpit);
+}
+
+} // end anonymous namespace
- abstract.emplace(pit);
- break;
- }
- }
- }
- pit++;
- }
- }
- done:
- return DocBookInfoTag(shouldBeInInfo, mustBeInInfo, abstract, bpit, cpit);
+xml::FontTag docbookStartFontTag(xml::FontTypes type)
+{
+ return xml::FontTag(from_utf8(fontToDocBookTag(type)), from_utf8(fontToAttribute(type)), type);
+}
+
+
+xml::EndFontTag docbookEndFontTag(xml::FontTypes type)
+{
+ return xml::EndFontTag(from_utf8(fontToDocBookTag(type)), type);
}
if (hasAbstract) {
// Generate the abstract XML into a string before further checks.
odocstringstream os2;
- {
- XMLStream xs2(os2);
- auto bpit = *std::min_element(info.abstract.begin(), info.abstract.end());
- auto epit = 1 + *std::max_element(info.abstract.begin(), info.abstract.end());
- // info.abstract is inclusive, epit is exclusive, hence +1 for looping.
-
- while (bpit < epit) {
- makeAny(text, buf, xs2, runparams, paragraphs.iterator_at(bpit));
- bpit += 1;
- }
- }
+ XMLStream xs2(os2);
+ for (auto const & p : info.abstract)
+ makeAny(text, buf, xs2, runparams, paragraphs.iterator_at(p));
// Actually output the abstract if there is something to do. Don't count line feeds or spaces in this,
// even though they must be properly output if there is some abstract.
abstract = os2.str();
- static const lyx::regex reg("[ \\r\\n]*");
- docstring abstractContent = from_utf8(lyx::regex_replace(to_utf8(abstract), reg, string("")));
+ docstring cleaned = abstract;
+ cleaned.erase(std::remove_if(cleaned.begin(), cleaned.end(), ::isspace), cleaned.end());
// Nothing? Then there is no abstract!
- if (abstractContent.empty())
+ if (cleaned.empty())
hasAbstract = false;
}
}
// Output the elements that should go in <info>, before and after the abstract.
- for (auto pit : info.shouldBeInInfo) { // Typically, the title: these elements are so important and ubiquitous
+ for (auto pit : info.shouldBeInInfo) // Typically, the title: these elements are so important and ubiquitous
// that mandating a wrapper like <info> would repel users. Thus, generate them first.
makeAny(text, buf, xs, runparams, paragraphs.iterator_at(pit));
- }
- for (auto pit : info.mustBeInInfo) {
+ for (auto pit : info.mustBeInInfo)
if (info.abstract.find(pit) == info.abstract.end()) // The abstract must be in info, but is dealt with after.
makeAny(text, buf, xs, runparams, paragraphs.iterator_at(pit));
- }
// Always output the abstract as the last item of the <info>, as it requires special treatment (especially if
// it contains several paragraphs that are empty).
if (hasAbstract) {
-// string tag = paragraphs[*info.abstract.begin()].layout().docbookforceabstracttag();
-// if (tag == "NONE")
-// tag = "abstract";
-//
-// xs << xml::StartTag(tag);
-// xs << xml::CR();
- xs << XMLStream::ESCAPE_NONE << abstract;
-// xs << xml::EndTag(tag);
-// xs << xml::CR();
+ if (info.abstractLayout) {
+ xs << XMLStream::ESCAPE_NONE << abstract;
+ xs << xml::CR();
+ } else {
+ string tag = paragraphs[*info.abstract.begin()].layout().docbookforceabstracttag();
+ if (tag == "NONE")
+ tag = "abstract";
+
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+
+ xs << xml::StartTag(tag);
+ xs << xml::CR();
+ xs << XMLStream::ESCAPE_NONE << abstract;
+ xs << xml::EndTag(tag);
+ xs << xml::CR();
+ }
}
// End the <info> tag if it was started.
}
-void docbookFirstParagraphs(
- Text const &text,
- Buffer const &buf,
- XMLStream &xs,
- OutputParams const &runparams,
- pit_type epit)
-{
- // Handle the beginning of the document, supposing it has sections.
- // Major role: output the first <info> tag.
-
- ParagraphList const ¶graphs = text.paragraphs();
- pit_type bpit = runparams.par_begin;
- DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, epit);
- outputDocBookInfo(text, buf, xs, runparams, paragraphs, info);
-}
-
-
void docbookSimpleAllParagraphs(
Text const & text,
Buffer const & buf,
ParagraphList const ¶graphs = text.paragraphs();
pit_type bpit = runparams.par_begin;
pit_type const epit = runparams.par_end;
- DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, epit);
+ DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, epit, false);
outputDocBookInfo(text, buf, xs, runparams, paragraphs, info);
// Then, the content. It starts where the <info> ends.
- bpit = info.epit;
- while (bpit < epit) {
- auto par = paragraphs.iterator_at(bpit);
+ auto par = text.paragraphs().iterator_at(info.epit);
+ auto end = text.paragraphs().iterator_at(epit);
+ while (par != end) {
if (!hasOnlyNotes(*par))
- makeAny(text, buf, xs, runparams, par);
- bpit += 1;
+ par = makeAny(text, buf, xs, runparams, par);
+ else
+ ++par;
}
}
std::stack<std::pair<int, string>> headerLevels; // Used to determine when to open/close sections: store the depth
// of the section and the tag that was used to open it.
- // Detect whether the document contains sections. If there are no sections, there can be no automatically
- // discovered abstract.
+ // Detect whether the document contains sections. If there are no sections, treatment is largely simplified.
+ // In particular, there can't be an abstract, unless it is manually marked.
bool documentHasSections;
pit_type eppit;
tie(documentHasSections, eppit) = hasDocumentSectioning(paragraphs, bpit, epit);
- if (documentHasSections) {
- docbookFirstParagraphs(text, buf, xs, runparams, eppit);
- bpit = eppit;
- } else {
+ // Deal with "simple" documents, i.e. those without sections.
+ if (!documentHasSections){
docbookSimpleAllParagraphs(text, buf, xs, runparams);
return;
}
+ // Output the first <info> tag (or just the title).
+ DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, eppit, true);
+ outputDocBookInfo(text, buf, xs, runparams, paragraphs, info);
+ bpit = eppit;
+
+ // Then, iterate through the paragraphs of this document.
bool currentlyInAppendix = false;
- while (bpit < epit) {
+ auto par = text.paragraphs().iterator_at(bpit);
+ auto end = text.paragraphs().iterator_at(epit);
+ while (par != end) {
OutputParams ourparams = runparams;
- auto par = paragraphs.iterator_at(bpit);
if (par->params().startOfAppendix())
currentlyInAppendix = true;
- Layout const &style = par->layout();
- ParagraphList::const_iterator const lastStartedPar = par;
- ParagraphList::const_iterator send;
-
if (hasOnlyNotes(*par)) {
- bpit += 1;
+ ++par;
continue;
}
+ Layout const &style = par->layout();
+
// Think about adding <section> and/or </section>s.
- const bool isLayoutSectioning = style.category() == from_utf8("Sectioning");
- if (isLayoutSectioning) {
+ if (isLayoutSectioning(style)) {
int level = style.toclevel;
// Need to close a previous section if it has the same level or a higher one (close <section> if opening a <h2>
}
// Generate this paragraph.
- makeAny(text, buf, xs, ourparams, par);
- bpit += 1;
+ par = makeAny(text, buf, xs, ourparams, par);
}
// If need be, close <section>s, but only at the end of the document (otherwise, dealt with at the beginning