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