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();
}
}
if (nextpar != nullptr) {
Layout const & nextlay = nextpar->layout();
if (nextlay.docbookwrappertag() != "NONE") {
- if (nextpar->getDepth() == par->getDepth()) {
- // Same depth: the basic condition applies.
- closeWrapper = nextlay.docbookwrappertag() == lay.docbookwrappertag()
- && !nextlay.docbookwrappermergewithprevious();
- } else if (nextpar->getDepth() > par->getDepth()) {
- // The next paragraph is deeper: no need to close the wrapper, only to open it (cf. openParTag).
- closeWrapper = 0;
- } else {
- // This paragraph is deeper than the next one: close the wrapper,
- // disregarding docbookwrappermergewithprevious.
- // Hypothesis: nextlay.docbookwrappertag() == lay.docbookwrappertag(). TODO: THIS IS WRONG! Loop back until a layout with the right depth is found?
- closeWrapper = 1L + (long long) par->getDepth() - (long long) nextpar->getDepth(); // > 0, as nextpar->getDepth() < par->getDepth()
- }
- } else {
- if (nextpar->getDepth() == par->getDepth()) {
- // This is not wrapped: this must be the rest of the item, still within the wrapper.
- closeWrapper = 1;
- } else if (nextpar->getDepth() > par->getDepth()) {
- // The next paragraph is deeper: no need to close the wrapper, only to open it (cf. openParTag).
- closeWrapper = 0;
- } else {
- // This paragraph is deeper than the next one: close the wrapper,
- // disregarding docbookwrappermergewithprevious.
- // Hypothesis: nextlay.docbookwrappertag() == lay.docbookwrappertag(). TODO: THIS IS WRONG! Loop back until a layout with the right depth is found?
- closeWrapper = 1L + (long long) par->getDepth() - (long long) nextpar->getDepth(); // > 0, as nextpar->getDepth() < par->getDepth()
- }
+ closeWrapper = nextlay.docbookwrappertag() == lay.docbookwrappertag()
+ && !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 makeBibliography(
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;
// 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);
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();
Buffer const &buf,
XMLStream &xs,
OutputParams const &runparams,
- ParagraphList::const_iterator const & par)
->>>>>>> be6480e59c... DocBook: same refactoring for docbookSimpleAllParagraphs.
+ 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, but only if it has not been previously opened (condition
- // implemented in openParTag).
- auto prevpar = text.paragraphs().getParagraphBefore(par);
- openParTag(xs, &*par, prevpar); // TODO: switch in layout for par/block?
+ // 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());
- // Generate the contents of this environment. There is a special case if this is like some environment.
- 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) {
- // Open a wrapper tag if needed.
- if (style.docbookitemwrappertag() != "NONE")
- openTag(xs, style.docbookitemwrappertag(), style.docbookitemwrapperattr(), style.docbookitemwrappertagtype());
+ // 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") {
- // At least one condition must be met:
- // - this environment is not a list
- // - if this is a list, the label must not be manual (i.e. it must be taken from the layout)
- if (style.latextype != LATEX_LIST_ENVIRONMENT || style.labeltype != LABEL_MANUAL) {
+ 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()) {
- xs << xml::CR();
- } else {
+ if (!lbl.empty()) {
openLabelTag(xs, style);
xs << lbl;
closeLabelTag(xs, style);
}
- } else {
- // Only variablelist gets here (or similar items defined as an extension in the layout).
- openLabelTag(xs, style);
- sep = par->firstWordDocBook(xs, runparams);
- closeLabelTag(xs, style);
}
}
- // Maybe the item is completely empty, i.e. if the first word ends at the end of the current paragraph
- // AND if the next paragraph doesn't have the same depth (if there is such a paragraph).
- // Common case: there is only the first word on the line, but there is a nested list instead
- // of more text.
- bool emptyItem = false;
- if (sep == par->size()) { // If the separator is already at the end of this paragraph...
- auto next_par = par;
- ++next_par;
- if (next_par == text.paragraphs().end()) // There is no next paragraph.
- emptyItem = true;
- else // There is a next paragraph: check depth.
- emptyItem = par->params().depth() >= next_par->params().depth();
- }
-
- if (emptyItem) {
- // Avoid having an empty item, this is not valid DocBook. A single character is enough to force
- // generation of a full <para>.
- // TODO: this always worked only by magic...
- xs << ' ';
- } else {
- // 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;
+ // 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());
}
- } else {
- makeAny(text, buf, xs, runparams, par);
+
+ // 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 the environment.
- auto nextpar = par;
- ++nextpar;
- closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr); // TODO: switch in layout for par/block?
+ // 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;
}
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(text, buf, xs, runparams, par);
break;
makeBibliography(text, buf, xs, runparams, par);
break;
}
+ ++par;
+ return par;
+}
+
+
+bool isLayoutSectioning(Layout const & lay)
+{
+ return lay.category() == from_utf8("Sectioning");
}
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.
- }
-
- abstract.emplace(pit);
- break;
- }
- }
- }
- pit++;
- }
- }
-
- done:
- return DocBookInfoTag(shouldBeInInfo, mustBeInInfo, abstract, bpit, cpit);
+ return DocBookInfoTag(shouldBeInInfo, mustBeInInfo,
+ hasAbstractLayout ? abstractWithLayout : abstractNoLayout,
+ hasAbstractLayout, bpit, cpit);
}
} // end anonymous namespace
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.
}
// 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.
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;
auto par = text.paragraphs().iterator_at(bpit);
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);
+ 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
projects / features.git / blobdiff