src/TextClass.cpp

   1 /**
   2  * \file TextClass.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 Jean-Marc Lasgouttes
   8  * \author Angus Leeming
   9  * \author John Levon
  10  * \author André Pönitz
  11  *
  12  * Full author contact details are available in file CREDITS.
  13  */
  14
  15 #include <config.h>
  16
  17 #include "TextClass.h"
  18
  19 #include "LayoutFile.h"
  20 #include "CiteEnginesList.h"
  21 #include "Color.h"
  22 #include "Counters.h"
  23 #include "Floating.h"
  24 #include "FloatList.h"
  25 #include "Layout.h"
  26 #include "Lexer.h"
  27 #include "Font.h"
  28 #include "ModuleList.h"
  29
  30 #include "frontends/alert.h"
  31
  32 #include "support/lassert.h"
  33 #include "support/debug.h"
  34 #include "support/ExceptionMessage.h"
  35 #include "support/FileName.h"
  36 #include "support/filetools.h"
  37 #include "support/gettext.h"
  38 #include "support/lstrings.h"
  39 #include "support/os.h"
  40 #include "support/TempFile.h"
  41
  42 #include <algorithm>
  43 #include <fstream>
  44 #include <sstream>
  45
  46 #ifdef ERROR
  47 #undef ERROR
  48 #endif
  49
  50 using namespace std;
  51 using namespace lyx::support;
  52
  53 namespace lyx {
  54
  55 // Keep the changes documented in the Customization manual.
  56 //
  57 // If you change this format, then you MUST also make sure that
  58 // your changes do not invalidate the hardcoded layout file in
  59 // LayoutFile.cpp. Additions will never do so, but syntax changes
  60 // could. See LayoutFileList::addEmptyClass() and, especially, the
  61 // definition of the layoutpost string.
  62 // You should also run the development/tools/updatelayouts.py script,
  63 // to update the format of all of our layout files.
  64 //
  65 int const LAYOUT_FORMAT = 80; // spitz: Requires for floats
  66
  67
  68 // Layout format for the current lyx file format. Controls which format is
  69 // targeted by Local Layout > Convert. In master, equal to LAYOUT_FORMAT.
  70 int const LYXFILE_LAYOUT_FORMAT = LAYOUT_FORMAT;
  71
  72
  73 namespace {
  74
  75 class LayoutNamesEqual : public unary_function<Layout, bool> {
  76 public:
  77         LayoutNamesEqual(docstring const & name)
  78                 : name_(name)
  79         {}
  80         bool operator()(Layout const & c) const
  81         {
  82                 return c.name() == name_;
  83         }
  84 private:
  85         docstring name_;
  86 };
  87
  88
  89 bool layout2layout(FileName const & filename, FileName const & tempfile,
  90                    int const format = LAYOUT_FORMAT)
  91 {
  92         FileName const script = libFileSearch("scripts", "layout2layout.py");
  93         if (script.empty()) {
  94                 LYXERR0("Could not find layout conversion "
  95                         "script layout2layout.py.");
  96                 return false;
  97         }
  98
  99         ostringstream command;
 100         command << os::python() << ' ' << quoteName(script.toFilesystemEncoding())
 101                 << " -t " << format
 102                 << ' ' << quoteName(filename.toFilesystemEncoding())
 103                 << ' ' << quoteName(tempfile.toFilesystemEncoding());
 104         string const command_str = command.str();
 105
 106         LYXERR(Debug::TCLASS, "Running `" << command_str << '\'');
 107
 108         cmd_ret const ret = runCommand(command_str);
 109         if (ret.first != 0) {
 110                 if (format == LAYOUT_FORMAT)
 111                         LYXERR0("Conversion of layout with layout2layout.py has failed.");
 112                 return false;
 113         }
 114         return true;
 115 }
 116
 117
 118 string translateReadType(TextClass::ReadType rt)
 119 {
 120         switch (rt) {
 121         case TextClass::BASECLASS:
 122                 return "textclass";
 123         case TextClass::MERGE:
 124                 return "input file";
 125         case TextClass::MODULE:
 126                 return "module file";
 127         case TextClass::CITE_ENGINE:
 128                 return "cite engine";
 129         case TextClass::VALIDATION:
 130                 return "validation";
 131         }
 132         // shutup warning
 133         return string();
 134 }
 135
 136 } // namespace
 137
 138
 139 // This string should not be translated here,
 140 // because it is a layout identifier.
 141 docstring const TextClass::plain_layout_ = from_ascii(N_("Plain Layout"));
 142
 143
 144 /////////////////////////////////////////////////////////////////////////
 145 //
 146 // TextClass
 147 //
 148 /////////////////////////////////////////////////////////////////////////
 149
 150 TextClass::TextClass()
 151         : loaded_(false), tex_class_avail_(false),
 152           opt_enginetype_("authoryear|numerical"), opt_fontsize_("10|11|12"),
 153           opt_pagesize_("default|a4|a5|b5|letter|legal|executive"),
 154           opt_pagestyle_("empty|plain|headings|fancy"), fontsize_format_("$$spt"), pagesize_("default"),
 155           pagesize_format_("$$spaper"), pagestyle_("default"), tablestyle_("default"),
 156           columns_(1), sides_(OneSide), secnumdepth_(3), tocdepth_(3), outputType_(LATEX),
 157           outputFormat_("latex"), has_output_format_(false), defaultfont_(sane_font),
 158           titletype_(TITLE_COMMAND_AFTER), titlename_("maketitle"),
 159           min_toclevel_(0), max_toclevel_(0), maxcitenames_(2),
 160           cite_full_author_list_(true), bibintoc_(false)
 161 {
 162 }
 163
 164
 165 bool TextClass::readStyle(Lexer & lexrc, Layout & lay) const
 166 {
 167         LYXERR(Debug::TCLASS, "Reading style " << to_utf8(lay.name()));
 168         if (!lay.read(lexrc, *this)) {
 169                 LYXERR0("Error parsing style `" << to_utf8(lay.name()) << '\'');
 170                 return false;
 171         }
 172         // Resolve fonts
 173         lay.resfont = lay.font;
 174         lay.resfont.realize(defaultfont_);
 175         lay.reslabelfont = lay.labelfont;
 176         lay.reslabelfont.realize(defaultfont_);
 177         return true; // no errors
 178 }
 179
 180
 181 enum TextClassTags {
 182         TC_OUTPUTTYPE = 1,
 183         TC_OUTPUTFORMAT,
 184         TC_INPUT,
 185         TC_STYLE,
 186         TC_MODIFYSTYLE,
 187         TC_PROVIDESTYLE,
 188         TC_DEFAULTSTYLE,
 189         TC_INSETLAYOUT,
 190         TC_NOINSETLAYOUT,
 191         TC_NOSTYLE,
 192         TC_COLUMNS,
 193         TC_SIDES,
 194         TC_PAGESTYLE,
 195         TC_PAGESIZE,
 196         TC_DEFAULTFONT,
 197         TC_SECNUMDEPTH,
 198         TC_TOCDEPTH,
 199         TC_CLASSOPTIONS,
 200         TC_PREAMBLE,
 201         TC_HTMLPREAMBLE,
 202         TC_HTMLSTYLES,
 203         TC_PROVIDES,
 204         TC_REQUIRES,
 205         TC_PKGOPTS,
 206         TC_LEFTMARGIN,
 207         TC_RIGHTMARGIN,
 208         TC_FLOAT,
 209         TC_COUNTER,
 210         TC_NOCOUNTER,
 211         TC_IFCOUNTER,
 212         TC_NOFLOAT,
 213         TC_TITLELATEXNAME,
 214         TC_TITLELATEXTYPE,
 215         TC_FORMAT,
 216         TC_ADDTOPREAMBLE,
 217         TC_ADDTOHTMLPREAMBLE,
 218         TC_ADDTOHTMLSTYLES,
 219         TC_DEFAULTMODULE,
 220         TC_PROVIDESMODULE,
 221         TC_EXCLUDESMODULE,
 222         TC_HTMLTOCSECTION,
 223         TC_CITEENGINE,
 224         TC_ADDTOCITEENGINE,
 225         TC_CITEENGINETYPE,
 226         TC_CITEFORMAT,
 227         TC_CITEFRAMEWORK,
 228         TC_MAXCITENAMES,
 229         TC_DEFAULTBIBLIO,
 230         TC_FULLAUTHORLIST,
 231         TC_OUTLINERNAME,
 232         TC_TABLESTYLE,
 233         TC_BIBINTOC
 234 };
 235
 236
 237 namespace {
 238
 239 LexerKeyword textClassTags[] = {
 240         { "addtociteengine",   TC_ADDTOCITEENGINE },
 241         { "addtohtmlpreamble", TC_ADDTOHTMLPREAMBLE },
 242         { "addtohtmlstyles",   TC_ADDTOHTMLSTYLES },
 243         { "addtopreamble",     TC_ADDTOPREAMBLE },
 244         { "bibintoc",          TC_BIBINTOC },
 245         { "citeengine",        TC_CITEENGINE },
 246         { "citeenginetype",    TC_CITEENGINETYPE },
 247         { "citeformat",        TC_CITEFORMAT },
 248         { "citeframework",     TC_CITEFRAMEWORK },
 249         { "classoptions",      TC_CLASSOPTIONS },
 250         { "columns",           TC_COLUMNS },
 251         { "counter",           TC_COUNTER },
 252         { "defaultbiblio",     TC_DEFAULTBIBLIO },
 253         { "defaultfont",       TC_DEFAULTFONT },
 254         { "defaultmodule",     TC_DEFAULTMODULE },
 255         { "defaultstyle",      TC_DEFAULTSTYLE },
 256         { "excludesmodule",    TC_EXCLUDESMODULE },
 257         { "float",             TC_FLOAT },
 258         { "format",            TC_FORMAT },
 259         { "fullauthorlist",    TC_FULLAUTHORLIST },
 260         { "htmlpreamble",      TC_HTMLPREAMBLE },
 261         { "htmlstyles",        TC_HTMLSTYLES },
 262         { "htmltocsection",    TC_HTMLTOCSECTION },
 263         { "ifcounter",         TC_IFCOUNTER },
 264         { "input",             TC_INPUT },
 265         { "insetlayout",       TC_INSETLAYOUT },
 266         { "leftmargin",        TC_LEFTMARGIN },
 267         { "maxcitenames",      TC_MAXCITENAMES },
 268         { "modifystyle",       TC_MODIFYSTYLE },
 269         { "nocounter",         TC_NOCOUNTER },
 270         { "nofloat",           TC_NOFLOAT },
 271         { "noinsetlayout",     TC_NOINSETLAYOUT },
 272         { "nostyle",           TC_NOSTYLE },
 273         { "outlinername",      TC_OUTLINERNAME },
 274         { "outputformat",      TC_OUTPUTFORMAT },
 275         { "outputtype",        TC_OUTPUTTYPE },
 276         { "packageoptions",    TC_PKGOPTS },
 277         { "pagesize",          TC_PAGESIZE },
 278         { "pagestyle",         TC_PAGESTYLE },
 279         { "preamble",          TC_PREAMBLE },
 280         { "provides",          TC_PROVIDES },
 281         { "providesmodule",    TC_PROVIDESMODULE },
 282         { "providestyle",      TC_PROVIDESTYLE },
 283         { "requires",          TC_REQUIRES },
 284         { "rightmargin",       TC_RIGHTMARGIN },
 285         { "secnumdepth",       TC_SECNUMDEPTH },
 286         { "sides",             TC_SIDES },
 287         { "style",             TC_STYLE },
 288         { "tablestyle",        TC_TABLESTYLE },
 289         { "titlelatexname",    TC_TITLELATEXNAME },
 290         { "titlelatextype",    TC_TITLELATEXTYPE },
 291         { "tocdepth",          TC_TOCDEPTH }
 292 };
 293
 294 } // namespace
 295
 296
 297 bool TextClass::convertLayoutFormat(support::FileName const & filename, ReadType rt)
 298 {
 299         LYXERR(Debug::TCLASS, "Converting layout file to " << LAYOUT_FORMAT);
 300         TempFile tmp("convertXXXXXX.layout");
 301         FileName const tempfile = tmp.name();
 302         bool success = layout2layout(filename, tempfile);
 303         if (success)
 304                 success = readWithoutConv(tempfile, rt) == OK;
 305         return success;
 306 }
 307
 308
 309 std::string TextClass::convert(std::string const & str)
 310 {
 311         TempFile tmp1("localXXXXXX.layout");
 312         FileName const fn = tmp1.name();
 313         ofstream os(fn.toFilesystemEncoding().c_str());
 314         os << str;
 315         os.close();
 316         TempFile tmp2("convert_localXXXXXX.layout");
 317         FileName const tempfile = tmp2.name();
 318         bool success = layout2layout(fn, tempfile, LYXFILE_LAYOUT_FORMAT);
 319         if (!success)
 320                 return "";
 321         ifstream is(tempfile.toFilesystemEncoding().c_str());
 322         string ret;
 323         string tmp;
 324         while (!is.eof()) {
 325                 getline(is, tmp);
 326                 ret += tmp + '\n';
 327         }
 328         is.close();
 329         return ret;
 330 }
 331
 332
 333 TextClass::ReturnValues TextClass::readWithoutConv(FileName const & filename, ReadType rt)
 334 {
 335         if (!filename.isReadableFile()) {
 336                 lyxerr << "Cannot read layout file `" << filename << "'."
 337                        << endl;
 338                 return ERROR;
 339         }
 340
 341         LYXERR(Debug::TCLASS, "Reading " + translateReadType(rt) + ": " +
 342                 to_utf8(makeDisplayPath(filename.absFileName())));
 343
 344         // Define the plain layout used in table cells, ert, etc. Note that
 345         // we do this before loading any layout file, so that classes can
 346         // override features of this layout if they should choose to do so.
 347         if (rt == BASECLASS && !hasLayout(plain_layout_))
 348                 layoutlist_.push_back(createBasicLayout(plain_layout_));
 349
 350         Lexer lexrc(textClassTags);
 351         lexrc.setFile(filename);
 352         ReturnValues retval = read(lexrc, rt);
 353
 354         LYXERR(Debug::TCLASS, "Finished reading " + translateReadType(rt) + ": " +
 355                         to_utf8(makeDisplayPath(filename.absFileName())));
 356
 357         return retval;
 358 }
 359
 360
 361 bool TextClass::read(FileName const & filename, ReadType rt)
 362 {
 363         ReturnValues const retval = readWithoutConv(filename, rt);
 364         if (retval != FORMAT_MISMATCH)
 365                 return retval == OK;
 366
 367         bool const worx = convertLayoutFormat(filename, rt);
 368         if (!worx)
 369                 LYXERR0 ("Unable to convert " << filename <<
 370                         " to format " << LAYOUT_FORMAT);
 371         return worx;
 372 }
 373
 374
 375 TextClass::ReturnValues TextClass::validate(std::string const & str)
 376 {
 377         TextClass tc;
 378         return tc.read(str, VALIDATION);
 379 }
 380
 381
 382 TextClass::ReturnValues TextClass::read(std::string const & str, ReadType rt)
 383 {
 384         Lexer lexrc(textClassTags);
 385         istringstream is(str);
 386         lexrc.setStream(is);
 387         ReturnValues retval = read(lexrc, rt);
 388
 389         if (retval != FORMAT_MISMATCH)
 390                 return retval;
 391
 392         // write the layout string to a temporary file
 393         TempFile tmp("TextClass_read");
 394         FileName const tempfile = tmp.name();
 395         ofstream os(tempfile.toFilesystemEncoding().c_str());
 396         if (!os) {
 397                 LYXERR0("Unable to create temporary file");
 398                 return ERROR;
 399         }
 400         os << str;
 401         os.close();
 402
 403         // now try to convert it to LAYOUT_FORMAT
 404         if (!convertLayoutFormat(tempfile, rt)) {
 405                 LYXERR0("Unable to convert internal layout information to format "
 406                         << LAYOUT_FORMAT);
 407                 return ERROR;
 408         }
 409
 410         return OK_OLDFORMAT;
 411 }
 412
 413
 414 // Reads a textclass structure from file.
 415 TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt)
 416 {
 417         if (!lexrc.isOK())
 418                 return ERROR;
 419
 420         // The first usable line should be
 421         // Format LAYOUT_FORMAT
 422         if (lexrc.lex() != TC_FORMAT || !lexrc.next()
 423             || lexrc.getInteger() != LAYOUT_FORMAT)
 424                 return FORMAT_MISMATCH;
 425
 426         // parsing
 427         bool error = false;
 428         while (lexrc.isOK() && !error) {
 429                 int le = lexrc.lex();
 430
 431                 switch (le) {
 432                 case Lexer::LEX_FEOF:
 433                         continue;
 434
 435                 case Lexer::LEX_UNDEF:
 436                         lexrc.printError("Unknown TextClass tag `$$Token'");
 437                         error = true;
 438                         continue;
 439
 440                 default:
 441                         break;
 442                 }
 443
 444                 // used below to track whether we are in an IfStyle or IfCounter tag.
 445                 bool modifystyle  = false;
 446                 bool providestyle = false;
 447                 bool ifcounter    = false;
 448
 449                 switch (static_cast<TextClassTags>(le)) {
 450
 451                 case TC_FORMAT:
 452                         lexrc.next();
 453                         lexrc.printError("Duplicate Format directive");
 454                         break;
 455
 456                 case TC_OUTPUTFORMAT:
 457                         if (lexrc.next()) {
 458                                 outputFormat_ = lexrc.getString();
 459                                 has_output_format_ = true;
 460                         }
 461                         break;
 462
 463                 case TC_OUTPUTTYPE:
 464                         readOutputType(lexrc);
 465                         switch(outputType_) {
 466                         case LATEX:
 467                                 outputFormat_ = "latex";
 468                                 break;
 469                         case DOCBOOK:
 470                                 outputFormat_ = "docbook";
 471                                 break;
 472                         case LITERATE:
 473                                 outputFormat_ = "literate";
 474                                 break;
 475                         }
 476                         break;
 477
 478                 case TC_INPUT: // Include file
 479                         if (lexrc.next()) {
 480                                 FileName tmp;
 481                                 string const inc = lexrc.getString();
 482                                 if (!path().empty() && (prefixIs(inc, "./") ||
 483                                                         prefixIs(inc, "../")))
 484                                         tmp = fileSearch(path(), inc, "layout");
 485                                 else
 486                                         tmp = libFileSearch("layouts", inc,
 487                                                             "layout");
 488
 489                                 if (tmp.empty()) {
 490                                         lexrc.printError("Could not find input file: " + inc);
 491                                         error = true;
 492                                 } else if (!read(tmp, MERGE)) {
 493                                         lexrc.printError("Error reading input file: " + tmp.absFileName());
 494                                         error = true;
 495                                 }
 496                         }
 497                         break;
 498
 499                 case TC_DEFAULTSTYLE:
 500                         if (lexrc.next()) {
 501                                 docstring const name = from_utf8(subst(lexrc.getString(),
 502                                                           '_', ' '));
 503                                 defaultlayout_ = name;
 504                         }
 505                         break;
 506
 507                 case TC_MODIFYSTYLE:
 508                         modifystyle = true;
 509                 // fall through
 510                 case TC_PROVIDESTYLE:
 511                         // if modifystyle is true, then we got here by falling through
 512                         // so we are not in an ProvideStyle block
 513                         if (!modifystyle)
 514                                 providestyle = true;
 515                 // fall through
 516                 case TC_STYLE: {
 517                         if (!lexrc.next()) {
 518                                 lexrc.printError("No name given for style: `$$Token'.");
 519                                 error = true;
 520                                 break;
 521                         }
 522                         docstring const name = from_utf8(subst(lexrc.getString(),
 523                                                         '_', ' '));
 524                         if (name.empty()) {
 525                                 string s = "Could not read name for style: `$$Token' "
 526                                         + lexrc.getString() + " is probably not valid UTF-8!";
 527                                 lexrc.printError(s);
 528                                 Layout lay;
 529                                 // Since we couldn't read the name, we just scan the rest
 530                                 // of the style and discard it.
 531                                 error = !readStyle(lexrc, lay);
 532                                 break;
 533                         }
 534
 535                         bool const have_layout = hasLayout(name);
 536
 537                         // If the layout already exists, then we want to add it to
 538                         // the existing layout, as long as we are not in an ProvideStyle
 539                         // block.
 540                         if (have_layout && !providestyle) {
 541                                 Layout & lay = operator[](name);
 542                                 error = !readStyle(lexrc, lay);
 543                         }
 544                         // If the layout does not exist, then we want to create a new
 545                         // one, but not if we are in a ModifyStyle block.
 546                         else if (!have_layout && !modifystyle) {
 547                                 Layout layout;
 548                                 layout.setName(name);
 549                                 error = !readStyle(lexrc, layout);
 550                                 if (!error)
 551                                         layoutlist_.push_back(layout);
 552
 553                                 if (defaultlayout_.empty()) {
 554                                         // We do not have a default layout yet, so we choose
 555                                         // the first layout we encounter.
 556                                         defaultlayout_ = name;
 557                                 }
 558                         }
 559                         // There are two ways to get here:
 560                         //  (i)  The layout exists but we are in an ProvideStyle block
 561                         //  (ii) The layout doesn't exist, but we are in an ModifyStyle
 562                         //       block.
 563                         // Either way, we just scan the rest and discard it
 564                         else {
 565                                 Layout lay;
 566                                 // signal to coverity that we do not care about the result
 567                                 (void)readStyle(lexrc, lay);
 568                         }
 569                         break;
 570                 }
 571
 572                 case TC_NOSTYLE:
 573                         if (lexrc.next()) {
 574                                 docstring const style = from_utf8(subst(lexrc.getString(),
 575                                                      '_', ' '));
 576                                 if (!deleteLayout(style))
 577                                         lyxerr << "Cannot delete style `"
 578                                                << to_utf8(style) << '\'' << endl;
 579                         }
 580                         break;
 581
 582                 case TC_NOINSETLAYOUT:
 583                         if (lexrc.next()) {
 584                                 docstring const style = from_utf8(subst(lexrc.getString(),
 585                                                                  '_', ' '));
 586                                 if (!deleteInsetLayout(style))
 587                                         LYXERR0("Style `" << style << "' cannot be removed\n"
 588                                                 "because it was not found!");
 589                         }
 590                         break;
 591
 592                 case TC_COLUMNS:
 593                         if (lexrc.next())
 594                                 columns_ = lexrc.getInteger();
 595                         break;
 596
 597                 case TC_SIDES:
 598                         if (lexrc.next()) {
 599                                 switch (lexrc.getInteger()) {
 600                                 case 1: sides_ = OneSide; break;
 601                                 case 2: sides_ = TwoSides; break;
 602                                 default:
 603                                         lyxerr << "Impossible number of page"
 604                                                 " sides, setting to one."
 605                                                << endl;
 606                                         sides_ = OneSide;
 607                                         break;
 608                                 }
 609                         }
 610                         break;
 611
 612                 case TC_PAGESIZE:
 613                         lexrc.next();
 614                         pagesize_ = rtrim(lexrc.getString());
 615                         break;
 616
 617                 case TC_PAGESTYLE:
 618                         lexrc.next();
 619                         pagestyle_ = rtrim(lexrc.getString());
 620                         break;
 621
 622                 case TC_DEFAULTFONT:
 623                         defaultfont_ = lyxRead(lexrc);
 624                         if (!defaultfont_.resolved()) {
 625                                 lexrc.printError("Warning: defaultfont should "
 626                                                  "be fully instantiated!");
 627                                 defaultfont_.realize(sane_font);
 628                         }
 629                         break;
 630
 631                 case TC_SECNUMDEPTH:
 632                         lexrc.next();
 633                         secnumdepth_ = lexrc.getInteger();
 634                         break;
 635
 636                 case TC_TOCDEPTH:
 637                         lexrc.next();
 638                         tocdepth_ = lexrc.getInteger();
 639                         break;
 640
 641                 // First step to support options
 642                 case TC_CLASSOPTIONS:
 643                         readClassOptions(lexrc);
 644                         break;
 645
 646                 case TC_PREAMBLE:
 647                         preamble_ = lexrc.getLongString(from_ascii("EndPreamble"));
 648                         break;
 649
 650                 case TC_HTMLPREAMBLE:
 651                         htmlpreamble_ = lexrc.getLongString(from_ascii("EndPreamble"));
 652                         break;
 653
 654                 case TC_HTMLSTYLES:
 655                         htmlstyles_ = lexrc.getLongString(from_ascii("EndStyles"));
 656                         break;
 657
 658                 case TC_HTMLTOCSECTION:
 659                         html_toc_section_ = from_utf8(trim(lexrc.getString()));
 660                         break;
 661
 662                 case TC_ADDTOPREAMBLE:
 663                         preamble_ += lexrc.getLongString(from_ascii("EndPreamble"));
 664                         break;
 665
 666                 case TC_ADDTOHTMLPREAMBLE:
 667                         htmlpreamble_ += lexrc.getLongString(from_ascii("EndPreamble"));
 668                         break;
 669
 670                 case TC_ADDTOHTMLSTYLES:
 671                         htmlstyles_ += lexrc.getLongString(from_ascii("EndStyles"));
 672                         break;
 673
 674                 case TC_PROVIDES: {
 675                         lexrc.next();
 676                         string const feature = lexrc.getString();
 677                         lexrc.next();
 678                         if (lexrc.getInteger())
 679                                 provides_.insert(feature);
 680                         else
 681                                 provides_.erase(feature);
 682                         break;
 683                 }
 684
 685                 case TC_REQUIRES: {
 686                         lexrc.eatLine();
 687                         vector<string> const req
 688                                 = getVectorFromString(lexrc.getString());
 689                         requires_.insert(req.begin(), req.end());
 690                         break;
 691                 }
 692
 693                 case TC_PKGOPTS : {
 694                         lexrc.next();
 695                         string const pkg = lexrc.getString();
 696                         lexrc.next();
 697                         string const options = lexrc.getString();
 698                         package_options_[pkg] = options;
 699                         break;
 700                 }
 701
 702                 case TC_DEFAULTMODULE: {
 703                         lexrc.next();
 704                         string const module = lexrc.getString();
 705                         if (find(default_modules_.begin(), default_modules_.end(), module) == default_modules_.end())
 706                                 default_modules_.push_back(module);
 707                         break;
 708                 }
 709
 710                 case TC_PROVIDESMODULE: {
 711                         lexrc.next();
 712                         string const module = lexrc.getString();
 713                         if (find(provided_modules_.begin(), provided_modules_.end(), module) == provided_modules_.end())
 714                                 provided_modules_.push_back(module);
 715                         break;
 716                 }
 717
 718                 case TC_EXCLUDESMODULE: {
 719                         lexrc.next();
 720                         string const module = lexrc.getString();
 721                         // modules already have their own way to exclude other modules
 722                         if (rt == MODULE) {
 723                                 LYXERR0("ExcludesModule tag cannot be used in a module!");
 724                                 break;
 725                         }
 726                         if (find(excluded_modules_.begin(), excluded_modules_.end(), module) == excluded_modules_.end())
 727                                 excluded_modules_.push_back(module);
 728                         break;
 729                 }
 730
 731                 case TC_LEFTMARGIN:     // left margin type
 732                         if (lexrc.next())
 733                                 leftmargin_ = lexrc.getDocString();
 734                         break;
 735
 736                 case TC_RIGHTMARGIN:    // right margin type
 737                         if (lexrc.next())
 738                                 rightmargin_ = lexrc.getDocString();
 739                         break;
 740
 741                 case TC_INSETLAYOUT: {
 742                         if (!lexrc.next()) {
 743                                 lexrc.printError("No name given for InsetLayout: `$$Token'.");
 744                                 error = true;
 745                                 break;
 746                         }
 747                         docstring const name = subst(lexrc.getDocString(), '_', ' ');
 748                         bool const validating = (rt == VALIDATION);
 749                         if (name.empty()) {
 750                                 string s = "Could not read name for InsetLayout: `$$Token' "
 751                                         + lexrc.getString() + " is probably not valid UTF-8!";
 752                                 lexrc.printError(s);
 753                                 InsetLayout il;
 754                                 // Since we couldn't read the name, we just scan the rest
 755                                 // of the style and discard it.
 756                                 il.read(lexrc, *this);
 757                                 // Let's try to continue rather than abort, unless we're validating
 758                                 // in which case we want to report the error
 759                                 if (validating)
 760                                         error = true;
 761                         } else if (hasInsetLayout(name)) {
 762                                 InsetLayout & il = insetlayoutlist_[name];
 763                                 error = !il.read(lexrc, *this, validating);
 764                         } else {
 765                                 InsetLayout il;
 766                                 il.setName(name);
 767                                 error = !il.read(lexrc, *this, validating);
 768                                 if (!error)
 769                                         insetlayoutlist_[name] = il;
 770                         }
 771                         break;
 772                 }
 773
 774                 case TC_FLOAT:
 775                         error = !readFloat(lexrc);
 776                         break;
 777
 778                 case TC_CITEENGINE:
 779                         error = !readCiteEngine(lexrc, rt);
 780                         break;
 781
 782                 case TC_ADDTOCITEENGINE:
 783                         error = !readCiteEngine(lexrc, rt, true);
 784                         break;
 785
 786                 case TC_CITEENGINETYPE:
 787                         if (lexrc.next())
 788                                 opt_enginetype_ = rtrim(lexrc.getString());
 789                         break;
 790
 791                 case TC_CITEFORMAT:
 792                         error = !readCiteFormat(lexrc, rt);
 793                         break;
 794
 795                 case TC_CITEFRAMEWORK:
 796                         lexrc.next();
 797                         citeframework_ = rtrim(lexrc.getString());
 798                         break;
 799
 800                 case TC_MAXCITENAMES:
 801                         lexrc.next();
 802                         maxcitenames_ = size_t(lexrc.getInteger());
 803                         break;
 804
 805                 case TC_DEFAULTBIBLIO:
 806                         if (lexrc.next()) {
 807                                 vector<string> const dbs =
 808                                         getVectorFromString(rtrim(lexrc.getString()), "|");
 809                                 for (auto const & dbase : dbs) {
 810                                         if (!contains(dbase, ':')) {
 811                                                 vector<string> const enginetypes =
 812                                                         getVectorFromString(opt_enginetype_, "|");
 813                                                 for (string const & s: enginetypes)
 814                                                         cite_default_biblio_style_[s] = dbase;
 815                                         } else {
 816                                                 string eng;
 817                                                 string const db = split(dbase, eng, ':');
 818                                                 cite_default_biblio_style_[eng] = db;
 819                                         }
 820                                 }
 821                         }
 822                         break;
 823
 824                 case TC_BIBINTOC:
 825                         if (lexrc.next())
 826                                 bibintoc_ = lexrc.getBool();
 827                         break;
 828
 829                 case TC_FULLAUTHORLIST:
 830                         if (lexrc.next())
 831                                 cite_full_author_list_ &= lexrc.getBool();
 832                         break;
 833
 834                 case TC_NOCOUNTER:
 835                         if (lexrc.next()) {
 836                                 docstring const cnt = lexrc.getDocString();
 837                                 if (!counters_.remove(cnt))
 838                                         LYXERR0("Unable to remove counter: " + to_utf8(cnt));
 839                         }
 840                         break;
 841
 842                 case TC_IFCOUNTER:
 843                         ifcounter = true;
 844                         // fall through
 845                 case TC_COUNTER:
 846                         if (lexrc.next()) {
 847                                 docstring const name = lexrc.getDocString();
 848                                 if (name.empty()) {
 849                                         string s = "Could not read name for counter: `$$Token' "
 850                                                         + lexrc.getString() + " is probably not valid UTF-8!";
 851                                         lexrc.printError(s.c_str());
 852                                         Counter c;
 853                                         // Since we couldn't read the name, we just scan the rest
 854                                         // and discard it.
 855                                         c.read(lexrc);
 856                                 } else
 857                                         error = !counters_.read(lexrc, name, !ifcounter);
 858                         }
 859                         else {
 860                                 lexrc.printError("No name given for style: `$$Token'.");
 861                                 error = true;
 862                         }
 863                         break;
 864
 865                 case TC_TITLELATEXTYPE:
 866                         readTitleType(lexrc);
 867                         break;
 868
 869                 case TC_TITLELATEXNAME:
 870                         if (lexrc.next())
 871                                 titlename_ = lexrc.getString();
 872                         break;
 873
 874                 case TC_NOFLOAT:
 875                         if (lexrc.next()) {
 876                                 string const nofloat = lexrc.getString();
 877                                 floatlist_.erase(nofloat);
 878                         }
 879                         break;
 880
 881                 case TC_OUTLINERNAME:
 882                         error = !readOutlinerName(lexrc);
 883                         break;
 884
 885                 case TC_TABLESTYLE:
 886                         lexrc.next();
 887                         tablestyle_ = rtrim(lexrc.getString());
 888                         break;
 889                 } // end of switch
 890         }
 891
 892         // at present, we abort if we encounter an error,
 893         // so there is no point continuing.
 894         if (error)
 895                 return ERROR;
 896
 897         if (rt != BASECLASS)
 898                 return OK;
 899
 900         if (defaultlayout_.empty()) {
 901                 LYXERR0("Error: Textclass '" << name_
 902                                                 << "' is missing a defaultstyle.");
 903                 return ERROR;
 904         }
 905
 906         // Try to erase "stdinsets" from the provides_ set.
 907         // The
 908         //   Provides stdinsets 1
 909         // declaration simply tells us that the standard insets have been
 910         // defined. (It's found in stdinsets.inc but could also be used in
 911         // user-defined files.) There isn't really any such package. So we
 912         // might as well go ahead and erase it.
 913         // If we do not succeed, then it was not there, which means that
 914         // the textclass did not provide the definitions of the standard
 915         // insets. So we need to try to load them.
 916         int erased = provides_.erase("stdinsets");
 917         if (!erased) {
 918                 FileName tmp = libFileSearch("layouts", "stdinsets.inc");
 919
 920                 if (tmp.empty()) {
 921                         frontend::Alert::warning(_("Missing File"),
 922                                 _("Could not find stdinsets.inc! This may lead to data loss!"));
 923                         error = true;
 924                 } else if (!read(tmp, MERGE)) {
 925                         frontend::Alert::warning(_("Corrupt File"),
 926                                 _("Could not read stdinsets.inc! This may lead to data loss!"));
 927                         error = true;
 928                 }
 929         }
 930
 931         min_toclevel_ = Layout::NOT_IN_TOC;
 932         max_toclevel_ = Layout::NOT_IN_TOC;
 933         for (auto const & lay : *this) {
 934                 int const toclevel = lay.toclevel;
 935                 if (toclevel != Layout::NOT_IN_TOC) {
 936                         if (min_toclevel_ == Layout::NOT_IN_TOC)
 937                                 min_toclevel_ = toclevel;
 938                         else
 939                                 min_toclevel_ = min(min_toclevel_, toclevel);
 940                         max_toclevel_ = max(max_toclevel_, toclevel);
 941                 }
 942         }
 943         LYXERR(Debug::TCLASS, "Minimum TocLevel is " << min_toclevel_
 944                 << ", maximum is " << max_toclevel_);
 945
 946         return (error ? ERROR : OK);
 947 }
 948
 949
 950 void TextClass::readTitleType(Lexer & lexrc)
 951 {
 952         LexerKeyword titleTypeTags[] = {
 953                 { "commandafter", TITLE_COMMAND_AFTER },
 954                 { "environment",  TITLE_ENVIRONMENT }
 955         };
 956
 957         PushPopHelper pph(lexrc, titleTypeTags);
 958
 959         int le = lexrc.lex();
 960         switch (le) {
 961         case Lexer::LEX_UNDEF:
 962                 lexrc.printError("Unknown output type `$$Token'");
 963                 break;
 964         case TITLE_COMMAND_AFTER:
 965         case TITLE_ENVIRONMENT:
 966                 titletype_ = static_cast<TitleLatexType>(le);
 967                 break;
 968         default:
 969                 LYXERR0("Unhandled value " << le << " in TextClass::readTitleType.");
 970                 break;
 971         }
 972 }
 973
 974
 975 void TextClass::readOutputType(Lexer & lexrc)
 976 {
 977         LexerKeyword outputTypeTags[] = {
 978                 { "docbook",  DOCBOOK },
 979                 { "latex",    LATEX },
 980                 { "literate", LITERATE }
 981         };
 982
 983         PushPopHelper pph(lexrc, outputTypeTags);
 984
 985         int le = lexrc.lex();
 986         switch (le) {
 987         case Lexer::LEX_UNDEF:
 988                 lexrc.printError("Unknown output type `$$Token'");
 989                 return;
 990         case LATEX:
 991         case DOCBOOK:
 992         case LITERATE:
 993                 outputType_ = static_cast<OutputType>(le);
 994                 break;
 995         default:
 996                 LYXERR0("Unhandled value " << le);
 997                 break;
 998         }
 999 }
1000
1001
1002 void TextClass::readClassOptions(Lexer & lexrc)
1003 {
1004         enum {
1005                 CO_FONTSIZE = 1,
1006                 CO_FONTSIZE_FORMAT,
1007                 CO_PAGESIZE,
1008                 CO_PAGESIZE_FORMAT,
1009                 CO_PAGESTYLE,
1010                 CO_OTHER,
1011                 CO_HEADER,
1012                 CO_END
1013         };
1014
1015         LexerKeyword classOptionsTags[] = {
1016                 {"end",       CO_END },
1017                 {"fontsize",  CO_FONTSIZE },
1018                 {"fontsizeformat", CO_FONTSIZE_FORMAT },
1019                 {"header",    CO_HEADER },
1020                 {"other",     CO_OTHER },
1021                 {"pagesize",  CO_PAGESIZE },
1022                 {"pagesizeformat", CO_PAGESIZE_FORMAT },
1023                 {"pagestyle", CO_PAGESTYLE }
1024         };
1025
1026         lexrc.pushTable(classOptionsTags);
1027         bool getout = false;
1028         while (!getout && lexrc.isOK()) {
1029                 int le = lexrc.lex();
1030                 switch (le) {
1031                 case Lexer::LEX_UNDEF:
1032                         lexrc.printError("Unknown ClassOption tag `$$Token'");
1033                         continue;
1034                 default:
1035                         break;
1036                 }
1037                 switch (le) {
1038                 case CO_FONTSIZE:
1039                         lexrc.next();
1040                         opt_fontsize_ = rtrim(lexrc.getString());
1041                         break;
1042                 case CO_FONTSIZE_FORMAT:
1043                         lexrc.next();
1044                         fontsize_format_ = rtrim(lexrc.getString());
1045                         break;
1046                 case CO_PAGESIZE:
1047                         lexrc.next();
1048                         opt_pagesize_ = rtrim(lexrc.getString());
1049                         break;
1050                 case CO_PAGESIZE_FORMAT:
1051                         lexrc.next();
1052                         pagesize_format_ = rtrim(lexrc.getString());
1053                         break;
1054                 case CO_PAGESTYLE:
1055                         lexrc.next();
1056                         opt_pagestyle_ = rtrim(lexrc.getString());
1057                         break;
1058                 case CO_OTHER:
1059                         lexrc.next();
1060                         if (options_.empty())
1061                                 options_ = lexrc.getString();
1062                         else
1063                                 options_ += ',' + lexrc.getString();
1064                         break;
1065                 case CO_HEADER:
1066                         lexrc.next();
1067                         class_header_ = subst(lexrc.getString(), "&quot;", "\"");
1068                         break;
1069                 case CO_END:
1070                         getout = true;
1071                         break;
1072                 }
1073         }
1074         lexrc.popTable();
1075 }
1076
1077
1078 vector<CitationStyle> const & TextClass::getCiteStyles(
1079         CiteEngineType const & type) const
1080 {
1081         static vector<CitationStyle> empty;
1082         map<CiteEngineType, vector<CitationStyle> >::const_iterator it = cite_styles_.find(type);
1083         if (it == cite_styles_.end())
1084                 return empty;
1085         return it->second;
1086 }
1087
1088
1089 bool TextClass::readCiteEngine(Lexer & lexrc, ReadType rt, bool const add)
1090 {
1091         int const type = readCiteEngineType(lexrc);
1092         bool authoryear = (type & ENGINE_TYPE_AUTHORYEAR);
1093         bool numerical = (type & ENGINE_TYPE_NUMERICAL);
1094         bool defce = (type & ENGINE_TYPE_DEFAULT);
1095
1096         if (rt == CITE_ENGINE) {
1097                 // The cite engines are not supposed to overwrite
1098                 // CiteStyle defined by the class or a module.
1099                 if (authoryear)
1100                         authoryear = getCiteStyles(ENGINE_TYPE_AUTHORYEAR).empty();
1101                 if (numerical)
1102                         numerical = getCiteStyles(ENGINE_TYPE_NUMERICAL).empty();
1103                 if (defce)
1104                         defce = getCiteStyles(ENGINE_TYPE_DEFAULT).empty();
1105         }
1106
1107         if (rt != CITE_ENGINE && !add) {
1108                 // Reset if we defined CiteStyle
1109                 // from the class or a module
1110                 if (authoryear)
1111                         cite_styles_[ENGINE_TYPE_AUTHORYEAR].clear();
1112                 if (numerical)
1113                         cite_styles_[ENGINE_TYPE_NUMERICAL].clear();
1114                 if (defce)
1115                         cite_styles_[ENGINE_TYPE_DEFAULT].clear();
1116         }
1117
1118         string def;
1119         bool getout = false;
1120         while (!getout && lexrc.isOK()) {
1121                 lexrc.eatLine();
1122                 def = lexrc.getString();
1123                 def = subst(def, " ", "");
1124                 def = subst(def, "\t", "");
1125                 if (compare_ascii_no_case(def, "end") == 0) {
1126                         getout = true;
1127                         continue;
1128                 }
1129                 CitationStyle cs;
1130                 char ichar = def[0];
1131                 if (ichar == '#')
1132                         continue;
1133                 if (isUpperCase(ichar)) {
1134                         cs.forceUpperCase = true;
1135                         def[0] = lowercase(ichar);
1136                 }
1137
1138                 /** For portability reasons (between different
1139                  *  cite engines such as natbib and biblatex),
1140                  *  we distinguish between:
1141                  *  1. The LyX name as output in the LyX file
1142                  *  2. Possible aliases that might fall back to
1143                  *     the given LyX name in the current engine
1144                  *  3. The actual LaTeX command that is output
1145                  *  (2) and (3) are optional.
1146                  *  Also, the GUI string for the starred version can
1147                  *  be changed
1148                  *  The syntax is:
1149                  *  LyXName|alias,nextalias*<!stardesc!stardesctooltip>[][]=latexcmd
1150                  */
1151                 enum ScanMode {
1152                         LyXName,
1153                         Alias,
1154                         LaTeXCmd,
1155                         StarDesc
1156                 };
1157
1158                 ScanMode mode = LyXName;
1159                 ScanMode oldmode = LyXName;
1160                 string lyx_cmd;
1161                 string alias;
1162                 string latex_cmd;
1163                 string stardesc;
1164                 size_t const n = def.size();
1165                 for (size_t i = 0; i != n; ++i) {
1166                         ichar = def[i];
1167                         if (ichar == '|')
1168                                 mode = Alias;
1169                         else if (ichar == '=')
1170                                 mode = LaTeXCmd;
1171                         else if (ichar == '<') {
1172                                 oldmode = mode;
1173                                 mode = StarDesc;
1174                         } else if (ichar == '>')
1175                                 mode = oldmode;
1176                         else if (mode == LaTeXCmd)
1177                                 latex_cmd += ichar;
1178                         else if (mode == StarDesc)
1179                                 stardesc += ichar;
1180                         else if (ichar == '$')
1181                                 cs.hasQualifiedList = true;
1182                         else if (ichar == '*')
1183                                 cs.hasStarredVersion = true;
1184                         else if (ichar == '[' && cs.textAfter)
1185                                 cs.textBefore = true;
1186                         else if (ichar == '[')
1187                                 cs.textAfter = true;
1188                         else if (ichar != ']') {
1189                                 if (mode == Alias)
1190                                         alias += ichar;
1191                                 else
1192                                         lyx_cmd += ichar;
1193                         }
1194                 }
1195                 cs.name = lyx_cmd;
1196                 cs.cmd = latex_cmd.empty() ? lyx_cmd : latex_cmd;
1197                 if (!alias.empty()) {
1198                         vector<string> const aliases = getVectorFromString(alias);
1199                         for (string const & s: aliases)
1200                                 cite_command_aliases_[s] = lyx_cmd;
1201                 }
1202                 vector<string> const stardescs = getVectorFromString(stardesc, "!");
1203                 int size = int(stardesc.size());
1204                 if (size > 0)
1205                         cs.stardesc = stardescs[0];
1206                 if (size > 1)
1207                         cs.startooltip = stardescs[1];
1208                 if (add) {
1209                         if (authoryear)
1210                                 class_cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(cs);
1211                         if (numerical)
1212                                 class_cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(cs);
1213                         if (defce)
1214                                 class_cite_styles_[ENGINE_TYPE_DEFAULT].push_back(cs);
1215                 } else {
1216                         if (authoryear)
1217                                 cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(cs);
1218                         if (numerical)
1219                                 cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(cs);
1220                         if (defce)
1221                                 cite_styles_[ENGINE_TYPE_DEFAULT].push_back(cs);
1222                 }
1223         }
1224         // If we do AddToCiteEngine, do not apply yet,
1225         // except if we have already a style to add something to
1226         bool apply_ay = !add;
1227         bool apply_num = !add;
1228         bool apply_def = !add;
1229         if (add) {
1230                 if (type & ENGINE_TYPE_AUTHORYEAR)
1231                         apply_ay = !getCiteStyles(ENGINE_TYPE_AUTHORYEAR).empty();
1232                 if (type & ENGINE_TYPE_NUMERICAL)
1233                         apply_num = !getCiteStyles(ENGINE_TYPE_NUMERICAL).empty();
1234                 if (type & ENGINE_TYPE_DEFAULT)
1235                         apply_def = !getCiteStyles(ENGINE_TYPE_DEFAULT).empty();
1236         }
1237
1238         // Add the styles from AddToCiteEngine to the class' styles
1239         // (but only if they are not yet defined)
1240         for (auto const & cis : class_cite_styles_) {
1241                 // Only consider the current CiteEngineType
1242                 if (!(type & cis.first))
1243                         continue;
1244                 for (auto const & ciss : cis.second) {
1245                         bool defined = false;
1246                         // Check if the style "name" is already def'ed
1247                         for (auto const & av : getCiteStyles(cis.first))
1248                                 if (av.name == ciss.name)
1249                                         defined = true;
1250                         if (!defined) {
1251                                 if (cis.first == ENGINE_TYPE_AUTHORYEAR && apply_ay)
1252                                         cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(ciss);
1253                                 else if (cis.first == ENGINE_TYPE_NUMERICAL && apply_num)
1254                                         cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(ciss);
1255                                 else if (cis.first == ENGINE_TYPE_DEFAULT && apply_def)
1256                                         cite_styles_[ENGINE_TYPE_DEFAULT].push_back(ciss);
1257                         }
1258                 }
1259         }
1260         if (type & ENGINE_TYPE_AUTHORYEAR && apply_ay)
1261                 class_cite_styles_[ENGINE_TYPE_AUTHORYEAR].clear();
1262         if (type & ENGINE_TYPE_NUMERICAL && apply_num)
1263                 class_cite_styles_[ENGINE_TYPE_NUMERICAL].clear();
1264         if (type & ENGINE_TYPE_DEFAULT && apply_def)
1265                 class_cite_styles_[ENGINE_TYPE_DEFAULT].clear();
1266         return getout;
1267 }
1268
1269
1270 int TextClass::readCiteEngineType(Lexer & lexrc) const
1271 {
1272         static_assert(ENGINE_TYPE_DEFAULT ==
1273                                   (ENGINE_TYPE_AUTHORYEAR | ENGINE_TYPE_NUMERICAL),
1274                                   "Incorrect default engine type");
1275         if (!lexrc.next()) {
1276                 lexrc.printError("No cite engine type given for token: `$$Token'.");
1277                 return ENGINE_TYPE_DEFAULT;
1278         }
1279         string const type = rtrim(lexrc.getString());
1280         if (compare_ascii_no_case(type, "authoryear") == 0)
1281                 return ENGINE_TYPE_AUTHORYEAR;
1282         else if (compare_ascii_no_case(type, "numerical") == 0)
1283                 return ENGINE_TYPE_NUMERICAL;
1284         else if (compare_ascii_no_case(type, "default") != 0) {
1285                 string const s = "Unknown cite engine type `" + type
1286                         + "' given for token: `$$Token',";
1287                 lexrc.printError(s);
1288         }
1289         return ENGINE_TYPE_DEFAULT;
1290 }
1291
1292
1293 bool TextClass::readCiteFormat(Lexer & lexrc, ReadType rt)
1294 {
1295         int const type = readCiteEngineType(lexrc);
1296         string etype;
1297         string definition;
1298         // Cite engine definitions do not overwrite existing
1299         // definitions from the class or a module
1300         bool const overwrite = rt != CITE_ENGINE;
1301         while (lexrc.isOK()) {
1302                 lexrc.next();
1303                 etype = lexrc.getString();
1304                 if (compare_ascii_no_case(etype, "end") == 0)
1305                         break;
1306                 if (!lexrc.isOK())
1307                         return false;
1308                 lexrc.eatLine();
1309                 definition = lexrc.getString();
1310                 char initchar = etype[0];
1311                 if (initchar == '#')
1312                         continue;
1313                 if (initchar == '!' || initchar == '_' || prefixIs(etype, "B_")) {
1314                         bool defined = false;
1315                         bool aydefined = false;
1316                         bool numdefined = false;
1317                         // Check if the macro is already def'ed
1318                         for (auto const & cm : cite_macros_) {
1319                                 if (!(type & cm.first))
1320                                         continue;
1321                                 if (cm.second.find(etype) != cm.second.end()) {
1322                                         if (type == cm.first)
1323                                                 // defined as default or specific type
1324                                                 defined = true;
1325                                         if (cm.first == ENGINE_TYPE_AUTHORYEAR)
1326                                                 // defined for author-year
1327                                                 aydefined = true;
1328                                         else if (cm.first == ENGINE_TYPE_NUMERICAL)
1329                                                 // defined for numerical
1330                                                 numdefined = true;
1331                                 }
1332                         }
1333                         if (!defined || overwrite) {
1334                                 if (type & ENGINE_TYPE_AUTHORYEAR && (type != ENGINE_TYPE_DEFAULT || !aydefined))
1335                                         cite_macros_[ENGINE_TYPE_AUTHORYEAR][etype] = definition;
1336                                 if (type & ENGINE_TYPE_NUMERICAL && (type != ENGINE_TYPE_DEFAULT || !numdefined))
1337                                         cite_macros_[ENGINE_TYPE_NUMERICAL][etype] = definition;
1338                                 if (type == ENGINE_TYPE_DEFAULT)
1339                                         cite_macros_[ENGINE_TYPE_DEFAULT][etype] = definition;
1340                         }
1341                 } else {
1342                         bool defined = false;
1343                         bool aydefined = false;
1344                         bool numdefined = false;
1345                         // Check if the format is already def'ed
1346                         for (auto const & cm : cite_formats_) {
1347                                 if (!(type & cm.first))
1348                                         continue;
1349                                 if (cm.second.find(etype) != cm.second.end()) {
1350                                         if (type == cm.first)
1351                                                 // defined as default or specific type
1352                                                 defined = true;
1353                                         if (cm.first == ENGINE_TYPE_AUTHORYEAR)
1354                                                 // defined for author-year
1355                                                 aydefined = true;
1356                                         else if (cm.first == ENGINE_TYPE_NUMERICAL)
1357                                                 // defined for numerical
1358                                                 numdefined = true;
1359                                 }
1360                         }
1361                         if (!defined || overwrite){
1362                                 if (type & ENGINE_TYPE_AUTHORYEAR && (type != ENGINE_TYPE_DEFAULT || !aydefined))
1363                                         cite_formats_[ENGINE_TYPE_AUTHORYEAR][etype] = definition;
1364                                 if (type & ENGINE_TYPE_NUMERICAL && (type != ENGINE_TYPE_DEFAULT || !numdefined))
1365                                         cite_formats_[ENGINE_TYPE_NUMERICAL][etype] = definition;
1366                                 if (type == ENGINE_TYPE_DEFAULT)
1367                                         cite_formats_[ENGINE_TYPE_DEFAULT][etype] = definition;
1368                         }
1369                 }
1370         }
1371         return true;
1372 }
1373
1374
1375 bool TextClass::readFloat(Lexer & lexrc)
1376 {
1377         enum {
1378                 FT_TYPE = 1,
1379                 FT_NAME,
1380                 FT_PLACEMENT,
1381                 FT_EXT,
1382                 FT_WITHIN,
1383                 FT_STYLE,
1384                 FT_LISTNAME,
1385                 FT_USESFLOAT,
1386                 FT_PREDEFINED,
1387                 FT_HTMLSTYLE,
1388                 FT_HTMLATTR,
1389                 FT_HTMLTAG,
1390                 FT_LISTCOMMAND,
1391                 FT_REFPREFIX,
1392                 FT_ALLOWED_PLACEMENT,
1393                 FT_ALLOWS_SIDEWAYS,
1394                 FT_ALLOWS_WIDE,
1395                 FT_REQUIRES,
1396                 FT_END
1397         };
1398
1399         LexerKeyword floatTags[] = {
1400                 { "allowedplacement", FT_ALLOWED_PLACEMENT },
1401                 { "allowssideways", FT_ALLOWS_SIDEWAYS },
1402                 { "allowswide", FT_ALLOWS_WIDE },
1403                 { "end", FT_END },
1404                 { "extension", FT_EXT },
1405                 { "guiname", FT_NAME },
1406                 { "htmlattr", FT_HTMLATTR },
1407                 { "htmlstyle", FT_HTMLSTYLE },
1408                 { "htmltag", FT_HTMLTAG },
1409                 { "ispredefined", FT_PREDEFINED },
1410                 { "listcommand", FT_LISTCOMMAND },
1411                 { "listname", FT_LISTNAME },
1412                 { "numberwithin", FT_WITHIN },
1413                 { "placement", FT_PLACEMENT },
1414                 { "refprefix", FT_REFPREFIX },
1415                 { "requires", FT_REQUIRES },
1416                 { "style", FT_STYLE },
1417                 { "type", FT_TYPE },
1418                 { "usesfloatpkg", FT_USESFLOAT }
1419         };
1420
1421         lexrc.pushTable(floatTags);
1422
1423         string ext;
1424         string htmlattr;
1425         docstring htmlstyle;
1426         string htmltag;
1427         string listname;
1428         string listcommand;
1429         string name;
1430         string placement;
1431         string allowed_placement = "!htbpH";
1432         string refprefix;
1433         string style;
1434         string type;
1435         string within;
1436         string requires;
1437         bool usesfloat = true;
1438         bool ispredefined = false;
1439         bool allowswide = true;
1440         bool allowssideways = true;
1441
1442         bool getout = false;
1443         while (!getout && lexrc.isOK()) {
1444                 int le = lexrc.lex();
1445                 switch (le) {
1446                 case Lexer::LEX_UNDEF:
1447                         lexrc.printError("Unknown float tag `$$Token'");
1448                         continue;
1449                 default:
1450                         break;
1451                 }
1452                 switch (le) {
1453                 case FT_TYPE:
1454                         lexrc.next();
1455                         type = lexrc.getString();
1456                         if (floatlist_.typeExist(type)) {
1457                                 Floating const & fl = floatlist_.getType(type);
1458                                 placement = fl.placement();
1459                                 ext = fl.ext();
1460                                 within = fl.within();
1461                                 style = fl.style();
1462                                 name = fl.name();
1463                                 listname = fl.listName();
1464                                 usesfloat = fl.usesFloatPkg();
1465                                 ispredefined = fl.isPredefined();
1466                                 listcommand = fl.listCommand();
1467                                 refprefix = fl.refPrefix();
1468                         }
1469                         break;
1470                 case FT_NAME:
1471                         lexrc.next();
1472                         name = lexrc.getString();
1473                         break;
1474                 case FT_PLACEMENT:
1475                         lexrc.next();
1476                         placement = lexrc.getString();
1477                         break;
1478                 case FT_ALLOWED_PLACEMENT:
1479                         lexrc.next();
1480                         allowed_placement = lexrc.getString();
1481                         break;
1482                 case FT_EXT:
1483                         lexrc.next();
1484                         ext = lexrc.getString();
1485                         break;
1486                 case FT_WITHIN:
1487                         lexrc.next();
1488                         within = lexrc.getString();
1489                         if (within == "none")
1490                                 within.erase();
1491                         break;
1492                 case FT_STYLE:
1493                         lexrc.next();
1494                         style = lexrc.getString();
1495                         break;
1496                 case FT_LISTCOMMAND:
1497                         lexrc.next();
1498                         listcommand = lexrc.getString();
1499                         break;
1500                 case FT_REFPREFIX:
1501                         lexrc.next();
1502                         refprefix = lexrc.getString();
1503                         break;
1504                 case FT_LISTNAME:
1505                         lexrc.next();
1506                         listname = lexrc.getString();
1507                         break;
1508                 case FT_USESFLOAT:
1509                         lexrc.next();
1510                         usesfloat = lexrc.getBool();
1511                         break;
1512                 case FT_REQUIRES:
1513                         lexrc.next();
1514                         requires = lexrc.getString();
1515                         break;
1516                 case FT_PREDEFINED:
1517                         lexrc.next();
1518                         ispredefined = lexrc.getBool();
1519                         break;
1520                 case FT_ALLOWS_SIDEWAYS:
1521                         lexrc.next();
1522                         allowssideways = lexrc.getBool();
1523                         break;
1524                 case FT_ALLOWS_WIDE:
1525                         lexrc.next();
1526                         allowswide = lexrc.getBool();
1527                         break;
1528                 case FT_HTMLATTR:
1529                         lexrc.next();
1530                         htmlattr = lexrc.getString();
1531                         break;
1532                 case FT_HTMLSTYLE:
1533                         lexrc.next();
1534                         htmlstyle = lexrc.getLongString(from_ascii("EndHTMLStyle"));
1535                         break;
1536                 case FT_HTMLTAG:
1537                         lexrc.next();
1538                         htmltag = lexrc.getString();
1539                         break;
1540                 case FT_END:
1541                         getout = true;
1542                         break;
1543                 }
1544         }
1545
1546         lexrc.popTable();
1547
1548         // Here we have a full float if getout == true
1549         if (getout) {
1550                 if (!usesfloat && listcommand.empty()) {
1551                         // if this float uses the same auxfile as an existing one,
1552                         // there is no need for it to provide a list command.
1553                         bool found_ext = false;
1554                         for (auto const & f : floatlist_) {
1555                                 if (f.second.ext() == ext) {
1556                                         found_ext = true;
1557                                         break;
1558                                 }
1559                         }
1560                         if (!found_ext)
1561                                 LYXERR0("The layout does not provide a list command " <<
1562                                   "for the float `" << type << "'. LyX will " <<
1563                                   "not be able to produce a float list.");
1564                 }
1565                 Floating fl(type, placement, ext, within, style, name,
1566                             listname, listcommand, refprefix, allowed_placement,
1567                             htmltag, htmlattr, htmlstyle, requires, usesfloat,
1568                             ispredefined, allowswide, allowssideways);
1569                 floatlist_.newFloat(fl);
1570                 // each float has its own counter
1571                 counters_.newCounter(from_ascii(type), from_ascii(within),
1572                                       docstring(), docstring());
1573                 // also define sub-float counters
1574                 docstring const subtype = "sub-" + from_ascii(type);
1575                 counters_.newCounter(subtype, from_ascii(type),
1576                                       "\\alph{" + subtype + "}", docstring());
1577         }
1578         return getout;
1579 }
1580
1581
1582 bool TextClass::readOutlinerName(Lexer & lexrc)
1583 {
1584         std::string type;
1585         docstring name;
1586         if (lexrc.next())
1587                 type = lexrc.getString();
1588         else {
1589                 lexrc.printError("No type given for OutlinerName: `$$Token'.");
1590                 return false;
1591         }
1592         if (lexrc.next())
1593                 name = lexrc.getDocString();
1594         else {
1595                 lexrc.printError("No name given for OutlinerName: `$$Token'.");
1596                 return false;
1597         }
1598         outliner_names_[type] = name;
1599     return true;
1600 }
1601
1602
1603 string const & TextClass::prerequisites(string const & sep) const
1604 {
1605         if (contains(prerequisites_, ',')) {
1606                 vector<string> const pres = getVectorFromString(prerequisites_);
1607                 prerequisites_ = getStringFromVector(pres, sep);
1608         }
1609         return prerequisites_;
1610 }
1611
1612
1613 bool TextClass::hasLayout(docstring const & n) const
1614 {
1615         docstring const name = n.empty() ? defaultLayoutName() : n;
1616
1617         return find_if(layoutlist_.begin(), layoutlist_.end(),
1618                        LayoutNamesEqual(name))
1619                 != layoutlist_.end();
1620 }
1621
1622
1623 bool TextClass::hasInsetLayout(docstring const & n) const
1624 {
1625         if (n.empty())
1626                 return false;
1627         InsetLayouts::const_iterator it = insetlayoutlist_.find(n);
1628         return it != insetlayoutlist_.end();
1629 }
1630
1631
1632 Layout const & TextClass::operator[](docstring const & name) const
1633 {
1634         LATTEST(!name.empty());
1635
1636         const_iterator it =
1637                 find_if(begin(), end(), LayoutNamesEqual(name));
1638
1639         if (it == end()) {
1640                 LYXERR0("We failed to find the layout '" << name
1641                        << "' in the layout list. You MUST investigate!");
1642                 for (auto const & lay : *this)
1643                         lyxerr  << " " << to_utf8(lay.name()) << endl;
1644
1645                 // We require the name to exist
1646                 static const Layout dummy;
1647                 LASSERT(false, return dummy);
1648         }
1649
1650         return *it;
1651 }
1652
1653
1654 Layout & TextClass::operator[](docstring const & name)
1655 {
1656         LATTEST(!name.empty());
1657         // Safe to continue, given what we do below.
1658
1659         iterator it = find_if(begin(), end(), LayoutNamesEqual(name));
1660
1661         if (it == end()) {
1662                 LYXERR0("We failed to find the layout '" << to_utf8(name)
1663                        << "' in the layout list. You MUST investigate!");
1664                 for (auto const & lay : *this)
1665                         LYXERR0(" " << to_utf8(lay.name()));
1666
1667                 // we require the name to exist
1668                 LATTEST(false);
1669                 // we are here only in release mode
1670                 layoutlist_.push_back(createBasicLayout(name, true));
1671                 it = find_if(begin(), end(), LayoutNamesEqual(name));
1672         }
1673
1674         return *it;
1675 }
1676
1677
1678 bool TextClass::deleteLayout(docstring const & name)
1679 {
1680         if (name == defaultLayoutName() || name == plainLayoutName())
1681                 return false;
1682
1683         LayoutList::iterator it =
1684                 remove_if(layoutlist_.begin(), layoutlist_.end(),
1685                           LayoutNamesEqual(name));
1686
1687         LayoutList::iterator end = layoutlist_.end();
1688         bool const ret = (it != end);
1689         layoutlist_.erase(it, end);
1690         return ret;
1691 }
1692
1693
1694 bool TextClass::deleteInsetLayout(docstring const & name)
1695 {
1696         return insetlayoutlist_.erase(name);
1697 }
1698
1699
1700 // Load textclass info if not loaded yet
1701 bool TextClass::load(string const & path) const
1702 {
1703         if (loaded_)
1704                 return true;
1705
1706         // Read style-file, provided path is searched before the system ones
1707         // If path is a file, it is loaded directly.
1708         FileName layout_file(path);
1709         if (!path.empty() && !layout_file.isReadableFile())
1710                 layout_file = FileName(addName(path, name_ + ".layout"));
1711         if (layout_file.empty() || !layout_file.exists())
1712                 layout_file = libFileSearch("layouts", name_, "layout");
1713         loaded_ = const_cast<TextClass*>(this)->read(layout_file);
1714
1715         if (!loaded_) {
1716                 lyxerr << "Error reading `"
1717                        << to_utf8(makeDisplayPath(layout_file.absFileName()))
1718                        << "'\n(Check `" << name_
1719                        << "')\nCheck your installation and "
1720                           "try Options/Reconfigure..."
1721                        << endl;
1722         }
1723
1724         return loaded_;
1725 }
1726
1727
1728 bool DocumentClass::addLayoutIfNeeded(docstring const & n) const
1729 {
1730         if (hasLayout(n))
1731                 return false;
1732
1733         layoutlist_.push_back(createBasicLayout(n, true));
1734         return true;
1735 }
1736
1737
1738 string DocumentClass::forcedLayouts() const
1739 {
1740         ostringstream os;
1741         bool first = true;
1742         for (auto const & lay : *this) {
1743                 if (lay.forcelocal > 0) {
1744                         if (first) {
1745                                 os << "Format " << LAYOUT_FORMAT << '\n';
1746                                 first = false;
1747                         }
1748                         lay.write(os);
1749                 }
1750         }
1751         return os.str();
1752 }
1753
1754
1755 InsetLayout const & DocumentClass::insetLayout(docstring const & name) const
1756 {
1757         // FIXME The fix for the InsetLayout part of 4812 would be here:
1758         // Add the InsetLayout to the document class if it is not found.
1759         docstring n = name;
1760         InsetLayouts::const_iterator cen = insetlayoutlist_.end();
1761         while (!n.empty()) {
1762                 InsetLayouts::const_iterator cit = insetlayoutlist_.lower_bound(n);
1763                 if (cit != cen && cit->first == n) {
1764                         if (cit->second.obsoleted_by().empty())
1765                                 return cit->second;
1766                         n = cit->second.obsoleted_by();
1767                         return insetLayout(n);
1768                 }
1769                 // If we have a generic prefix (e.g., "Note:"),
1770                 // try if this one alone is found.
1771                 size_t i = n.find(':');
1772                 if (i == string::npos)
1773                         break;
1774                 n = n.substr(0, i);
1775         }
1776         // Layout "name" not found.
1777         return plainInsetLayout();
1778 }
1779
1780
1781 InsetLayout const & DocumentClass::plainInsetLayout() {
1782         static const InsetLayout plain_insetlayout_;
1783         return plain_insetlayout_;
1784 }
1785
1786
1787 docstring const & TextClass::defaultLayoutName() const
1788 {
1789         return defaultlayout_;
1790 }
1791
1792
1793 Layout const & TextClass::defaultLayout() const
1794 {
1795         return operator[](defaultLayoutName());
1796 }
1797
1798
1799 bool TextClass::isDefaultLayout(Layout const & layout) const
1800 {
1801         return layout.name() == defaultLayoutName();
1802 }
1803
1804
1805 bool TextClass::isPlainLayout(Layout const & layout) const
1806 {
1807         return layout.name() == plainLayoutName();
1808 }
1809
1810
1811 Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const
1812 {
1813         static Layout * defaultLayout = nullptr;
1814
1815         if (defaultLayout) {
1816                 defaultLayout->setUnknown(unknown);
1817                 defaultLayout->setName(name);
1818                 return *defaultLayout;
1819         }
1820
1821         static char const * s = "Margin Static\n"
1822                         "LatexType Paragraph\n"
1823                         "LatexName dummy\n"
1824                         "Align Block\n"
1825                         "AlignPossible Left, Right, Center\n"
1826                         "LabelType No_Label\n"
1827                         "End";
1828         istringstream ss(s);
1829         Lexer lex(textClassTags);
1830         lex.setStream(ss);
1831         defaultLayout = new Layout;
1832         defaultLayout->setUnknown(unknown);
1833         defaultLayout->setName(name);
1834         if (!readStyle(lex, *defaultLayout)) {
1835                 // The only way this happens is because the hardcoded layout above
1836                 // is wrong.
1837                 LATTEST(false);
1838         };
1839         return *defaultLayout;
1840 }
1841
1842
1843 DocumentClassPtr getDocumentClass(
1844                 LayoutFile const & baseClass, LayoutModuleList const & modlist,
1845                 string const & cengine, bool const clone)
1846 {
1847         DocumentClassPtr doc_class =
1848             DocumentClassPtr(new DocumentClass(baseClass));
1849         for (auto const & mod : modlist) {
1850                 LyXModule * lm = theModuleList[mod];
1851                 if (!lm) {
1852                         docstring const msg =
1853                                                 bformat(_("The module %1$s has been requested by\n"
1854                                                 "this document but has not been found in the list of\n"
1855                                                 "available modules. If you recently installed it, you\n"
1856                                                 "probably need to reconfigure LyX.\n"), from_utf8(mod));
1857                         if (!clone)
1858                                 frontend::Alert::warning(_("Module not available"), msg);
1859                         continue;
1860                 }
1861                 if (!lm->isAvailable() && !clone) {
1862                         docstring const prereqs = from_utf8(getStringFromVector(lm->prerequisites(), "\n\t"));
1863                         docstring const msg =
1864                                 bformat(_("The module %1$s requires a package that is not\n"
1865                                         "available in your LaTeX installation, or a converter that\n"
1866                                         "you have not installed. LaTeX output may not be possible.\n"
1867                                         "Missing prerequisites:\n"
1868                                                 "\t%2$s\n"
1869                                         "See section 3.1.2.3 (Modules) of the User's Guide for more information."),
1870                                 from_utf8(mod), prereqs);
1871                         frontend::Alert::warning(_("Package not available"), msg, true);
1872                 }
1873                 FileName layout_file = libFileSearch("layouts", lm->getFilename());
1874                 if (!doc_class->read(layout_file, TextClass::MODULE)) {
1875                         docstring const msg =
1876                                                 bformat(_("Error reading module %1$s\n"), from_utf8(mod));
1877                         frontend::Alert::warning(_("Read Error"), msg);
1878                 }
1879         }
1880
1881         if (cengine.empty())
1882                 return doc_class;
1883
1884         LyXCiteEngine * ce = theCiteEnginesList[cengine];
1885         if (!ce) {
1886                 docstring const msg =
1887                                         bformat(_("The cite engine %1$s has been requested by\n"
1888                                         "this document but has not been found in the list of\n"
1889                                         "available engines. If you recently installed it, you\n"
1890                                         "probably need to reconfigure LyX.\n"), from_utf8(cengine));
1891                 if (!clone)
1892                         frontend::Alert::warning(_("Cite Engine not available"), msg);
1893         } else if (!ce->isAvailable() && !clone) {
1894                 docstring const prereqs = from_utf8(getStringFromVector(ce->prerequisites(), "\n\t"));
1895                 docstring const msg =
1896                         bformat(_("The cite engine %1$s requires a package that is not\n"
1897                                 "available in your LaTeX installation, or a converter that\n"
1898                                 "you have not installed. LaTeX output may not be possible.\n"
1899                                 "Missing prerequisites:\n"
1900                                         "\t%2$s\n"
1901                                 "See section 3.1.2.3 (Modules) of the User's Guide for more information."),
1902                         from_utf8(cengine), prereqs);
1903                 frontend::Alert::warning(_("Package not available"), msg, true);
1904         } else {
1905                 FileName layout_file = libFileSearch("citeengines", ce->getFilename());
1906                 if (!doc_class->read(layout_file, TextClass::CITE_ENGINE)) {
1907                         docstring const msg =
1908                                                 bformat(_("Error reading cite engine %1$s\n"), from_utf8(cengine));
1909                         frontend::Alert::warning(_("Read Error"), msg);
1910                 }
1911         }
1912
1913         return doc_class;
1914 }
1915
1916
1917 /////////////////////////////////////////////////////////////////////////
1918 //
1919 // DocumentClass
1920 //
1921 /////////////////////////////////////////////////////////////////////////
1922
1923 DocumentClass::DocumentClass(LayoutFile const & tc)
1924         : TextClass(tc)
1925 {}
1926
1927
1928 bool DocumentClass::hasLaTeXLayout(std::string const & lay) const
1929 {
1930         for (auto const & l : layoutlist_)
1931                 if (l.latexname() == lay)
1932                         return true;
1933         return false;
1934 }
1935
1936
1937 bool DocumentClass::provides(string const & p) const
1938 {
1939         return provides_.find(p) != provides_.end();
1940 }
1941
1942
1943 bool DocumentClass::hasTocLevels() const
1944 {
1945         return min_toclevel_ != Layout::NOT_IN_TOC;
1946 }
1947
1948
1949 Layout const & DocumentClass::getTOCLayout() const
1950 {
1951         // we're going to look for the layout with the minimum toclevel
1952         int minlevel = 1000;
1953         Layout const * lay = nullptr;
1954         for (auto const & l : *this) {
1955                 int const level = l.toclevel;
1956                 // we don't want Part or unnumbered sections
1957                 if (level == Layout::NOT_IN_TOC || level < 0
1958                         || level >= minlevel || l.counter.empty())
1959                         continue;
1960                 lay = &l;
1961                 minlevel = level;
1962         }
1963         if (lay)
1964                 return *lay;
1965         // hmm. that is very odd, so we'll do our best.
1966         return operator[](defaultLayoutName());
1967 }
1968
1969
1970 Layout const & DocumentClass::htmlTOCLayout() const
1971 {
1972         if (html_toc_section_.empty())
1973                 html_toc_section_ = getTOCLayout().name();
1974         return operator[](html_toc_section_);
1975 }
1976
1977
1978 string const DocumentClass::getCiteFormat(CiteEngineType const & type,
1979         string const & entry, bool const punct, string const & fallback) const
1980 {
1981         string default_format = "{%fullnames:author%[[%fullnames:author%, ]][[{%fullnames:editor%[[%fullnames:editor%, ed., ]]}]]}"
1982                                 "\"%title%\"{%journal%[[, {!<i>!}%journal%{!</i>!}]][[{%publisher%[[, %publisher%]]"
1983                                 "[[{%institution%[[, %institution%]]}]]}]]}{%year%[[ (%year%)]]}{%pages%[[, %pages%]]}";
1984         if (punct)
1985                 default_format += ".";
1986
1987         map<CiteEngineType, map<string, string> >::const_iterator itype = cite_formats_.find(type);
1988         if (itype == cite_formats_.end())
1989                 return default_format;
1990         map<string, string>::const_iterator it = itype->second.find(entry);
1991         if (it == itype->second.end() && !fallback.empty())
1992                 it = itype->second.find(fallback);
1993         if (it == itype->second.end())
1994                 return default_format;
1995         if (punct)
1996                 return it->second + ".";
1997         return it->second;
1998 }
1999
2000
2001 string const & DocumentClass::getCiteMacro(CiteEngineType const & type,
2002         string const & macro) const
2003 {
2004         static string empty;
2005         map<CiteEngineType, map<string, string> >::const_iterator itype = cite_macros_.find(type);
2006         if (itype == cite_macros_.end())
2007                 return empty;
2008         map<string, string>::const_iterator it = itype->second.find(macro);
2009         if (it == itype->second.end())
2010                 return empty;
2011         return it->second;
2012 }
2013
2014
2015 vector<string> const DocumentClass::citeCommands(
2016         CiteEngineType const & type) const
2017 {
2018         vector<CitationStyle> const styles = citeStyles(type);
2019         vector<string> cmds;
2020         for (auto const & cs : styles)
2021                 cmds.push_back(cs.name);
2022
2023         return cmds;
2024 }
2025
2026
2027 vector<CitationStyle> const & DocumentClass::citeStyles(
2028         CiteEngineType const & type) const
2029 {
2030         static vector<CitationStyle> empty;
2031         map<CiteEngineType, vector<CitationStyle> >::const_iterator it = cite_styles_.find(type);
2032         if (it == cite_styles_.end())
2033                 return empty;
2034         return it->second;
2035 }
2036
2037
2038 /////////////////////////////////////////////////////////////////////////
2039 //
2040 // PageSides
2041 //
2042 /////////////////////////////////////////////////////////////////////////
2043
2044 ostream & operator<<(ostream & os, PageSides p)
2045 {
2046         switch (p) {
2047         case OneSide:
2048                 os << '1';
2049                 break;
2050         case TwoSides:
2051                 os << '2';
2052                 break;
2053         }
2054         return os;
2055 }
2056
2057
2058 } // namespace lyx