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 "Layout.h"
  20 #include "OutputParams.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 "insets/InsetNote.h"
  32
  33 #include "support/convert.h"
  34 #include "support/debug.h"
  35 #include "support/lassert.h"
  36 #include "support/lstrings.h"
  37 #include "support/textutils.h"
  38
  39 #include <stack>
  40 #include <iostream>
  41 #include <algorithm>
  42
  43 using namespace std;
  44 using namespace lyx::support;
  45
  46 namespace lyx {
  47
  48 namespace {
  49
  50 std::string const fontToDocBookTag(xml::FontTypes type)
  51 {
  52         switch (type) {
  53         case xml::FontTypes::FT_EMPH:
  54         case xml::FontTypes::FT_BOLD:
  55                 return "emphasis";
  56         case xml::FontTypes::FT_NOUN:
  57                 return "person";
  58         case xml::FontTypes::FT_UBAR:
  59         case xml::FontTypes::FT_WAVE:
  60         case xml::FontTypes::FT_DBAR:
  61         case xml::FontTypes::FT_SOUT:
  62         case xml::FontTypes::FT_XOUT:
  63         case xml::FontTypes::FT_ITALIC:
  64         case xml::FontTypes::FT_UPRIGHT:
  65         case xml::FontTypes::FT_SLANTED:
  66         case xml::FontTypes::FT_SMALLCAPS:
  67         case xml::FontTypes::FT_ROMAN:
  68         case xml::FontTypes::FT_SANS:
  69                 return "emphasis";
  70         case xml::FontTypes::FT_TYPE:
  71                 return "code";
  72         case xml::FontTypes::FT_SIZE_TINY:
  73         case xml::FontTypes::FT_SIZE_SCRIPT:
  74         case xml::FontTypes::FT_SIZE_FOOTNOTE:
  75         case xml::FontTypes::FT_SIZE_SMALL:
  76         case xml::FontTypes::FT_SIZE_NORMAL:
  77         case xml::FontTypes::FT_SIZE_LARGE:
  78         case xml::FontTypes::FT_SIZE_LARGER:
  79         case xml::FontTypes::FT_SIZE_LARGEST:
  80         case xml::FontTypes::FT_SIZE_HUGE:
  81         case xml::FontTypes::FT_SIZE_HUGER:
  82         case xml::FontTypes::FT_SIZE_INCREASE:
  83         case xml::FontTypes::FT_SIZE_DECREASE:
  84                 return "emphasis";
  85         default:
  86                 return "";
  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:
 104                 return ""; // Outputs a <person>
 105         case xml::FontTypes::FT_TYPE:
 106                 return ""; // Outputs a <code>
 107         case xml::FontTypes::FT_UBAR:
 108                 return "underline";
 109
 110                 // All other roles are non-standard for DocBook.
 111
 112         case xml::FontTypes::FT_WAVE:
 113                 return "wave";
 114         case xml::FontTypes::FT_DBAR:
 115                 return "dbar";
 116         case xml::FontTypes::FT_SOUT:
 117                 return "sout";
 118         case xml::FontTypes::FT_XOUT:
 119                 return "xout";
 120         case xml::FontTypes::FT_UPRIGHT:
 121                 return "upright";
 122         case xml::FontTypes::FT_SLANTED:
 123                 return "slanted";
 124         case xml::FontTypes::FT_SMALLCAPS:
 125                 return "smallcaps";
 126         case xml::FontTypes::FT_ROMAN:
 127                 return "roman";
 128         case xml::FontTypes::FT_SANS:
 129                 return "sans";
 130         case xml::FontTypes::FT_SIZE_TINY:
 131                 return "tiny";
 132         case xml::FontTypes::FT_SIZE_SCRIPT:
 133                 return "size_script";
 134         case xml::FontTypes::FT_SIZE_FOOTNOTE:
 135                 return "size_footnote";
 136         case xml::FontTypes::FT_SIZE_SMALL:
 137                 return "size_small";
 138         case xml::FontTypes::FT_SIZE_NORMAL:
 139                 return "size_normal";
 140         case xml::FontTypes::FT_SIZE_LARGE:
 141                 return "size_large";
 142         case xml::FontTypes::FT_SIZE_LARGER:
 143                 return "size_larger";
 144         case xml::FontTypes::FT_SIZE_LARGEST:
 145                 return "size_largest";
 146         case xml::FontTypes::FT_SIZE_HUGE:
 147                 return "size_huge";
 148         case xml::FontTypes::FT_SIZE_HUGER:
 149                 return "size_huger";
 150         case xml::FontTypes::FT_SIZE_INCREASE:
 151                 return "size_increase";
 152         case xml::FontTypes::FT_SIZE_DECREASE:
 153                 return "size_decrease";
 154         default:
 155                 return "";
 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 } // end anonymous namespace
 171
 172
 173 xml::FontTag docbookStartFontTag(xml::FontTypes type)
 174 {
 175         return xml::FontTag(from_utf8(fontToDocBookTag(type)), from_utf8(fontToAttribute(type)), type);
 176 }
 177
 178
 179 xml::EndFontTag docbookEndFontTag(xml::FontTypes type)
 180 {
 181         return xml::EndFontTag(from_utf8(fontToDocBookTag(type)), type);
 182 }
 183
 184
 185 namespace {
 186
 187 // convenience functions
 188
 189 void openParTag(XMLStream &xs, Layout const &lay)
 190 {
 191         if (lay.docbookwrappertag() != "NONE") {
 192                 xs << xml::StartTag(lay.docbookwrappertag(), lay.docbookwrapperattr());
 193         }
 194
 195         string tag = lay.docbooktag();
 196         if (tag == "Plain Layout")
 197                 tag = "para";
 198
 199         xs << xml::ParTag(tag, lay.docbookattr());
 200 }
 201
 202
 203 void closeTag(XMLStream &xs, Layout const &lay)
 204 {
 205         string tag = lay.docbooktag();
 206         if (tag == "Plain Layout")
 207                 tag = "para";
 208
 209         xs << xml::EndTag(tag);
 210         if (lay.docbookwrappertag() != "NONE")
 211                 xs << xml::EndTag(lay.docbookwrappertag());
 212 }
 213
 214
 215 void openLabelTag(XMLStream & xs, Layout const & lay) // Mostly for definition lists.
 216 {
 217         xs << xml::StartTag(lay.docbookitemlabeltag(), lay.docbookitemlabelattr());
 218 }
 219
 220
 221 void closeLabelTag(XMLStream & xs, Layout const & lay)
 222 {
 223         xs << xml::EndTag(lay.docbookitemlabeltag());
 224         xs << xml::CR();
 225 }
 226
 227
 228 void openItemTag(XMLStream &xs, Layout const &lay)
 229 {
 230         xs << xml::StartTag(lay.docbookitemtag(), lay.docbookitemattr());
 231 }
 232
 233
 234 // Return true when new elements are output in a paragraph, false otherwise.
 235 bool openInnerItemTag(XMLStream &xs, Layout const &lay)
 236 {
 237         if (lay.docbookiteminnertag() != "NONE") {
 238                 xs << xml::CR();
 239                 xs << xml::ParTag(lay.docbookiteminnertag(), lay.docbookiteminnerattr());
 240
 241                 if (lay.docbookiteminnertag() == "para") {
 242                         return true;
 243                 }
 244         }
 245         return false;
 246 }
 247
 248
 249 void closeInnerItemTag(XMLStream &xs, Layout const &lay)
 250 {
 251         if (lay.docbookiteminnertag()!= "NONE") {
 252                 xs << xml::EndTag(lay.docbookiteminnertag());
 253                 xs << xml::CR();
 254         }
 255 }
 256
 257
 258 inline void closeItemTag(XMLStream &xs, Layout const &lay)
 259 {
 260         xs << xml::EndTag(lay.docbookitemtag());
 261         xs << xml::CR();
 262 }
 263
 264 // end of convenience functions
 265
 266 ParagraphList::const_iterator findLastParagraph(
 267                 ParagraphList::const_iterator p,
 268                 ParagraphList::const_iterator const & pend) {
 269         for (++p; p != pend && p->layout().latextype == LATEX_PARAGRAPH; ++p);
 270
 271         return p;
 272 }
 273
 274
 275 ParagraphList::const_iterator findEndOfEnvironment(
 276                 ParagraphList::const_iterator const & pstart,
 277                 ParagraphList::const_iterator const & pend)
 278 {
 279         ParagraphList::const_iterator p = pstart;
 280         Layout const &bstyle = p->layout();
 281         size_t const depth = p->params().depth();
 282         for (++p; p != pend; ++p) {
 283                 Layout const &style = p->layout();
 284                 // It shouldn't happen that e.g. a section command occurs inside
 285                 // a quotation environment, at a higher depth, but as of 6/2009,
 286                 // it can happen. We pretend that it's just at lowest depth.
 287                 if (style.latextype == LATEX_COMMAND)
 288                         return p;
 289
 290                 // If depth is down, we're done
 291                 if (p->params().depth() < depth)
 292                         return p;
 293
 294                 // If depth is up, we're not done
 295                 if (p->params().depth() > depth)
 296                         continue;
 297
 298                 // FIXME I am not sure about the first check.
 299                 // Surely we *could* have different layouts that count as
 300                 // LATEX_PARAGRAPH, right?
 301                 if (style.latextype == LATEX_PARAGRAPH || style != bstyle)
 302                         return p;
 303         }
 304         return pend;
 305 }
 306
 307
 308 ParagraphList::const_iterator makeParagraphBibliography(
 309                 Buffer const &buf,
 310                 XMLStream &xs,
 311                 OutputParams const &runparams,
 312                 Text const &text,
 313                 ParagraphList::const_iterator const & pbegin,
 314                 ParagraphList::const_iterator const & pend)
 315 {
 316         auto const begin = text.paragraphs().begin();
 317         auto const end = text.paragraphs().end();
 318
 319         // Find the paragraph *before* pbegin.
 320         ParagraphList::const_iterator pbegin_before = begin;
 321         if (pbegin != begin) {
 322                 ParagraphList::const_iterator pbegin_before_next = begin;
 323                 ++pbegin_before_next;
 324
 325                 while (pbegin_before_next != pbegin) {
 326                         ++pbegin_before;
 327                         ++pbegin_before_next;
 328                 }
 329         }
 330
 331         ParagraphList::const_iterator par = pbegin;
 332
 333         // If this is the first paragraph in a bibliography, open the bibliography tag.
 334         if (pbegin != begin && pbegin_before->layout().latextype != LATEX_BIB_ENVIRONMENT) {
 335                 xs << xml::StartTag("bibliography");
 336                 xs << xml::CR();
 337         }
 338
 339         // Generate the required paragraphs.
 340         for (; par != pend; ++par) {
 341                 // Start the precooked bibliography entry. This is very much like opening a paragraph tag.
 342                 // Don't forget the citation ID!
 343                 docstring attr;
 344                 for (auto i = 0; i < par->size(); ++i) {
 345                         if (par->getInset(0)->lyxCode() == BIBITEM_CODE) {
 346                                 const auto * bibitem = dynamic_cast<const InsetBibitem*>(par->getInset(i));
 347                                 attr = from_utf8("xml:id='") + bibitem->bibLabel() + from_utf8("'");
 348                                 break;
 349                         }
 350                 }
 351                 xs << xml::StartTag(from_utf8("bibliomixed"), attr);
 352
 353                 // Generate the entry.
 354                 par->simpleDocBookOnePar(buf, xs, runparams, text.outerFont(distance(begin, par)), true, true, 0);
 355
 356                 // End the precooked bibliography entry.
 357                 xs << xml::EndTag("bibliomixed");
 358                 xs << xml::CR();
 359         }
 360
 361         // If this is the last paragraph in a bibliography, close the bibliography tag.
 362         if (par == end || par->layout().latextype != LATEX_BIB_ENVIRONMENT) {
 363                 xs << xml::EndTag("bibliography");
 364                 xs << xml::CR();
 365         }
 366
 367         return pend;
 368 }
 369
 370
 371 ParagraphList::const_iterator makeParagraphs(
 372                 Buffer const &buf,
 373                 XMLStream &xs,
 374                 OutputParams const &runparams,
 375                 Text const &text,
 376                 ParagraphList::const_iterator const & pbegin,
 377                 ParagraphList::const_iterator const & pend)
 378 {
 379         ParagraphList::const_iterator const begin = text.paragraphs().begin();
 380         ParagraphList::const_iterator par = pbegin;
 381         for (; par != pend; ++par) {
 382                 Layout const &lay = par->layout();
 383
 384                 // We want to open the paragraph tag if:
 385                 //   (i) the current layout permits multiple paragraphs
 386                 //  (ii) we are either not already inside a paragraph (HTMLIsBlock) OR
 387                 //         we are, but this is not the first paragraph
 388                 //
 389                 // But there is also a special case, and we first see whether we are in it.
 390                 // We do not want to open the paragraph tag if this paragraph contains
 391                 // only one item, and that item is "inline", i.e., not HTMLIsBlock (such
 392                 // as a branch). On the other hand, if that single item has a font change
 393                 // applied to it, then we still do need to open the paragraph.
 394                 //
 395                 // Obviously, this is very fragile. The main reason we need to do this is
 396                 // because of branches, e.g., a branch that contains an entire new section.
 397                 // We do not really want to wrap that whole thing in a <div>...</div>.
 398                 bool special_case = false;
 399                 Inset const *specinset = par->size() == 1 ? par->getInset(0) : 0;
 400                 if (specinset && !specinset->getLayout().htmlisblock()) { // TODO: Convert htmlisblock to a DocBook parameter?
 401                         Layout const &style = par->layout();
 402                         FontInfo const first_font = style.labeltype == LABEL_MANUAL ?
 403                                                                                 style.labelfont : style.font;
 404                         FontInfo const our_font =
 405                                         par->getFont(buf.masterBuffer()->params(), 0,
 406                                                                  text.outerFont(distance(begin, par))).fontInfo();
 407
 408                         if (first_font == our_font)
 409                                 special_case = true;
 410                 }
 411
 412                 // Plain layouts must be ignored.
 413                 if (!special_case && buf.params().documentClass().isPlainLayout(lay) && !runparams.docbook_force_pars)
 414                         special_case = true;
 415                 // TODO: Could get rid of this with a DocBook equivalent to htmlisblock?
 416                 if (!special_case && par->size() == 1 && par->getInset(0)) {
 417                         Inset const * firstInset = par->getInset(0);
 418
 419                         // Floats cannot be in paragraphs.
 420                         special_case = to_ascii(firstInset->layoutName()).substr(0, 6) == "Float:";
 421
 422                         // Bibliographies cannot be in paragraphs.
 423                         if (!special_case && firstInset->asInsetCommand())
 424                                 special_case = firstInset->asInsetCommand()->params().getCmdName() == "bibtex";
 425
 426                         // Equations do not deserve their own paragraph (DocBook allows them outside paragraphs).
 427                         if (!special_case && firstInset->asInsetMath())
 428                                 special_case = true;
 429
 430                         // ERTs are in comments, not paragraphs.
 431                         if (!special_case && firstInset->lyxCode() == lyx::ERT_CODE)
 432                                 special_case = true;
 433
 434                         // Listings should not get into their own paragraph.
 435                         if (!special_case && firstInset->lyxCode() == lyx::LISTINGS_CODE)
 436                                 special_case = true;
 437                 }
 438
 439                 bool const open_par = runparams.docbook_make_pars
 440                                                           && (!runparams.docbook_in_par || par != pbegin)
 441                                                           && !special_case;
 442
 443                 // We want to issue the closing tag if either:
 444                 //   (i)  We opened it, and either docbook_in_par is false,
 445                 //              or we're not in the last paragraph, anyway.
 446                 //   (ii) We didn't open it and docbook_in_par is true,
 447                 //              but we are in the first par, and there is a next par.
 448                 ParagraphList::const_iterator nextpar = par;
 449                 ++nextpar;
 450                 bool const close_par =
 451                                 ((open_par && (!runparams.docbook_in_par || nextpar != pend))
 452                                 || (!open_par && runparams.docbook_in_par && par == pbegin && nextpar != pend));
 453
 454                 if (open_par) {
 455                         openParTag(xs, lay);
 456                 }
 457
 458                 par->simpleDocBookOnePar(buf, xs, runparams, text.outerFont(distance(begin, par)), open_par, close_par, 0);
 459
 460                 if (close_par) {
 461                         closeTag(xs, lay);
 462                         xs << xml::CR();
 463                 }
 464         }
 465         return pend;
 466 }
 467
 468
 469 bool isNormalEnv(Layout const &lay)
 470 {
 471         return lay.latextype == LATEX_ENVIRONMENT
 472                    || lay.latextype == LATEX_BIB_ENVIRONMENT;
 473 }
 474
 475
 476 ParagraphList::const_iterator makeEnvironment(
 477                 Buffer const &buf,
 478                 XMLStream &xs,
 479                 OutputParams const &runparams,
 480                 Text const &text,
 481                 ParagraphList::const_iterator const & pbegin,
 482                 ParagraphList::const_iterator const & pend)
 483 {
 484         ParagraphList::const_iterator const begin = text.paragraphs().begin();
 485         ParagraphList::const_iterator par = pbegin;
 486         Layout const &bstyle = par->layout();
 487         depth_type const origdepth = pbegin->params().depth();
 488
 489         // open tag for this environment
 490         openParTag(xs, bstyle);
 491         xs << xml::CR();
 492
 493         // we will on occasion need to remember a layout from before.
 494         Layout const *lastlay = nullptr;
 495
 496         while (par != pend) {
 497                 Layout const & style = par->layout();
 498                 ParagraphList::const_iterator send;
 499
 500                 // Actual content of this paragraph.
 501                 switch (style.latextype) {
 502                 case LATEX_ENVIRONMENT:
 503                 case LATEX_LIST_ENVIRONMENT:
 504                 case LATEX_ITEM_ENVIRONMENT: {
 505                         // There are two possibilities in this case.
 506                         // One is that we are still in the environment in which we
 507                         // started---which we will be if the depth is the same.
 508                         if (par->params().depth() == origdepth) {
 509                                 LATTEST(bstyle == style);
 510                                 if (lastlay != nullptr) {
 511                                         xs << XMLStream::ESCAPE_NONE << ("<!-- lastlay != nullptr; item tag: " + from_utf8(lastlay->docbookitemtag()) + "; item wrapper tag: " + from_utf8(lastlay->docbookitemwrappertag()) + " -->");
 512                                         closeItemTag(xs, *lastlay);
 513                                         if (lastlay->docbookitemwrappertag() != "NONE") {
 514                                                 xs << XMLStream::ESCAPE_NONE << "<!-- has docbookwrappertag -->";
 515                                                 xs << xml::EndTag(lastlay->docbookitemwrappertag());
 516                                                 xs << xml::CR();
 517                                         }
 518                                         lastlay = nullptr;
 519                                 }
 520
 521                                 // this will be positive if we want to skip the
 522                                 // initial word (if it's been taken for the label).
 523                                 pos_type sep = 0;
 524
 525                                 // Open a wrapper tag if needed.
 526                                 if (style.docbookitemwrappertag() != "NONE") {
 527                                         xs << xml::StartTag(style.docbookitemwrappertag(), style.docbookitemwrapperattr());
 528                                         xs << xml::CR();
 529                                 }
 530
 531                                 // label output
 532                                 if (style.labeltype != LABEL_NO_LABEL &&
 533                                                 style.docbookitemlabeltag() != "NONE") {
 534
 535                                         if (isNormalEnv(style)) {
 536                                                 // in this case, we print the label only for the first
 537                                                 // paragraph (as in a theorem or an abstract).
 538                                                 if (par == pbegin) {
 539                                                         docstring const lbl = pbegin->params().labelString();
 540                                                         if (!lbl.empty()) {
 541                                                                 openLabelTag(xs, style);
 542                                                                 xs << lbl;
 543                                                                 closeLabelTag(xs, style);
 544                                                         }
 545                                                         xs << xml::CR();
 546                                                 }
 547                                         } else { // some kind of list
 548                                                 if (style.labeltype == LABEL_MANUAL) {
 549                                                         // Only variablelist gets here.
 550
 551                                                         openLabelTag(xs, style);
 552                                                         sep = par->firstWordDocBook(xs, runparams);
 553                                                         closeLabelTag(xs, style);
 554                                                         xs << xml::CR();
 555                                                 } else {
 556                                                         openLabelTag(xs, style);
 557                                                         xs << par->params().labelString();
 558                                                         closeLabelTag(xs, style);
 559                                                         xs << xml::CR();
 560                                                 }
 561                                         }
 562                                 } // end label output
 563
 564                                 bool wasInParagraph = runparams.docbook_in_par;
 565                                 openItemTag(xs, style);
 566                                 bool getsIntoParagraph = openInnerItemTag(xs, style);
 567                                 OutputParams rp = runparams;
 568                                 rp.docbook_in_par = wasInParagraph | getsIntoParagraph;
 569
 570                                 par->simpleDocBookOnePar(buf, xs, rp, text.outerFont(distance(begin, par)), true, true, sep);
 571                                 ++par;
 572                                 if (getsIntoParagraph)
 573                                         closeInnerItemTag(xs, style);
 574
 575                                 // We may not want to close the tag yet, in particular:
 576                                 // If we're not at the end of the item...
 577                                 if (par != pend
 578                                         //  and are doing items...
 579                                         && !isNormalEnv(style)
 580                                         // and if the depth has changed...
 581                                         && par->params().depth() != origdepth) {
 582                                         // then we'll save this layout for later, and close it when
 583                                         // we get another item.
 584                                         lastlay = &style;
 585                                 } else {
 586                                         closeItemTag(xs, style);
 587
 588                                         // Eventually, close the item wrapper.
 589                                         if (style.docbookitemwrappertag() != "NONE") {
 590                                                 xs << xml::EndTag(style.docbookitemwrappertag());
 591                                                 xs << xml::CR();
 592                                         }
 593                                 }
 594                         }
 595                         // The other possibility is that the depth has increased.
 596                         else {
 597                                 send = findEndOfEnvironment(par, pend);
 598                                 par = makeEnvironment(buf, xs, runparams, text, par, send);
 599                         }
 600                         break;
 601                 }
 602                 case LATEX_PARAGRAPH:
 603                         send = findLastParagraph(par, pend);
 604                         par = makeParagraphs(buf, xs, runparams, text, par, send);
 605                         break;
 606                 case LATEX_BIB_ENVIRONMENT:
 607                         send = findLastParagraph(par, pend);
 608                         par = makeParagraphBibliography(buf, xs, runparams, text, par, send);
 609                         break;
 610                 case LATEX_COMMAND:
 611                         ++par;
 612                         break;
 613                 }
 614         }
 615
 616         if (lastlay != 0)
 617                 closeItemTag(xs, *lastlay);
 618         closeTag(xs, bstyle);
 619         xs << xml::CR();
 620         return pend;
 621 }
 622
 623
 624 void makeCommand(
 625                 Buffer const & buf,
 626                 XMLStream & xs,
 627                 OutputParams const & runparams,
 628                 Text const & text,
 629                 ParagraphList::const_iterator const & pbegin)
 630 {
 631         Layout const &style = pbegin->layout();
 632
 633         // No need for labels, as they are handled by DocBook tags.
 634
 635         openParTag(xs, style);
 636
 637         ParagraphList::const_iterator const begin = text.paragraphs().begin();
 638         pbegin->simpleDocBookOnePar(buf, xs, runparams,
 639                                                                 text.outerFont(distance(begin, pbegin)));
 640         closeTag(xs, style);
 641         xs << xml::CR();
 642 }
 643
 644 pair<ParagraphList::const_iterator, ParagraphList::const_iterator> makeAny(
 645                 Text const &text,
 646                 Buffer const &buf,
 647                 XMLStream &xs,
 648                 OutputParams const &ourparams,
 649                 ParagraphList::const_iterator par,
 650                 ParagraphList::const_iterator send,
 651                 ParagraphList::const_iterator pend)
 652 {
 653         Layout const & style = par->layout();
 654
 655         switch (style.latextype) {
 656                 case LATEX_COMMAND: {
 657                         // The files with which we are working never have more than
 658                         // one paragraph in a command structure.
 659                         // FIXME
 660                         // if (ourparams.docbook_in_par)
 661                         //   fix it so we don't get sections inside standard, e.g.
 662                         // note that we may then need to make runparams not const, so we
 663                         // can communicate that back.
 664                         // FIXME Maybe this fix should be in the routines themselves, in case
 665                         // they are called from elsewhere.
 666                         makeCommand(buf, xs, ourparams, text, par);
 667                         ++par;
 668                         break;
 669                 }
 670                 case LATEX_ENVIRONMENT:
 671                 case LATEX_LIST_ENVIRONMENT:
 672                 case LATEX_ITEM_ENVIRONMENT: {
 673                         // FIXME Same fix here.
 674                         send = findEndOfEnvironment(par, pend);
 675                         par = makeEnvironment(buf, xs, ourparams, text, par, send);
 676                         break;
 677                 }
 678                 case LATEX_BIB_ENVIRONMENT: {
 679                         send = findLastParagraph(par, pend);
 680                         par = makeParagraphBibliography(buf, xs, ourparams, text, par, send);
 681                         break;
 682                 }
 683                 case LATEX_PARAGRAPH: {
 684                         send = findLastParagraph(par, pend);
 685                         par = makeParagraphs(buf, xs, ourparams, text, par, send);
 686                         break;
 687                 }
 688         }
 689
 690         return make_pair(par, send);
 691 }
 692
 693 } // end anonymous namespace
 694
 695
 696 using DocBookDocumentSectioning = tuple<bool, pit_type>;
 697 using DocBookInfoTag = tuple<set<pit_type>, set<pit_type>, pit_type, pit_type>;
 698
 699
 700 DocBookDocumentSectioning hasDocumentSectioning(ParagraphList const &paragraphs, pit_type bpit, pit_type const epit) {
 701         bool documentHasSections = false;
 702
 703         while (bpit < epit) {
 704                 Layout const &style = paragraphs[bpit].layout();
 705                 documentHasSections |= style.category() == from_utf8("Sectioning");
 706
 707                 if (documentHasSections) {
 708                         break;
 709                 }
 710                 bpit += 1;
 711         }
 712         // Paragraphs before the first section: [ runparams.par_begin ; eppit )
 713
 714         return make_tuple(documentHasSections, bpit);
 715 }
 716
 717
 718 DocBookInfoTag getParagraphsWithInfo(ParagraphList const &paragraphs, pit_type const bpit, pit_type const epit) {
 719         set<pit_type> shouldBeInInfo;
 720         set<pit_type> mustBeInInfo;
 721
 722         pit_type cpit = bpit;
 723         while (cpit < epit) {
 724                 // Skip paragraphs only containing one note.
 725                 Paragraph const &par = paragraphs[cpit];
 726                 if (par.size() == 1 && dynamic_cast<InsetNote*>(paragraphs[cpit].insetList().get(0))) {
 727                         cpit += 1;
 728                         continue;
 729                 }
 730
 731                 // Based on layout information, store this paragraph in one set: should be in <info>, must be.
 732                 Layout const &style = par.layout();
 733
 734                 std::cout << "Name: " << to_utf8(style.name()) << std::endl;
 735                 std::cout << "  DocBook tag: " << style.docbooktag() << std::endl;
 736                 std::cout << "  In info: " << style.docbookininfo() << std::endl;
 737
 738                 if (style.docbookininfo() == "always") {
 739                         mustBeInInfo.emplace(cpit);
 740                 } else if (style.docbookininfo() == "maybe") {
 741                         shouldBeInInfo.emplace(cpit);
 742                 } else {
 743                         // Hypothesis: the <info> parts should be grouped together near the beginning bpit.
 744                         break;
 745                 }
 746                 cpit += 1;
 747         }
 748         // Now, cpit points to the last paragraph that has things that could go in <info>.
 749         // bpit is still the beginning of the <info> part.
 750
 751         return make_tuple(shouldBeInInfo, mustBeInInfo, bpit, cpit);
 752 }
 753
 754
 755 bool hasAbstractBetween(ParagraphList const &paragraphs, pit_type const bpitAbstract, pit_type const epitAbstract)
 756 {
 757         // Hypothesis: the paragraphs between bpitAbstract and epitAbstract can be considered an abstract because they
 758         // are just after a document or part title.
 759         if (epitAbstract - bpitAbstract <= 0)
 760                 return false;
 761
 762         // If there is something between these paragraphs, check if it's compatible with an abstract (i.e. some text).
 763         pit_type bpit = bpitAbstract;
 764         while (bpit < epitAbstract) {
 765                 const Paragraph &p = paragraphs.at(bpit);
 766
 767                 if (p.layout().name() == from_ascii("Abstract"))
 768                         return true;
 769
 770                 if (!p.insetList().empty()) {
 771                         for (const auto &i : p.insetList()) {
 772                                 if (i.inset->getText(0) != nullptr) {
 773                                         return true;
 774                                 }
 775                         }
 776                 }
 777                 bpit++;
 778         }
 779         return false;
 780 }
 781
 782
 783 pit_type generateDocBookParagraphWithoutSectioning(
 784                 Text const & text,
 785                 Buffer const & buf,
 786                 XMLStream & xs,
 787                 OutputParams const & runparams,
 788                 ParagraphList const & paragraphs,
 789                 pit_type bpit,
 790                 pit_type epit)
 791 {
 792         auto par = paragraphs.iterator_at(bpit);
 793         auto lastStartedPar = par;
 794         ParagraphList::const_iterator send;
 795         auto const pend =
 796                         (epit == (int) paragraphs.size()) ?
 797                         paragraphs.end() : paragraphs.iterator_at(epit);
 798
 799         std::cout << "generateDocBookParagraphWithoutSectioning" << std::endl;
 800         while (bpit < epit) {
 801                 std::cout << "iteration; bpit: " << bpit << std::endl;
 802                 tie(par, send) = makeAny(text, buf, xs, runparams, par, send, pend);
 803                 bpit += distance(lastStartedPar, par);
 804                 lastStartedPar = par;
 805         }
 806         std::cout << "generateDocBookParagraphWithoutSectioning has looped; bpit: " << bpit << std::endl;
 807
 808         return bpit;
 809 }
 810
 811
 812 void outputDocBookInfo(
 813                 Text const & text,
 814                 Buffer const & buf,
 815                 XMLStream & xs,
 816                 OutputParams const & runparams,
 817                 ParagraphList const & paragraphs,
 818                 DocBookInfoTag const & info,
 819                 pit_type bpitAbstract,
 820                 pit_type const epitAbstract)
 821 {
 822         // Consider everything between bpitAbstract and epitAbstract (excluded) as paragraphs for the abstract.
 823         // Use bpitAbstract >= epitAbstract to indicate there is no abstract.
 824
 825         set<pit_type> shouldBeInInfo;
 826         set<pit_type> mustBeInInfo;
 827         pit_type bpitInfo;
 828         pit_type epitInfo;
 829         tie(shouldBeInInfo, mustBeInInfo, bpitInfo, epitInfo) = info;
 830
 831         // The abstract must go in <info>.
 832         bool hasAbstract = hasAbstractBetween(paragraphs, bpitAbstract, epitAbstract);
 833         bool needInfo = !mustBeInInfo.empty() || hasAbstract;
 834
 835         // Start the <info> tag if required.
 836         if (needInfo) {
 837                 xs.startDivision(false);
 838                 xs << xml::StartTag("info");
 839                 xs << xml::CR();
 840         }
 841
 842         // Output the elements that should go in <info>.
 843         generateDocBookParagraphWithoutSectioning(text, buf, xs, runparams, paragraphs, bpitInfo, epitInfo);
 844
 845         if (hasAbstract) {
 846                 string tag = paragraphs[bpitAbstract].layout().docbookforceabstracttag();
 847                 if (tag == "NONE")
 848                         tag = "abstract";
 849
 850                 xs << xml::StartTag(tag);
 851                 xs << xml::CR();
 852                 xs.startDivision(false);
 853                 generateDocBookParagraphWithoutSectioning(text, buf, xs, runparams, paragraphs, bpitAbstract, epitAbstract);
 854                 xs.endDivision();
 855                 xs << xml::EndTag(tag);
 856                 xs << xml::CR();
 857         }
 858
 859         // End the <info> tag if it was started.
 860         if (needInfo) {
 861                 xs << xml::EndTag("info");
 862                 xs << xml::CR();
 863                 xs.endDivision();
 864         }
 865 }
 866
 867
 868 void docbookFirstParagraphs(
 869                 Text const &text,
 870                 Buffer const &buf,
 871                 XMLStream &xs,
 872                 OutputParams const &runparams,
 873                 pit_type epit)
 874 {
 875         // Handle the beginning of the document, supposing it has sections.
 876         // Major role: output the first <info> tag.
 877
 878         ParagraphList const &paragraphs = text.paragraphs();
 879         pit_type bpit = runparams.par_begin;
 880         DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, epit);
 881         outputDocBookInfo(text, buf, xs, runparams, paragraphs, info, get<3>(info), epit);
 882 }
 883
 884
 885 bool isParagraphEmpty(const Paragraph &par)
 886 {
 887         InsetList const &insets = par.insetList();
 888         size_t insetsLength = distance(insets.begin(), insets.end());
 889         bool hasParagraphOnlyNote = insetsLength == 1 && insets.get(0) && insets.get(0)->asInsetCollapsible() &&
 890                                                                 dynamic_cast<InsetNote *>(insets.get(0));
 891         return hasParagraphOnlyNote;
 892 }
 893
 894
 895 void docbookSimpleAllParagraphs(
 896                 Text const & text,
 897                 Buffer const & buf,
 898                 XMLStream & xs,
 899                 OutputParams const & runparams)
 900 {
 901         // Handle the document, supposing it has no sections (i.e. a "simple" document).
 902
 903         // First, the <info> tag.
 904         ParagraphList const &paragraphs = text.paragraphs();
 905         pit_type bpit = runparams.par_begin;
 906         pit_type const epit = runparams.par_end;
 907         DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, epit);
 908         outputDocBookInfo(text, buf, xs, runparams, paragraphs, info, 0, 0);
 909         bpit = get<3>(info); // Generate the content starting from the end of the <info> part.
 910
 911         // Then, the content.
 912         ParagraphList::const_iterator const pend =
 913                         (epit == (int) paragraphs.size()) ?
 914                         paragraphs.end() : paragraphs.iterator_at(epit);
 915
 916         while (bpit < epit) {
 917                 auto par = paragraphs.iterator_at(bpit);
 918                 ParagraphList::const_iterator const lastStartedPar = par;
 919                 ParagraphList::const_iterator send;
 920
 921                 if (isParagraphEmpty(*par)) {
 922                         ++par;
 923                         bpit += distance(lastStartedPar, par);
 924                         continue;
 925                 }
 926
 927                 // Generate this paragraph.
 928                 tie(par, send) = makeAny(text, buf, xs, runparams, par, send, pend);
 929                 bpit += distance(lastStartedPar, par);
 930         }
 931 }
 932
 933
 934 void docbookParagraphs(Text const &text,
 935                                            Buffer const &buf,
 936                                            XMLStream &xs,
 937                                            OutputParams const &runparams) {
 938         ParagraphList const &paragraphs = text.paragraphs();
 939         if (runparams.par_begin == runparams.par_end) {
 940                 runparams.par_begin = 0;
 941                 runparams.par_end = paragraphs.size();
 942         }
 943         pit_type bpit = runparams.par_begin;
 944         pit_type const epit = runparams.par_end;
 945         LASSERT(bpit < epit,
 946                         {
 947                                 xs << XMLStream::ESCAPE_NONE << "<!-- DocBook output error! -->\n";
 948                                 return;
 949                         });
 950
 951         ParagraphList::const_iterator const pend =
 952                         (epit == (int) paragraphs.size()) ?
 953                         paragraphs.end() : paragraphs.iterator_at(epit);
 954         std::stack<std::pair<int, string>> headerLevels; // Used to determine when to open/close sections: store the depth
 955         // of the section and the tag that was used to open it.
 956
 957         // Detect whether the document contains sections. If there are no sections, there can be no automatically
 958         // discovered abstract.
 959         bool documentHasSections;
 960         pit_type eppit;
 961         tie(documentHasSections, eppit) = hasDocumentSectioning(paragraphs, bpit, epit);
 962
 963         if (documentHasSections) {
 964                 docbookFirstParagraphs(text, buf, xs, runparams, eppit);
 965                 bpit = eppit;
 966         } else {
 967                 docbookSimpleAllParagraphs(text, buf, xs, runparams);
 968                 return;
 969         }
 970
 971         bool currentlyInAppendix = false;
 972
 973         while (bpit < epit) {
 974                 OutputParams ourparams = runparams;
 975
 976                 auto par = paragraphs.iterator_at(bpit);
 977                 if (par->params().startOfAppendix())
 978                         currentlyInAppendix = true;
 979                 Layout const &style = par->layout();
 980                 ParagraphList::const_iterator const lastStartedPar = par;
 981                 ParagraphList::const_iterator send;
 982
 983                 if (isParagraphEmpty(*par)) {
 984                         ++par;
 985                         bpit += distance(lastStartedPar, par);
 986                         continue;
 987                 }
 988
 989                 // Think about adding <section> and/or </section>s.
 990                 const bool isLayoutSectioning = style.category() == from_utf8("Sectioning");
 991                 if (isLayoutSectioning) {
 992                         int level = style.toclevel;
 993
 994                         // Need to close a previous section if it has the same level or a higher one (close <section> if opening a <h2>
 995                         // after a <h2>, <h3>, <h4>, <h5> or <h6>). More examples:
 996                         //   - current: h2; back: h1; do not close any <section>
 997                         //   - current: h1; back: h2; close two <section> (first the <h2>, then the <h1>, so a new <h1> can come)
 998                         while (!headerLevels.empty() && level <= headerLevels.top().first) {
 999                                 int stackLevel = headerLevels.top().first;
1000                                 docstring stackTag = from_utf8("</" + headerLevels.top().second + ">");
1001                                 headerLevels.pop();
1002
1003                                 // Output the tag only if it corresponds to a legit section.
1004                                 if (stackLevel != Layout::NOT_IN_TOC)
1005                                         xs << XMLStream::ESCAPE_NONE << stackTag << xml::CR();
1006                         }
1007
1008                         // Open the new section: first push it onto the stack, then output it in DocBook.
1009                         string sectionTag = (currentlyInAppendix && style.docbooksectiontag() == "chapter") ?
1010                                                                 "appendix" : style.docbooksectiontag();
1011                         headerLevels.push(std::make_pair(level, sectionTag));
1012
1013                         // Some sectioning-like elements should not be output (such as FrontMatter).
1014                         if (level != Layout::NOT_IN_TOC) {
1015                                 // Look for a label in the title, i.e. a InsetLabel as a child.
1016                                 docstring id = docstring();
1017                                 for (pos_type i = 0; i < par->size(); ++i) {
1018                                         Inset const *inset = par->getInset(i);
1019                                         if (inset) {
1020                                                 if (auto label = dynamic_cast<InsetLabel const *>(inset)) {
1021                                                         // Generate the attributes for the section if need be.
1022                                                         id += "xml:id=\"" + xml::cleanID(label->screenLabel()) + "\"";
1023
1024                                                         // Don't output the ID as a DocBook <anchor>.
1025                                                         ourparams.docbook_anchors_to_ignore.emplace(label->screenLabel());
1026
1027                                                         // Cannot have multiple IDs per tag.
1028                                                         break;
1029                                                 }
1030                                         }
1031                                 }
1032
1033                                 // Write the open tag for this section.
1034                                 docstring tag = from_utf8("<" + sectionTag);
1035                                 if (!id.empty())
1036                                         tag += from_utf8(" ") + id;
1037                                 tag += from_utf8(">");
1038                                 xs << XMLStream::ESCAPE_NONE << tag;
1039                                 xs << xml::CR();
1040                         }
1041                 }
1042
1043                 // Close all sections before the bibliography.
1044                 // 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)?
1045                 auto insetsLength = distance(par->insetList().begin(), par->insetList().end());
1046                 if (insetsLength > 0) {
1047                         Inset const *firstInset = par->getInset(0);
1048                         if (firstInset && dynamic_cast<InsetBibtex const *>(firstInset)) {
1049                                 while (!headerLevels.empty()) {
1050                                         int level = headerLevels.top().first;
1051                                         docstring tag = from_utf8("</" + headerLevels.top().second + ">");
1052                                         headerLevels.pop();
1053
1054                                         // Output the tag only if it corresponds to a legit section.
1055                                         if (level != Layout::NOT_IN_TOC) {
1056                                                 xs << XMLStream::ESCAPE_NONE << tag;
1057                                                 xs << xml::CR();
1058                                         }
1059                                 }
1060                         }
1061                 }
1062
1063                 // Generate this paragraph.
1064                 tie(par, send) = makeAny(text, buf, xs, ourparams, par, send, pend);
1065                 bpit += distance(lastStartedPar, par);
1066         }
1067
1068         // If need be, close <section>s, but only at the end of the document (otherwise, dealt with at the beginning
1069         // of the loop).
1070         while (!headerLevels.empty() && headerLevels.top().first > Layout::NOT_IN_TOC) {
1071                 docstring tag = from_utf8("</" + headerLevels.top().second + ">");
1072                 headerLevels.pop();
1073                 xs << XMLStream::ESCAPE_NONE << tag;
1074                 xs << xml::CR();
1075         }
1076 }
1077
1078 } // namespace lyx