src/output_docbook.cpp

   1 /**
   2  * \file output_docbook.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Lars Gullik Bjønnes
   7  * \author José Matos
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "Buffer.h"
  15 #include "buffer_funcs.h"
  16 #include "BufferParams.h"
  17 #include "Font.h"
  18 #include "InsetList.h"
  19 #include "Paragraph.h"
  20 #include "ParagraphList.h"
  21 #include "ParagraphParameters.h"
  22 #include "xml.h"
  23 #include "Text.h"
  24 #include "TextClass.h"
  25
  26 #include "insets/InsetBibtex.h"
  27 #include "insets/InsetBibitem.h"
  28 #include "insets/InsetLabel.h"
  29 #include "insets/InsetNote.h"
  30
  31 #include "support/lassert.h"
  32
  33 #include <stack>
  34 #include <iostream>
  35 #include <algorithm>
  36 #include <sstream>
  37
  38 using namespace std;
  39 using namespace lyx::support;
  40
  41 namespace lyx {
  42
  43 namespace {
  44
  45 std::string fontToDocBookTag(xml::FontTypes type)
  46 {
  47         switch (type) {
  48         case xml::FontTypes::FT_EMPH:
  49         case xml::FontTypes::FT_BOLD:
  50                 return "emphasis";
  51         case xml::FontTypes::FT_NOUN:
  52                 return "person";
  53         case xml::FontTypes::FT_UBAR:
  54         case xml::FontTypes::FT_WAVE:
  55         case xml::FontTypes::FT_DBAR:
  56         case xml::FontTypes::FT_SOUT:
  57         case xml::FontTypes::FT_XOUT:
  58         case xml::FontTypes::FT_ITALIC:
  59         case xml::FontTypes::FT_UPRIGHT:
  60         case xml::FontTypes::FT_SLANTED:
  61         case xml::FontTypes::FT_SMALLCAPS:
  62         case xml::FontTypes::FT_ROMAN:
  63         case xml::FontTypes::FT_SANS:
  64                 return "emphasis";
  65         case xml::FontTypes::FT_TYPE:
  66                 return "code";
  67         case xml::FontTypes::FT_SIZE_TINY:
  68         case xml::FontTypes::FT_SIZE_SCRIPT:
  69         case xml::FontTypes::FT_SIZE_FOOTNOTE:
  70         case xml::FontTypes::FT_SIZE_SMALL:
  71         case xml::FontTypes::FT_SIZE_NORMAL:
  72         case xml::FontTypes::FT_SIZE_LARGE:
  73         case xml::FontTypes::FT_SIZE_LARGER:
  74         case xml::FontTypes::FT_SIZE_LARGEST:
  75         case xml::FontTypes::FT_SIZE_HUGE:
  76         case xml::FontTypes::FT_SIZE_HUGER:
  77         case xml::FontTypes::FT_SIZE_INCREASE:
  78         case xml::FontTypes::FT_SIZE_DECREASE:
  79                 return "emphasis";
  80         default:
  81                 return "";
  82         }
  83 }
  84
  85
  86 string fontToRole(xml::FontTypes type)
  87 {
  88         // Specific fonts are achieved with roles. The only common ones are "" for basic emphasis,
  89         // and "bold"/"strong" for bold. With some specific options, other roles are copied into
  90         // HTML output (via the DocBook XSLT sheets); otherwise, if not recognised, they are just ignored.
  91         // Hence, it is not a problem to have many roles by default here.
  92         // See https://www.sourceware.org/ml/docbook/2003-05/msg00269.html
  93         switch (type) {
  94         case xml::FontTypes::FT_ITALIC:
  95         case xml::FontTypes::FT_EMPH:
  96                 return "";
  97         case xml::FontTypes::FT_BOLD:
  98                 return "bold";
  99         case xml::FontTypes::FT_NOUN: // Outputs a <person>
 100         case xml::FontTypes::FT_TYPE: // Outputs a <code>
 101                 return "";
 102         case xml::FontTypes::FT_UBAR:
 103                 return "underline";
 104
 105         // All other roles are non-standard for DocBook.
 106
 107         case xml::FontTypes::FT_WAVE:
 108                 return "wave";
 109         case xml::FontTypes::FT_DBAR:
 110                 return "dbar";
 111         case xml::FontTypes::FT_SOUT:
 112                 return "sout";
 113         case xml::FontTypes::FT_XOUT:
 114                 return "xout";
 115         case xml::FontTypes::FT_UPRIGHT:
 116                 return "upright";
 117         case xml::FontTypes::FT_SLANTED:
 118                 return "slanted";
 119         case xml::FontTypes::FT_SMALLCAPS:
 120                 return "smallcaps";
 121         case xml::FontTypes::FT_ROMAN:
 122                 return "roman";
 123         case xml::FontTypes::FT_SANS:
 124                 return "sans";
 125         case xml::FontTypes::FT_SIZE_TINY:
 126                 return "tiny";
 127         case xml::FontTypes::FT_SIZE_SCRIPT:
 128                 return "size_script";
 129         case xml::FontTypes::FT_SIZE_FOOTNOTE:
 130                 return "size_footnote";
 131         case xml::FontTypes::FT_SIZE_SMALL:
 132                 return "size_small";
 133         case xml::FontTypes::FT_SIZE_NORMAL:
 134                 return "size_normal";
 135         case xml::FontTypes::FT_SIZE_LARGE:
 136                 return "size_large";
 137         case xml::FontTypes::FT_SIZE_LARGER:
 138                 return "size_larger";
 139         case xml::FontTypes::FT_SIZE_LARGEST:
 140                 return "size_largest";
 141         case xml::FontTypes::FT_SIZE_HUGE:
 142                 return "size_huge";
 143         case xml::FontTypes::FT_SIZE_HUGER:
 144                 return "size_huger";
 145         case xml::FontTypes::FT_SIZE_INCREASE:
 146                 return "size_increase";
 147         case xml::FontTypes::FT_SIZE_DECREASE:
 148                 return "size_decrease";
 149         default:
 150                 return "";
 151         }
 152 }
 153
 154
 155 string fontToAttribute(xml::FontTypes type) {
 156         // If there is a role (i.e. nonstandard use of a tag), output the attribute. Otherwise, the sheer tag is sufficient
 157         // for the font.
 158         string role = fontToRole(type);
 159         if (!role.empty()) {
 160                 return "role='" + role + "'";
 161         } else {
 162                 return "";
 163         }
 164 }
 165
 166
 167 // Convenience functions to open and close tags. First, very low-level ones to ensure a consistent new-line behaviour.
 168 // Block style:
 169 //        Content before
 170 //        <blocktag>
 171 //          Contents of the block.
 172 //        </blocktag>
 173 //        Content after
 174 // Paragraph style:
 175 //        Content before
 176 //          <paratag>Contents of the paragraph.</paratag>
 177 //        Content after
 178 // Inline style:
 179 //    Content before<inlinetag>Contents of the paragraph.</inlinetag>Content after
 180
 181 void openInlineTag(XMLStream & xs, const std::string & tag, const std::string & attr)
 182 {
 183         xs << xml::StartTag(tag, attr);
 184 }
 185
 186
 187 void closeInlineTag(XMLStream & xs, const std::string & tag)
 188 {
 189         xs << xml::EndTag(tag);
 190 }
 191
 192
 193 void openParTag(XMLStream & xs, const std::string & tag, const std::string & attr)
 194 {
 195         if (!xs.isLastTagCR())
 196                 xs << xml::CR();
 197         xs << xml::StartTag(tag, attr);
 198 }
 199
 200
 201 void closeParTag(XMLStream & xs, const std::string & tag)
 202 {
 203         xs << xml::EndTag(tag);
 204         xs << xml::CR();
 205 }
 206
 207
 208 void openBlockTag(XMLStream & xs, const std::string & tag, const std::string & attr)
 209 {
 210         if (!xs.isLastTagCR())
 211                 xs << xml::CR();
 212         xs << xml::StartTag(tag, attr);
 213         xs << xml::CR();
 214 }
 215
 216
 217 void closeBlockTag(XMLStream & xs, const std::string & tag)
 218 {
 219         if (!xs.isLastTagCR())
 220                 xs << xml::CR();
 221         xs << xml::EndTag(tag);
 222         xs << xml::CR();
 223 }
 224
 225
 226 void openTag(XMLStream & xs, const std::string & tag, const std::string & attr, const std::string & tagtype)
 227 {
 228         if (tag.empty() || tag == "NONE")
 229                 return;
 230
 231         if (tag == "para" || tagtype == "paragraph") // Special case for <para>: always considered as a paragraph.
 232                 openParTag(xs, tag, attr);
 233         else if (tagtype == "block")
 234                 openBlockTag(xs, tag, attr);
 235         else if (tagtype == "inline")
 236                 openInlineTag(xs, tag, attr);
 237         else
 238                 xs.writeError("Unrecognised tag type '" + tagtype + "' for '" + tag + " " + attr + "'");
 239 }
 240
 241
 242 void closeTag(XMLStream & xs, const std::string & tag, const std::string & tagtype)
 243 {
 244         if (tag.empty() || tag == "NONE")
 245                 return;
 246
 247         if (tag == "para" || tagtype == "paragraph") // Special case for <para>: always considered as a paragraph.
 248                 closeParTag(xs, tag);
 249         else if (tagtype == "block")
 250                 closeBlockTag(xs, tag);
 251         else if (tagtype == "inline")
 252                 closeInlineTag(xs, tag);
 253         else
 254                 xs.writeError("Unrecognised tag type '" + tagtype + "' for '" + tag + "'");
 255 }
 256
 257
 258 // Higher-level convenience functions.
 259
 260 void openParTag(XMLStream & xs, const Paragraph * par, const Paragraph * prevpar)
 261 {
 262         Layout const & lay = par->layout();
 263
 264         if (par == prevpar)
 265                 prevpar = nullptr;
 266
 267         // When should the wrapper be opened here? Only if the previous paragraph has the SAME wrapper tag
 268         // (usually, they won't have the same layout) and the CURRENT one allows merging.
 269         // The main use case is author information in several paragraphs: if the name of the author is the
 270         // first paragraph of an author, then merging with the previous tag does not make sense. Say the
 271         // next paragraph is the affiliation, then it should be output in the same <author> tag (different
 272         // layout, same wrapper tag).
 273         bool openWrapper = lay.docbookwrappertag() != "NONE";
 274         if (prevpar != nullptr) {
 275                 Layout const & prevlay = prevpar->layout();
 276                 if (prevlay.docbookwrappertag() != "NONE") {
 277                         openWrapper = prevlay.docbookwrappertag() == lay.docbookwrappertag()
 278                                         && !lay.docbookwrappermergewithprevious();
 279                 }
 280         }
 281
 282         // Main logic.
 283         if (openWrapper)
 284                 openTag(xs, lay.docbookwrappertag(), lay.docbookwrapperattr(), lay.docbookwrappertagtype());
 285
 286         const string & tag = lay.docbooktag();
 287         if (tag != "NONE") {
 288                 auto xmltag = xml::ParTag(tag, lay.docbookattr());
 289                 if (!xs.isTagOpen(xmltag, 1)) // Don't nest a paragraph directly in a paragraph.
 290                         // TODO: required or not?
 291                         // TODO: avoid creating a ParTag object just for this query...
 292                         openTag(xs, lay.docbooktag(), lay.docbookattr(), lay.docbooktagtype());
 293         }
 294
 295         openTag(xs, lay.docbookitemtag(), lay.docbookitemattr(), lay.docbookitemtagtype());
 296         openTag(xs, lay.docbookiteminnertag(), lay.docbookiteminnerattr(), lay.docbookiteminnertagtype());
 297 }
 298
 299
 300 void closeParTag(XMLStream & xs, Paragraph const * par, Paragraph const * nextpar)
 301 {
 302         if (par == nextpar)
 303                 nextpar = nullptr;
 304
 305         // See comment in openParTag.
 306         Layout const & lay = par->layout();
 307         bool closeWrapper = lay.docbookwrappertag() != "NONE";
 308         if (nextpar != nullptr) {
 309                 Layout const & nextlay = nextpar->layout();
 310                 if (nextlay.docbookwrappertag() != "NONE") {
 311                         if (nextpar->getDepth() == par->getDepth()) {
 312                                 // Same depth: the basic condition applies.
 313                                 closeWrapper = nextlay.docbookwrappertag() == lay.docbookwrappertag()
 314                                                && !nextlay.docbookwrappermergewithprevious();
 315                         } else if (nextpar->getDepth() > par->getDepth()) {
 316                                 // The next paragraph is deeper: no need to close the wrapper, only to open it (cf. openParTag).
 317                                 closeWrapper = 0;
 318                         } else {
 319                                 // This paragraph is deeper than the next one: close the wrapper,
 320                                 // disregarding docbookwrappermergewithprevious.
 321                                 // Hypothesis: nextlay.docbookwrappertag() == lay.docbookwrappertag(). TODO: THIS IS WRONG! Loop back until a layout with the right depth is found?
 322                                 closeWrapper = 1L + (long long) par->getDepth() - (long long) nextpar->getDepth(); // > 0, as nextpar->getDepth() < par->getDepth()
 323                         }
 324                 } else {
 325                         if (nextpar->getDepth() == par->getDepth()) {
 326                                 // This is not wrapped: this must be the rest of the item, still within the wrapper.
 327                                 closeWrapper = 1;
 328                         } else if (nextpar->getDepth() > par->getDepth()) {
 329                                 // The next paragraph is deeper: no need to close the wrapper, only to open it (cf. openParTag).
 330                                 closeWrapper = 0;
 331                         } else {
 332                                 // This paragraph is deeper than the next one: close the wrapper,
 333                                 // disregarding docbookwrappermergewithprevious.
 334                                 // Hypothesis: nextlay.docbookwrappertag() == lay.docbookwrappertag(). TODO: THIS IS WRONG! Loop back until a layout with the right depth is found?
 335                                 closeWrapper = 1L + (long long) par->getDepth() - (long long) nextpar->getDepth(); // > 0, as nextpar->getDepth() < par->getDepth()
 336                         }
 337                 }
 338         }
 339
 340         // Main logic.
 341         closeTag(xs, lay.docbookiteminnertag(), lay.docbookiteminnertagtype());
 342         closeTag(xs, lay.docbookitemtag(), lay.docbookitemtagtype());
 343         closeTag(xs, lay.docbooktag(), lay.docbooktagtype());
 344         if (closeWrapper)
 345                 closeTag(xs, lay.docbookwrappertag(), lay.docbookwrappertagtype());
 346 }
 347
 348
 349 void openLabelTag(XMLStream & xs, Layout const & lay) // Mostly for definition lists.
 350 {
 351         openTag(xs, lay.docbookitemlabeltag(), lay.docbookitemlabelattr(), lay.docbookitemlabeltagtype());
 352 }
 353
 354
 355 void closeLabelTag(XMLStream & xs, Layout const & lay)
 356 {
 357         closeTag(xs, lay.docbookitemlabeltag(), lay.docbookitemlabeltagtype());
 358 }
 359
 360
 361 void openItemTag(XMLStream & xs, Layout const & lay)
 362 {
 363         openTag(xs, lay.docbookitemtag(), lay.docbookitemattr(), lay.docbookitemtagtype());
 364 }
 365
 366
 367 void closeItemTag(XMLStream & xs, Layout const & lay)
 368 {
 369         closeTag(xs, lay.docbookitemtag(), lay.docbookitemtagtype());
 370 }
 371
 372
 373 void makeAny(
 374                 Text const &,
 375                 Buffer const &,
 376                 XMLStream &,
 377                 OutputParams const &,
 378                 ParagraphList::const_iterator);
 379
 380
 381 void makeParagraphBibliography(
 382                 Buffer const & buf,
 383                 XMLStream & xs,
 384                 OutputParams const & runparams,
 385                 Text const & text,
 386                 ParagraphList::const_iterator const & par)
 387 {
 388         // If this is the first paragraph in a bibliography, open the bibliography tag.
 389         auto pbegin_before = text.paragraphs().getParagraphBefore(par);
 390         if (pbegin_before->layout().latextype != LATEX_BIB_ENVIRONMENT) {
 391                 xs << xml::StartTag("bibliography");
 392                 xs << xml::CR();
 393         }
 394
 395         // Start the precooked bibliography entry. This is very much like opening a paragraph tag.
 396         // Don't forget the citation ID!
 397         docstring attr;
 398         for (auto i = 0; i < par->size(); ++i) {
 399                 Inset const *ip = par->getInset(i);
 400                 if (!ip)
 401                         continue;
 402                 if (const auto * bibitem = dynamic_cast<const InsetBibitem*>(ip)) {
 403                         attr = from_utf8("xml:id='") + bibitem->getParam("key") + from_utf8("'");
 404                         break;
 405                 }
 406         }
 407         xs << xml::StartTag(from_utf8("bibliomixed"), attr);
 408
 409         // Generate the entry. Concatenate the different parts of the paragraph if any.
 410         auto const begin = text.paragraphs().begin();
 411         auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(std::distance(begin, par)), 0);
 412         for (auto & parXML : pars)
 413                 xs << XMLStream::ESCAPE_NONE << parXML;
 414
 415         // End the precooked bibliography entry.
 416         xs << xml::EndTag("bibliomixed");
 417         xs << xml::CR();
 418
 419         // If this is the last paragraph in a bibliography, close the bibliography tag.
 420         auto const end = text.paragraphs().end();
 421         bool endBibliography = par == end;
 422         if (!endBibliography) {
 423                 auto nextpar = par;
 424                 ++nextpar;
 425                 endBibliography = par->layout().latextype != LATEX_BIB_ENVIRONMENT;
 426         }
 427
 428         if (endBibliography) {
 429                 xs << xml::EndTag("bibliography");
 430                 xs << xml::CR();
 431         }
 432 }
 433
 434
 435 void makeParagraph(
 436                 Buffer const & buf,
 437                 XMLStream & xs,
 438                 OutputParams const & runparams,
 439                 Text const & text,
 440                 ParagraphList::const_iterator const & par)
 441 {
 442         auto const begin = text.paragraphs().begin();
 443         auto const end = text.paragraphs().end();
 444         auto prevpar = text.paragraphs().getParagraphBefore(par);
 445
 446         // We want to open the paragraph tag if:
 447         //   (i) the current layout permits multiple paragraphs
 448         //  (ii) we are either not already inside a paragraph (HTMLIsBlock) OR
 449         //         we are, but this is not the first paragraph
 450         //
 451         // But there is also a special case, and we first see whether we are in it.
 452         // We do not want to open the paragraph tag if this paragraph contains
 453         // only one item, and that item is "inline", i.e., not HTMLIsBlock (such
 454         // as a branch). On the other hand, if that single item has a font change
 455         // applied to it, then we still do need to open the paragraph.
 456         //
 457         // Obviously, this is very fragile. The main reason we need to do this is
 458         // because of branches, e.g., a branch that contains an entire new section.
 459         // We do not really want to wrap that whole thing in a <div>...</div>.
 460         bool special_case = false;
 461         Inset const *specinset = par->size() == 1 ? par->getInset(0) : nullptr;
 462         if (specinset && !specinset->getLayout().htmlisblock()) { // TODO: Convert htmlisblock to a DocBook parameter?
 463                 Layout const &style = par->layout();
 464                 FontInfo const first_font = style.labeltype == LABEL_MANUAL ?
 465                                                                         style.labelfont : style.font;
 466                 FontInfo const our_font =
 467                                 par->getFont(buf.masterBuffer()->params(), 0,
 468                                                          text.outerFont(std::distance(begin, par))).fontInfo();
 469
 470                 if (first_font == our_font)
 471                         special_case = true;
 472         }
 473
 474         // Plain layouts must be ignored.
 475         if (!special_case && buf.params().documentClass().isPlainLayout(par->layout()) && !runparams.docbook_force_pars)
 476                 special_case = true;
 477         // TODO: Could get rid of this with a DocBook equivalent to htmlisblock?
 478         if (!special_case && par->size() == 1 && par->getInset(0)) {
 479                 Inset const * firstInset = par->getInset(0);
 480
 481                 // Floats cannot be in paragraphs.
 482                 special_case = to_utf8(firstInset->layoutName()).substr(0, 6) == "Float:";
 483
 484                 // Bibliographies cannot be in paragraphs.
 485                 if (!special_case && firstInset->asInsetCommand())
 486                         special_case = firstInset->asInsetCommand()->params().getCmdName() == "bibtex";
 487
 488                 // Equations do not deserve their own paragraph (DocBook allows them outside paragraphs).
 489                 if (!special_case && firstInset->asInsetMath())
 490                         special_case = true;
 491
 492                 // ERTs are in comments, not paragraphs.
 493                 if (!special_case && firstInset->lyxCode() == lyx::ERT_CODE)
 494                         special_case = true;
 495
 496                 // Listings should not get into their own paragraph.
 497                 if (!special_case && firstInset->lyxCode() == lyx::LISTINGS_CODE)
 498                         special_case = true;
 499         }
 500
 501         bool const open_par = runparams.docbook_make_pars
 502                                                   && !runparams.docbook_in_par
 503                                                   && !special_case;
 504
 505         // We want to issue the closing tag if either:
 506         //   (i)  We opened it, and either docbook_in_par is false,
 507         //              or we're not in the last paragraph, anyway.
 508         //   (ii) We didn't open it and docbook_in_par is true,
 509         //              but we are in the first par, and there is a next par.
 510         auto nextpar = par;
 511         ++nextpar;
 512         bool const close_par = open_par && (!runparams.docbook_in_par);
 513
 514         // Determine if this paragraph has some real content. Things like new pages are not caught
 515         // by Paragraph::empty(), even though they do not generate anything useful in DocBook.
 516         // Thus, remove all spaces (including new lines: \r, \n) before checking for emptiness.
 517         // std::all_of allows doing this check without having to copy the string.
 518         // Open and close tags around each contained paragraph.
 519         auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(distance(begin, par)), 0);
 520         for (auto & parXML : pars) {
 521                 if (!std::all_of(parXML.begin(), parXML.end(), ::isspace)) {
 522                         if (open_par)
 523                                 openParTag(xs, &*par, prevpar);
 524
 525                         xs << XMLStream::ESCAPE_NONE << parXML;
 526
 527                         if (close_par)
 528                                 closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr);
 529                 }
 530         }
 531 }
 532
 533
 534 void makeEnvironment(Buffer const &buf,
 535                      XMLStream &xs,
 536                      OutputParams const &runparams,
 537                      Text const &text,
 538                      ParagraphList::const_iterator const & par)
 539 {
 540         // TODO: simplify me!
 541         auto const end = text.paragraphs().end();
 542
 543         // Output the opening tag for this environment, but only if it has not been previously opened (condition
 544         // implemented in openParTag).
 545         auto prevpar = text.paragraphs().getParagraphBefore(par);
 546         openParTag(xs, &*par, prevpar); // TODO: switch in layout for par/block?
 547
 548         // Generate the contents of this environment. There is a special case if this is like some environment.
 549         Layout const & style = par->layout();
 550         if (style.latextype == LATEX_COMMAND) {
 551                 // Nothing to do (otherwise, infinite loops).
 552         } else if (style.latextype == LATEX_ENVIRONMENT) {
 553                 // Open a wrapper tag if needed.
 554                 if (style.docbookitemwrappertag() != "NONE")
 555                         openTag(xs, style.docbookitemwrappertag(), style.docbookitemwrapperattr(), style.docbookitemwrappertagtype());
 556
 557                 // Generate the label, if need be. If it is taken from the text, sep != 0 and corresponds to the first
 558                 // character after the label.
 559                 pos_type sep = 0;
 560                 if (style.labeltype != LABEL_NO_LABEL && style.docbookitemlabeltag() != "NONE") {
 561                         // At least one condition must be met:
 562                         //  - this environment is not a list
 563                         //  - if this is a list, the label must not be manual (i.e. it must be taken from the layout)
 564                         if (style.latextype != LATEX_LIST_ENVIRONMENT || style.labeltype != LABEL_MANUAL) {
 565                                 // Usual cases: maybe there is something specified at the layout level. Highly unlikely, though.
 566                                 docstring const lbl = par->params().labelString();
 567
 568                                 if (lbl.empty()) {
 569                                         xs << xml::CR();
 570                                 } else {
 571                                         openLabelTag(xs, style);
 572                                         xs << lbl;
 573                                         closeLabelTag(xs, style);
 574                                 }
 575                         } else {
 576                                 // Only variablelist gets here (or similar items defined as an extension in the layout).
 577                                 openLabelTag(xs, style);
 578                                 sep = par->firstWordDocBook(xs, runparams);
 579                                 closeLabelTag(xs, style);
 580                         }
 581                 }
 582
 583                 // Maybe the item is completely empty, i.e. if the first word ends at the end of the current paragraph
 584                 // AND if the next paragraph doesn't have the same depth (if there is such a paragraph).
 585                 // Common case: there is only the first word on the line, but there is a nested list instead
 586                 // of more text.
 587                 bool emptyItem = false;
 588                 if (sep == par->size()) { // If the separator is already at the end of this paragraph...
 589                         auto next_par = par;
 590                         ++next_par;
 591                         if (next_par == text.paragraphs().end()) // There is no next paragraph.
 592                                 emptyItem = true;
 593                         else // There is a next paragraph: check depth.
 594                                 emptyItem = par->params().depth() >= next_par->params().depth();
 595                 }
 596
 597                 if (emptyItem) {
 598                         // Avoid having an empty item, this is not valid DocBook. A single character is enough to force
 599                         // generation of a full <para>.
 600                         // TODO: this always worked only by magic...
 601                         xs << ' ';
 602                 } else {
 603                         // Generate the rest of the paragraph, if need be. Open as many inner tags as necessary.
 604                         auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(std::distance(text.paragraphs().begin(), par)), sep);
 605                         auto p = pars.begin();
 606                         while (true) {
 607                                 xs << XMLStream::ESCAPE_NONE << *p;
 608                                 ++p;
 609                                 if (p != pars.end()) {
 610                                         closeTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnertagtype());
 611                                         openTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnerattr(), par->layout().docbookiteminnertagtype());
 612                                 } else
 613                                         break;
 614                         }
 615                 }
 616         } else {
 617                 makeAny(text, buf, xs, runparams, par);
 618         }
 619
 620         // Close the environment.
 621         auto nextpar = par;
 622         ++nextpar;
 623         closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr); // TODO: switch in layout for par/block?
 624 }
 625
 626
 627 ParagraphList::const_iterator findEndOfEnvironment(
 628                 ParagraphList::const_iterator const & pstart,
 629                 ParagraphList::const_iterator const & pend)
 630 {
 631         // Copy-paste from XHTML. Should be factored out at some point...
 632
 633         ParagraphList::const_iterator p = pstart;
 634         Layout const & bstyle = p->layout();
 635         size_t const depth = p->params().depth();
 636         for (++p; p != pend; ++p) {
 637                 Layout const & style = p->layout();
 638                 // It shouldn't happen that e.g. a section command occurs inside
 639                 // a quotation environment, at a higher depth, but as of 6/2009,
 640                 // it can happen. We pretend that it's just at lowest depth.
 641                 if (style.latextype == LATEX_COMMAND)
 642                         return p;
 643
 644                 // If depth is down, we're done
 645                 if (p->params().depth() < depth)
 646                         return p;
 647
 648                 // If depth is up, we're not done
 649                 if (p->params().depth() > depth)
 650                         continue;
 651
 652                 // FIXME I am not sure about the first check.
 653                 // Surely we *could* have different layouts that count as
 654                 // LATEX_PARAGRAPH, right?
 655                 if (style.latextype == LATEX_PARAGRAPH || style != bstyle)
 656                         return p;
 657         }
 658         return pend;
 659 }
 660
 661
 662 ParagraphList::const_iterator makeListEnvironment(Buffer const &buf,
 663                                                           XMLStream &xs,
 664                                                           OutputParams const &runparams,
 665                                                           Text const &text,
 666                                                           ParagraphList::const_iterator const & par)
 667 >>>>>>> be6480e59c... DocBook: same refactoring for docbookSimpleAllParagraphs.
 668 {
 669         auto const end = text.paragraphs().end();
 670
 671         // Output the opening tag for this environment, but only if it has not been previously opened (condition
 672         // implemented in openParTag).
 673         auto prevpar = text.paragraphs().getParagraphBefore(par);
 674         openParTag(xs, &*par, prevpar); // TODO: switch in layout for par/block?
 675
 676         // Generate the contents of this environment. There is a special case if this is like some environment.
 677         Layout const & style = par->layout();
 678         if (style.latextype == LATEX_COMMAND) {
 679                 // Nothing to do (otherwise, infinite loops).
 680         } else if (style.latextype == LATEX_ENVIRONMENT ||
 681                         style.latextype == LATEX_LIST_ENVIRONMENT ||
 682                         style.latextype == LATEX_ITEM_ENVIRONMENT) {
 683                 // Open a wrapper tag if needed.
 684                 if (style.docbookitemwrappertag() != "NONE")
 685                         openTag(xs, style.docbookitemwrappertag(), style.docbookitemwrapperattr(), style.docbookitemwrappertagtype());
 686
 687                 // Generate the label, if need be. If it is taken from the text, sep != 0 and corresponds to the first
 688                 // character after the label.
 689                 pos_type sep = 0;
 690                 if (style.labeltype != LABEL_NO_LABEL && style.docbookitemlabeltag() != "NONE") {
 691                         // At least one condition must be met:
 692                         //  - this environment is not a list
 693                         //  - if this is a list, the label must not be manual (i.e. it must be taken from the layout)
 694                         if (style.latextype != LATEX_LIST_ENVIRONMENT || style.labeltype != LABEL_MANUAL) {
 695                                 // Usual cases: maybe there is something specified at the layout level. Highly unlikely, though.
 696                                 docstring const lbl = par->params().labelString();
 697
 698                                 if (lbl.empty()) {
 699                                         xs << xml::CR();
 700                                 } else {
 701                                         openLabelTag(xs, style);
 702                                         xs << lbl;
 703                                         closeLabelTag(xs, style);
 704                                 }
 705                         } else {
 706                                 // Only variablelist gets here (or similar items defined as an extension in the layout).
 707                                 openLabelTag(xs, style);
 708                                 sep = par->firstWordDocBook(xs, runparams);
 709                                 closeLabelTag(xs, style);
 710                         }
 711                 }
 712
 713                 // Maybe the item is completely empty, i.e. if the first word ends at the end of the current paragraph
 714                 // AND if the next paragraph doesn't have the same depth (if there is such a paragraph).
 715                 // Common case: there is only the first word on the line, but there is a nested list instead
 716                 // of more text.
 717                 bool emptyItem = false;
 718                 if (sep == par->size()) { // If the separator is already at the end of this paragraph...
 719                         auto next_par = par;
 720                         ++next_par;
 721                         if (next_par == text.paragraphs().end()) // There is no next paragraph.
 722                                 emptyItem = true;
 723                         else // There is a next paragraph: check depth.
 724                                 emptyItem = par->params().depth() >= next_par->params().depth();
 725                 }
 726
 727                 if (emptyItem) {
 728                         // Avoid having an empty item, this is not valid DocBook. A single character is enough to force
 729                         // generation of a full <para>.
 730                         // TODO: this always worked only by magic...
 731                         xs << ' ';
 732                 } else {
 733                         // Generate the rest of the paragraph, if need be. Open as many inner tags as necessary.
 734                         auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(std::distance(text.paragraphs().begin(), par)), sep);
 735                         auto p = pars.begin();
 736                         while (true) {
 737                                 xs << XMLStream::ESCAPE_NONE << *p;
 738                                 ++p;
 739                                 if (p != pars.end()) {
 740                                         closeTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnertagtype());
 741                                         openTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnerattr(), par->layout().docbookiteminnertagtype());
 742                                 } else
 743                                         break;
 744                         }
 745                 }
 746         } else {
 747                 makeAny(text, buf, xs, runparams, par);
 748         }
 749
 750         // Close the environment.
 751         auto nextpar = par;
 752         ++nextpar;
 753         closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr); // TODO: switch in layout for par/block?
 754 }
 755
 756
 757 void makeCommand(
 758                 Buffer const & buf,
 759                 XMLStream & xs,
 760                 OutputParams const & runparams,
 761                 Text const & text,
 762                 ParagraphList::const_iterator const & par)
 763 {
 764         // Unlike XHTML, no need for labels, as they are handled by DocBook tags.
 765         auto const begin = text.paragraphs().begin();
 766         auto const end = text.paragraphs().end();
 767         auto nextpar = par;
 768         ++nextpar;
 769
 770         // Generate this command.
 771         auto prevpar = text.paragraphs().getParagraphBefore(par);
 772         openParTag(xs, &*par, prevpar);
 773
 774         auto pars = par->simpleDocBookOnePar(buf, runparams,text.outerFont(distance(begin, par)));
 775         for (auto & parXML : pars)
 776                 // TODO: decide what to do with openParTag/closeParTag in new lines.
 777                 xs << XMLStream::ESCAPE_NONE << parXML;
 778
 779         closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr);
 780 }
 781
 782
 783 void makeAny(
 784                 Text const &text,
 785                 Buffer const &buf,
 786                 XMLStream &xs,
 787                 OutputParams const &ourparams,
 788                 ParagraphList::const_iterator par)
 789 {
 790         switch (par->layout().latextype) {
 791         case LATEX_COMMAND:
 792                 makeCommand(buf, xs, ourparams, text, par);
 793                 break;
 794         case LATEX_ENVIRONMENT:
 795         case LATEX_LIST_ENVIRONMENT:
 796         case LATEX_ITEM_ENVIRONMENT:
 797                 makeEnvironment(buf, xs, ourparams, text, par);
 798                 break;
 799         case LATEX_PARAGRAPH:
 800                 makeParagraph(buf, xs, ourparams, text, par);
 801                 break;
 802         case LATEX_BIB_ENVIRONMENT:
 803                 makeParagraphBibliography(buf, xs, ourparams, text, par);
 804                 break;
 805         }
 806 }
 807
 808
 809 using DocBookDocumentSectioning = tuple<bool, pit_type>;
 810
 811
 812 struct DocBookInfoTag
 813 {
 814         const set<pit_type> shouldBeInInfo;
 815         const set<pit_type> mustBeInInfo;
 816         const set<pit_type> abstract;
 817         pit_type bpit;
 818         pit_type epit;
 819
 820         DocBookInfoTag(const set<pit_type> & shouldBeInInfo, const set<pit_type> & mustBeInInfo,
 821                                    const set<pit_type> & abstract, pit_type bpit, pit_type epit) :
 822                                    shouldBeInInfo(shouldBeInInfo), mustBeInInfo(mustBeInInfo), abstract(abstract),
 823                                    bpit(bpit), epit(epit) {}
 824 };
 825
 826
 827 DocBookDocumentSectioning hasDocumentSectioning(ParagraphList const &paragraphs, pit_type bpit, pit_type const epit) {
 828         bool documentHasSections = false;
 829
 830         while (bpit < epit) {
 831                 Layout const &style = paragraphs[bpit].layout();
 832                 documentHasSections |= style.category() == from_utf8("Sectioning");
 833
 834                 if (documentHasSections)
 835                         break;
 836                 bpit += 1;
 837         }
 838         // Paragraphs before the first section: [ runparams.par_begin ; eppit )
 839
 840         return make_tuple(documentHasSections, bpit);
 841 }
 842
 843
 844 bool hasOnlyNotes(Paragraph const & par)
 845 {
 846         // Precondition: the paragraph is not empty. Otherwise, the function will always return true...
 847         for (int i = 0; i < par.size(); ++i)
 848                 // If you find something that is not an inset (like actual text) or an inset that is not a note,
 849                 // return false.
 850                 if (!par.isInset(i) || !dynamic_cast<InsetNote *>(par.insetList().get(i)))
 851                         return false;
 852         return true;
 853 }
 854
 855
 856 DocBookInfoTag getParagraphsWithInfo(ParagraphList const &paragraphs, pit_type bpit, pit_type const epit) {
 857         set<pit_type> shouldBeInInfo;
 858         set<pit_type> mustBeInInfo;
 859         set<pit_type> abstract;
 860
 861         // Find the first non empty paragraph by mutating bpit.
 862         while (bpit < epit) {
 863                 Paragraph const &par = paragraphs[bpit];
 864                 if (par.empty() || hasOnlyNotes(par))
 865                         bpit += 1;
 866                 else
 867                         break;
 868         }
 869
 870         // Find the last info-like paragraph.
 871         pit_type cpit = bpit;
 872         bool hasAbstractLayout = false;
 873         while (cpit < epit) {
 874                 // Skip paragraphs only containing one note.
 875                 Paragraph const & par = paragraphs[cpit];
 876                 if (hasOnlyNotes(par)) {
 877                         cpit += 1;
 878                         continue;
 879                 }
 880
 881                 if (par.layout().docbookabstract())
 882                         hasAbstractLayout = true;
 883
 884                 // Based on layout information, store this paragraph in one set: should be in <info>, must be.
 885                 Layout const &style = par.layout();
 886
 887                 if (style.docbookininfo() == "always") {
 888                         mustBeInInfo.emplace(cpit);
 889                 } else if (style.docbookininfo() == "maybe") {
 890                         shouldBeInInfo.emplace(cpit);
 891                 } else {
 892                         // Hypothesis: the <info> parts should be grouped together near the beginning bpit.
 893                         // There may be notes in between, but nothing else.
 894                         break;
 895                 }
 896                 cpit += 1;
 897         }
 898         // Now, cpit points to the last paragraph that has things that could go in <info>.
 899         // bpit is the beginning of the <info> part.
 900
 901         // Go once again through the list of paragraphs to find the abstract. If there is an abstract
 902         // layout, only consider it. Otherwise, an abstract is just a sequence of paragraphs with text.
 903         if (hasAbstractLayout) {
 904                 pit_type pit = bpit;
 905                 while (pit < cpit) { // Don't overshoot the <info> part.
 906                         if (paragraphs[pit].layout().docbookabstract())
 907                                 abstract.emplace(pit);
 908                         pit++;
 909                 }
 910         } else {
 911                 pit_type lastAbstract = epit + 1; // A nonsensical value.
 912                 docstring lastAbstractLayout;
 913
 914                 pit_type pit = bpit;
 915                 while (pit < cpit) { // Don't overshoot the <info> part.
 916                         const Paragraph & par = paragraphs.at(pit);
 917                         if (!par.insetList().empty()) {
 918                                 for (const auto &i : par.insetList()) {
 919                                         if (i.inset->getText(0) != nullptr) {
 920                                                 if (lastAbstract == epit + 1) {
 921                                                         // First paragraph that matches the heuristic definition of abstract.
 922                                                         lastAbstract = pit;
 923                                                         lastAbstractLayout = par.layout().name();
 924                                                 } else if (pit > lastAbstract + 1 || par.layout().name() != lastAbstractLayout) {
 925                                                         // This is either too far from the last abstract paragraph or doesn't
 926                                                         // have the right layout name, BUT there has already been an abstract
 927                                                         // in this document: done with detecting the abstract.
 928                                                         goto done; // Easier to get out of two nested loops.
 929                                                 }
 930
 931                                                 abstract.emplace(pit);
 932                                                 break;
 933                                         }
 934                                 }
 935                         }
 936                         pit++;
 937                 }
 938         }
 939
 940         done:
 941         return DocBookInfoTag(shouldBeInInfo, mustBeInInfo, abstract, bpit, cpit);
 942 }
 943
 944 } // end anonymous namespace
 945
 946
 947 xml::FontTag docbookStartFontTag(xml::FontTypes type)
 948 {
 949         return xml::FontTag(from_utf8(fontToDocBookTag(type)), from_utf8(fontToAttribute(type)), type);
 950 }
 951
 952
 953 xml::EndFontTag docbookEndFontTag(xml::FontTypes type)
 954 {
 955         return xml::EndFontTag(from_utf8(fontToDocBookTag(type)), type);
 956 }
 957
 958
 959 void outputDocBookInfo(
 960                 Text const & text,
 961                 Buffer const & buf,
 962                 XMLStream & xs,
 963                 OutputParams const & runparams,
 964                 ParagraphList const & paragraphs,
 965                 DocBookInfoTag const & info)
 966 {
 967         // Perform an additional check on the abstract. Sometimes, there are many paragraphs that should go
 968         // into the abstract, but none generates actual content. Thus, first generate to a temporary stream,
 969         // then only create the <abstract> tag if these paragraphs generate some content.
 970         // This check must be performed *before* a decision on whether or not to output <info> is made.
 971         bool hasAbstract = !info.abstract.empty();
 972         docstring abstract;
 973         if (hasAbstract) {
 974                 // Generate the abstract XML into a string before further checks.
 975                 odocstringstream os2;
 976                 {
 977                         XMLStream xs2(os2);
 978                         auto bpit = *std::min_element(info.abstract.begin(), info.abstract.end());
 979                         auto epit = 1 + *std::max_element(info.abstract.begin(), info.abstract.end());
 980                         // info.abstract is inclusive, epit is exclusive, hence +1 for looping.
 981
 982                         while (bpit < epit) {
 983                                 makeAny(text, buf, xs2, runparams, paragraphs.iterator_at(bpit));
 984                                 bpit += 1;
 985                         }
 986                 }
 987
 988                 // Actually output the abstract if there is something to do. Don't count line feeds or spaces in this,
 989                 // even though they must be properly output if there is some abstract.
 990                 abstract = os2.str();
 991                 docstring cleaned = abstract;
 992                 cleaned.erase(std::remove_if(cleaned.begin(), cleaned.end(), ::isspace), cleaned.end());
 993
 994                 // Nothing? Then there is no abstract!
 995                 if (cleaned.empty())
 996                         hasAbstract = false;
 997         }
 998
 999         // The abstract must go in <info>. Otherwise, decide whether to open <info> based on the layouts.
1000         bool needInfo = !info.mustBeInInfo.empty() || hasAbstract;
1001
1002         // Start the <info> tag if required.
1003         if (needInfo) {
1004                 xs.startDivision(false);
1005                 xs << xml::StartTag("info");
1006                 xs << xml::CR();
1007         }
1008
1009         // Output the elements that should go in <info>, before and after the abstract.
1010         for (auto pit : info.shouldBeInInfo) { // Typically, the title: these elements are so important and ubiquitous
1011                 // that mandating a wrapper like <info> would repel users. Thus, generate them first.
1012                 makeAny(text, buf, xs, runparams, paragraphs.iterator_at(pit));
1013         }
1014         for (auto pit : info.mustBeInInfo) {
1015                 if (info.abstract.find(pit) == info.abstract.end()) // The abstract must be in info, but is dealt with after.
1016                         makeAny(text, buf, xs, runparams, paragraphs.iterator_at(pit));
1017         }
1018
1019         // Always output the abstract as the last item of the <info>, as it requires special treatment (especially if
1020         // it contains several paragraphs that are empty).
1021         if (hasAbstract) {
1022 //              string tag = paragraphs[*info.abstract.begin()].layout().docbookforceabstracttag();
1023 //              if (tag == "NONE")
1024 //                      tag = "abstract";
1025 //
1026 //              xs << xml::StartTag(tag);
1027 //              xs << xml::CR();
1028                 xs << XMLStream::ESCAPE_NONE << abstract;
1029 //              xs << xml::EndTag(tag);
1030 //              xs << xml::CR();
1031         }
1032
1033         // End the <info> tag if it was started.
1034         if (needInfo) {
1035                 xs << xml::EndTag("info");
1036                 xs << xml::CR();
1037                 xs.endDivision();
1038         }
1039 }
1040
1041
1042 void docbookFirstParagraphs(
1043                 Text const &text,
1044                 Buffer const &buf,
1045                 XMLStream &xs,
1046                 OutputParams const &runparams,
1047                 pit_type epit)
1048 {
1049         // Handle the beginning of the document, supposing it has sections.
1050         // Major role: output the first <info> tag.
1051
1052         ParagraphList const &paragraphs = text.paragraphs();
1053         pit_type bpit = runparams.par_begin;
1054         DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, epit);
1055         outputDocBookInfo(text, buf, xs, runparams, paragraphs, info);
1056 }
1057
1058
1059 void docbookSimpleAllParagraphs(
1060                 Text const & text,
1061                 Buffer const & buf,
1062                 XMLStream & xs,
1063                 OutputParams const & runparams)
1064 {
1065         // Handle the given text, supposing it has no sections (i.e. a "simple" text). The input may vary in length
1066         // between a single paragraph to a whole document.
1067
1068         // First, the <info> tag.
1069         ParagraphList const &paragraphs = text.paragraphs();
1070         pit_type bpit = runparams.par_begin;
1071         pit_type const epit = runparams.par_end;
1072         DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, epit);
1073         outputDocBookInfo(text, buf, xs, runparams, paragraphs, info);
1074
1075         // Then, the content. It starts where the <info> ends.
1076         auto par = text.paragraphs().iterator_at(info.epit);
1077         auto end = text.paragraphs().iterator_at(epit);
1078         while (par != end) {
1079                 if (!hasOnlyNotes(*par))
1080                         par = makeAny(text, buf, xs, runparams, par);
1081                 else
1082                         ++par;
1083         }
1084 }
1085
1086
1087 void docbookParagraphs(Text const &text,
1088                                            Buffer const &buf,
1089                                            XMLStream &xs,
1090                                            OutputParams const &runparams) {
1091         ParagraphList const &paragraphs = text.paragraphs();
1092         if (runparams.par_begin == runparams.par_end) {
1093                 runparams.par_begin = 0;
1094                 runparams.par_end = paragraphs.size();
1095         }
1096         pit_type bpit = runparams.par_begin;
1097         pit_type const epit = runparams.par_end;
1098         LASSERT(bpit < epit,
1099                         {
1100                                 xs << XMLStream::ESCAPE_NONE << "<!-- DocBook output error! -->\n";
1101                                 return;
1102                         });
1103
1104         std::stack<std::pair<int, string>> headerLevels; // Used to determine when to open/close sections: store the depth
1105         // of the section and the tag that was used to open it.
1106
1107         // Detect whether the document contains sections. If there are no sections, there can be no automatically
1108         // discovered abstract.
1109         bool documentHasSections;
1110         pit_type eppit;
1111         tie(documentHasSections, eppit) = hasDocumentSectioning(paragraphs, bpit, epit);
1112
1113         if (documentHasSections) {
1114                 docbookFirstParagraphs(text, buf, xs, runparams, eppit);
1115                 bpit = eppit;
1116         } else {
1117                 docbookSimpleAllParagraphs(text, buf, xs, runparams);
1118                 return;
1119         }
1120
1121         bool currentlyInAppendix = false;
1122
1123         auto par = text.paragraphs().iterator_at(bpit);
1124         auto end = text.paragraphs().iterator_at(epit);
1125         while (par != end) {
1126                 OutputParams ourparams = runparams;
1127
1128                 if (par->params().startOfAppendix())
1129                         currentlyInAppendix = true;
1130                 if (hasOnlyNotes(*par)) {
1131                         ++par;
1132                         continue;
1133                 }
1134
1135                 Layout const &style = par->layout();
1136
1137                 // Think about adding <section> and/or </section>s.
1138                 const bool isLayoutSectioning = style.category() == from_utf8("Sectioning");
1139                 if (isLayoutSectioning) {
1140                         int level = style.toclevel;
1141
1142                         // Need to close a previous section if it has the same level or a higher one (close <section> if opening a <h2>
1143                         // after a <h2>, <h3>, <h4>, <h5> or <h6>). More examples:
1144                         //   - current: h2; back: h1; do not close any <section>
1145                         //   - current: h1; back: h2; close two <section> (first the <h2>, then the <h1>, so a new <h1> can come)
1146                         while (!headerLevels.empty() && level <= headerLevels.top().first) {
1147                                 int stackLevel = headerLevels.top().first;
1148                                 docstring stackTag = from_utf8("</" + headerLevels.top().second + ">");
1149                                 headerLevels.pop();
1150
1151                                 // Output the tag only if it corresponds to a legit section.
1152                                 if (stackLevel != Layout::NOT_IN_TOC)
1153                                         xs << XMLStream::ESCAPE_NONE << stackTag << xml::CR();
1154                         }
1155
1156                         // Open the new section: first push it onto the stack, then output it in DocBook.
1157                         string sectionTag = (currentlyInAppendix && style.docbooksectiontag() == "chapter") ?
1158                                                                 "appendix" : style.docbooksectiontag();
1159                         headerLevels.push(std::make_pair(level, sectionTag));
1160
1161                         // Some sectioning-like elements should not be output (such as FrontMatter).
1162                         if (level != Layout::NOT_IN_TOC) {
1163                                 // Look for a label in the title, i.e. a InsetLabel as a child.
1164                                 docstring id = docstring();
1165                                 for (pos_type i = 0; i < par->size(); ++i) {
1166                                         Inset const *inset = par->getInset(i);
1167                                         if (inset) {
1168                                                 if (auto label = dynamic_cast<InsetLabel const *>(inset)) {
1169                                                         // Generate the attributes for the section if need be.
1170                                                         id += "xml:id=\"" + xml::cleanID(label->screenLabel()) + "\"";
1171
1172                                                         // Don't output the ID as a DocBook <anchor>.
1173                                                         ourparams.docbook_anchors_to_ignore.emplace(label->screenLabel());
1174
1175                                                         // Cannot have multiple IDs per tag.
1176                                                         break;
1177                                                 }
1178                                         }
1179                                 }
1180
1181                                 // Write the open tag for this section.
1182                                 docstring tag = from_utf8("<" + sectionTag);
1183                                 if (!id.empty())
1184                                         tag += from_utf8(" ") + id;
1185                                 tag += from_utf8(">");
1186                                 xs << XMLStream::ESCAPE_NONE << tag;
1187                                 xs << xml::CR();
1188                         }
1189                 }
1190
1191                 // Close all sections before the bibliography.
1192                 // TODO: Only close all when the bibliography is at the end of the document? Or force to output the bibliography at the end of the document? Or don't care (as allowed by DocBook)?
1193                 auto insetsLength = distance(par->insetList().begin(), par->insetList().end());
1194                 if (insetsLength > 0) {
1195                         Inset const *firstInset = par->getInset(0);
1196                         if (firstInset && dynamic_cast<InsetBibtex const *>(firstInset)) {
1197                                 while (!headerLevels.empty()) {
1198                                         int level = headerLevels.top().first;
1199                                         docstring tag = from_utf8("</" + headerLevels.top().second + ">");
1200                                         headerLevels.pop();
1201
1202                                         // Output the tag only if it corresponds to a legit section.
1203                                         if (level != Layout::NOT_IN_TOC) {
1204                                                 xs << XMLStream::ESCAPE_NONE << tag;
1205                                                 xs << xml::CR();
1206                                         }
1207                                 }
1208                         }
1209                 }
1210
1211                 // Generate this paragraph.
1212                 makeAny(text, buf, xs, ourparams, par);
1213         }
1214
1215         // If need be, close <section>s, but only at the end of the document (otherwise, dealt with at the beginning
1216         // of the loop).
1217         while (!headerLevels.empty() && headerLevels.top().first > Layout::NOT_IN_TOC) {
1218                 docstring tag = from_utf8("</" + headerLevels.top().second + ">");
1219                 headerLevels.pop();
1220                 xs << XMLStream::ESCAPE_NONE << tag;
1221                 xs << xml::CR();
1222         }
1223 }
1224
1225 } // namespace lyx