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 = 81; // rikiheck: GuiName for counters
  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         size_type const 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 required;
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                         required = 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, required, 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                                 bformat(_("%1$s (Float)"), _(name)));
1574                 // also define sub-float counters
1575                 docstring const subtype = "sub-" + from_ascii(type);
1576                 counters_.newCounter(subtype, from_ascii(type),
1577                                 "\\alph{" + subtype + "}", docstring(),
1578                                  bformat(_("Sub-%1$s (Float)"), _(name)));
1579         }
1580         return getout;
1581 }
1582
1583
1584 bool TextClass::readOutlinerName(Lexer & lexrc)
1585 {
1586         std::string type;
1587         docstring name;
1588         if (lexrc.next())
1589                 type = lexrc.getString();
1590         else {
1591                 lexrc.printError("No type given for OutlinerName: `$$Token'.");
1592                 return false;
1593         }
1594         if (lexrc.next())
1595                 name = lexrc.getDocString();
1596         else {
1597                 lexrc.printError("No name given for OutlinerName: `$$Token'.");
1598                 return false;
1599         }
1600         outliner_names_[type] = name;
1601     return true;
1602 }
1603
1604
1605 string const & TextClass::prerequisites(string const & sep) const
1606 {
1607         if (contains(prerequisites_, ',')) {
1608                 vector<string> const pres = getVectorFromString(prerequisites_);
1609                 prerequisites_ = getStringFromVector(pres, sep);
1610         }
1611         return prerequisites_;
1612 }
1613
1614
1615 bool TextClass::hasLayout(docstring const & n) const
1616 {
1617         docstring const name = n.empty() ? defaultLayoutName() : n;
1618
1619         return find_if(layoutlist_.begin(), layoutlist_.end(),
1620                        LayoutNamesEqual(name))
1621                 != layoutlist_.end();
1622 }
1623
1624
1625 bool TextClass::hasInsetLayout(docstring const & n) const
1626 {
1627         if (n.empty())
1628                 return false;
1629         InsetLayouts::const_iterator it = insetlayoutlist_.find(n);
1630         return it != insetlayoutlist_.end();
1631 }
1632
1633
1634 Layout const & TextClass::operator[](docstring const & name) const
1635 {
1636         LATTEST(!name.empty());
1637
1638         const_iterator it =
1639                 find_if(begin(), end(), LayoutNamesEqual(name));
1640
1641         if (it == end()) {
1642                 LYXERR0("We failed to find the layout '" << name
1643                        << "' in the layout list. You MUST investigate!");
1644                 for (auto const & lay : *this)
1645                         lyxerr  << " " << to_utf8(lay.name()) << endl;
1646
1647                 // We require the name to exist
1648                 static const Layout dummy;
1649                 LASSERT(false, return dummy);
1650         }
1651
1652         return *it;
1653 }
1654
1655
1656 Layout & TextClass::operator[](docstring const & name)
1657 {
1658         LATTEST(!name.empty());
1659         // Safe to continue, given what we do below.
1660
1661         iterator it = find_if(begin(), end(), LayoutNamesEqual(name));
1662
1663         if (it == end()) {
1664                 LYXERR0("We failed to find the layout '" << to_utf8(name)
1665                        << "' in the layout list. You MUST investigate!");
1666                 for (auto const & lay : *this)
1667                         LYXERR0(" " << to_utf8(lay.name()));
1668
1669                 // we require the name to exist
1670                 LATTEST(false);
1671                 // we are here only in release mode
1672                 layoutlist_.push_back(createBasicLayout(name, true));
1673                 it = find_if(begin(), end(), LayoutNamesEqual(name));
1674         }
1675
1676         return *it;
1677 }
1678
1679
1680 bool TextClass::deleteLayout(docstring const & name)
1681 {
1682         if (name == defaultLayoutName() || name == plainLayoutName())
1683                 return false;
1684
1685         LayoutList::iterator it =
1686                 remove_if(layoutlist_.begin(), layoutlist_.end(),
1687                           LayoutNamesEqual(name));
1688
1689         LayoutList::iterator end = layoutlist_.end();
1690         bool const ret = (it != end);
1691         layoutlist_.erase(it, end);
1692         return ret;
1693 }
1694
1695
1696 bool TextClass::deleteInsetLayout(docstring const & name)
1697 {
1698         return insetlayoutlist_.erase(name);
1699 }
1700
1701
1702 // Load textclass info if not loaded yet
1703 bool TextClass::load(string const & path) const
1704 {
1705         if (loaded_)
1706                 return true;
1707
1708         // Read style-file, provided path is searched before the system ones
1709         // If path is a file, it is loaded directly.
1710         FileName layout_file(path);
1711         if (!path.empty() && !layout_file.isReadableFile())
1712                 layout_file = FileName(addName(path, name_ + ".layout"));
1713         if (layout_file.empty() || !layout_file.exists())
1714                 layout_file = libFileSearch("layouts", name_, "layout");
1715         loaded_ = const_cast<TextClass*>(this)->read(layout_file);
1716
1717         if (!loaded_) {
1718                 lyxerr << "Error reading `"
1719                        << to_utf8(makeDisplayPath(layout_file.absFileName()))
1720                        << "'\n(Check `" << name_
1721                        << "')\nCheck your installation and "
1722                           "try Options/Reconfigure..."
1723                        << endl;
1724         }
1725
1726         return loaded_;
1727 }
1728
1729
1730 bool DocumentClass::addLayoutIfNeeded(docstring const & n) const
1731 {
1732         if (hasLayout(n))
1733                 return false;
1734
1735         layoutlist_.push_back(createBasicLayout(n, true));
1736         return true;
1737 }
1738
1739
1740 string DocumentClass::forcedLayouts() const
1741 {
1742         ostringstream os;
1743         bool first = true;
1744         for (auto const & lay : *this) {
1745                 if (lay.forcelocal > 0) {
1746                         if (first) {
1747                                 os << "Format " << LAYOUT_FORMAT << '\n';
1748                                 first = false;
1749                         }
1750                         lay.write(os);
1751                 }
1752         }
1753         return os.str();
1754 }
1755
1756
1757 InsetLayout const & DocumentClass::insetLayout(docstring const & name) const
1758 {
1759         // FIXME The fix for the InsetLayout part of 4812 would be here:
1760         // Add the InsetLayout to the document class if it is not found.
1761         docstring n = name;
1762         InsetLayouts::const_iterator cen = insetlayoutlist_.end();
1763         while (!n.empty()) {
1764                 InsetLayouts::const_iterator cit = insetlayoutlist_.lower_bound(n);
1765                 if (cit != cen && cit->first == n) {
1766                         if (cit->second.obsoleted_by().empty())
1767                                 return cit->second;
1768                         n = cit->second.obsoleted_by();
1769                         return insetLayout(n);
1770                 }
1771                 // If we have a generic prefix (e.g., "Note:"),
1772                 // try if this one alone is found.
1773                 size_t i = n.find(':');
1774                 if (i == string::npos)
1775                         break;
1776                 n = n.substr(0, i);
1777         }
1778         // Layout "name" not found.
1779         return plainInsetLayout();
1780 }
1781
1782
1783 InsetLayout const & DocumentClass::plainInsetLayout() {
1784         static const InsetLayout plain_insetlayout_;
1785         return plain_insetlayout_;
1786 }
1787
1788
1789 docstring const & TextClass::defaultLayoutName() const
1790 {
1791         return defaultlayout_;
1792 }
1793
1794
1795 Layout const & TextClass::defaultLayout() const
1796 {
1797         return operator[](defaultLayoutName());
1798 }
1799
1800
1801 bool TextClass::isDefaultLayout(Layout const & layout) const
1802 {
1803         return layout.name() == defaultLayoutName();
1804 }
1805
1806
1807 bool TextClass::isPlainLayout(Layout const & layout) const
1808 {
1809         return layout.name() == plainLayoutName();
1810 }
1811
1812
1813 Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const
1814 {
1815         static Layout * defaultLayout = nullptr;
1816
1817         if (defaultLayout) {
1818                 defaultLayout->setUnknown(unknown);
1819                 defaultLayout->setName(name);
1820                 return *defaultLayout;
1821         }
1822
1823         static char const * s = "Margin Static\n"
1824                         "LatexType Paragraph\n"
1825                         "LatexName dummy\n"
1826                         "Align Block\n"
1827                         "AlignPossible Left, Right, Center\n"
1828                         "LabelType No_Label\n"
1829                         "End";
1830         istringstream ss(s);
1831         Lexer lex(textClassTags);
1832         lex.setStream(ss);
1833         defaultLayout = new Layout;
1834         defaultLayout->setUnknown(unknown);
1835         defaultLayout->setName(name);
1836         if (!readStyle(lex, *defaultLayout)) {
1837                 // The only way this happens is because the hardcoded layout above
1838                 // is wrong.
1839                 LATTEST(false);
1840         };
1841         return *defaultLayout;
1842 }
1843
1844
1845 DocumentClassPtr getDocumentClass(
1846                 LayoutFile const & baseClass, LayoutModuleList const & modlist,
1847                 string const & cengine, bool const clone)
1848 {
1849         DocumentClassPtr doc_class =
1850             DocumentClassPtr(new DocumentClass(baseClass));
1851         for (auto const & mod : modlist) {
1852                 LyXModule * lm = theModuleList[mod];
1853                 if (!lm) {
1854                         docstring const msg =
1855                                                 bformat(_("The module %1$s has been requested by\n"
1856                                                 "this document but has not been found in the list of\n"
1857                                                 "available modules. If you recently installed it, you\n"
1858                                                 "probably need to reconfigure LyX.\n"), from_utf8(mod));
1859                         if (!clone)
1860                                 frontend::Alert::warning(_("Module not available"), msg);
1861                         continue;
1862                 }
1863                 if (!lm->isAvailable() && !clone) {
1864                         docstring const prereqs = from_utf8(getStringFromVector(lm->prerequisites(), "\n\t"));
1865                         docstring const msg =
1866                                 bformat(_("The module %1$s requires a package that is not\n"
1867                                         "available in your LaTeX installation, or a converter that\n"
1868                                         "you have not installed. LaTeX output may not be possible.\n"
1869                                         "Missing prerequisites:\n"
1870                                                 "\t%2$s\n"
1871                                         "See section 3.1.2.3 (Modules) of the User's Guide for more information."),
1872                                 from_utf8(mod), prereqs);
1873                         frontend::Alert::warning(_("Package not available"), msg, true);
1874                 }
1875                 FileName layout_file = libFileSearch("layouts", lm->getFilename());
1876                 if (!doc_class->read(layout_file, TextClass::MODULE)) {
1877                         docstring const msg =
1878                                                 bformat(_("Error reading module %1$s\n"), from_utf8(mod));
1879                         frontend::Alert::warning(_("Read Error"), msg);
1880                 }
1881         }
1882
1883         if (cengine.empty())
1884                 return doc_class;
1885
1886         LyXCiteEngine * ce = theCiteEnginesList[cengine];
1887         if (!ce) {
1888                 docstring const msg =
1889                                         bformat(_("The cite engine %1$s has been requested by\n"
1890                                         "this document but has not been found in the list of\n"
1891                                         "available engines. If you recently installed it, you\n"
1892                                         "probably need to reconfigure LyX.\n"), from_utf8(cengine));
1893                 if (!clone)
1894                         frontend::Alert::warning(_("Cite Engine not available"), msg);
1895         } else if (!ce->isAvailable() && !clone) {
1896                 docstring const prereqs = from_utf8(getStringFromVector(ce->prerequisites(), "\n\t"));
1897                 docstring const msg =
1898                         bformat(_("The cite engine %1$s requires a package that is not\n"
1899                                 "available in your LaTeX installation, or a converter that\n"
1900                                 "you have not installed. LaTeX output may not be possible.\n"
1901                                 "Missing prerequisites:\n"
1902                                         "\t%2$s\n"
1903                                 "See section 3.1.2.3 (Modules) of the User's Guide for more information."),
1904                         from_utf8(cengine), prereqs);
1905                 frontend::Alert::warning(_("Package not available"), msg, true);
1906         } else {
1907                 FileName layout_file = libFileSearch("citeengines", ce->getFilename());
1908                 if (!doc_class->read(layout_file, TextClass::CITE_ENGINE)) {
1909                         docstring const msg =
1910                                                 bformat(_("Error reading cite engine %1$s\n"), from_utf8(cengine));
1911                         frontend::Alert::warning(_("Read Error"), msg);
1912                 }
1913         }
1914
1915         return doc_class;
1916 }
1917
1918
1919 /////////////////////////////////////////////////////////////////////////
1920 //
1921 // DocumentClass
1922 //
1923 /////////////////////////////////////////////////////////////////////////
1924
1925 DocumentClass::DocumentClass(LayoutFile const & tc)
1926         : TextClass(tc)
1927 {}
1928
1929
1930 bool DocumentClass::hasLaTeXLayout(std::string const & lay) const
1931 {
1932         for (auto const & l : layoutlist_)
1933                 if (l.latexname() == lay)
1934                         return true;
1935         return false;
1936 }
1937
1938
1939 bool DocumentClass::provides(string const & p) const
1940 {
1941         return provides_.find(p) != provides_.end();
1942 }
1943
1944
1945 bool DocumentClass::hasTocLevels() const
1946 {
1947         return min_toclevel_ != Layout::NOT_IN_TOC;
1948 }
1949
1950
1951 Layout const & DocumentClass::getTOCLayout() const
1952 {
1953         // we're going to look for the layout with the minimum toclevel
1954         int minlevel = 1000;
1955         Layout const * lay = nullptr;
1956         for (auto const & l : *this) {
1957                 int const level = l.toclevel;
1958                 // we don't want Part or unnumbered sections
1959                 if (level == Layout::NOT_IN_TOC || level < 0
1960                         || level >= minlevel || l.counter.empty())
1961                         continue;
1962                 lay = &l;
1963                 minlevel = level;
1964         }
1965         if (lay)
1966                 return *lay;
1967         // hmm. that is very odd, so we'll do our best.
1968         return operator[](defaultLayoutName());
1969 }
1970
1971
1972 Layout const & DocumentClass::htmlTOCLayout() const
1973 {
1974         if (html_toc_section_.empty())
1975                 html_toc_section_ = getTOCLayout().name();
1976         return operator[](html_toc_section_);
1977 }
1978
1979
1980 string const DocumentClass::getCiteFormat(CiteEngineType const & type,
1981         string const & entry, bool const punct, string const & fallback) const
1982 {
1983         string default_format = "{%fullnames:author%[[%fullnames:author%, ]][[{%fullnames:editor%[[%fullnames:editor%, ed., ]]}]]}"
1984                                 "\"%title%\"{%journal%[[, {!<i>!}%journal%{!</i>!}]][[{%publisher%[[, %publisher%]]"
1985                                 "[[{%institution%[[, %institution%]]}]]}]]}{%year%[[ (%year%)]]}{%pages%[[, %pages%]]}";
1986         if (punct)
1987                 default_format += ".";
1988
1989         map<CiteEngineType, map<string, string> >::const_iterator itype = cite_formats_.find(type);
1990         if (itype == cite_formats_.end())
1991                 return default_format;
1992         map<string, string>::const_iterator it = itype->second.find(entry);
1993         if (it == itype->second.end() && !fallback.empty())
1994                 it = itype->second.find(fallback);
1995         if (it == itype->second.end())
1996                 return default_format;
1997         if (punct)
1998                 return it->second + ".";
1999         return it->second;
2000 }
2001
2002
2003 string const & DocumentClass::getCiteMacro(CiteEngineType const & type,
2004         string const & macro) const
2005 {
2006         static string empty;
2007         map<CiteEngineType, map<string, string> >::const_iterator itype = cite_macros_.find(type);
2008         if (itype == cite_macros_.end())
2009                 return empty;
2010         map<string, string>::const_iterator it = itype->second.find(macro);
2011         if (it == itype->second.end())
2012                 return empty;
2013         return it->second;
2014 }
2015
2016
2017 vector<string> const DocumentClass::citeCommands(
2018         CiteEngineType const & type) const
2019 {
2020         vector<CitationStyle> const styles = citeStyles(type);
2021         vector<string> cmds;
2022         for (auto const & cs : styles)
2023                 cmds.push_back(cs.name);
2024
2025         return cmds;
2026 }
2027
2028
2029 vector<CitationStyle> const & DocumentClass::citeStyles(
2030         CiteEngineType const & type) const
2031 {
2032         static vector<CitationStyle> empty;
2033         map<CiteEngineType, vector<CitationStyle> >::const_iterator it = cite_styles_.find(type);
2034         if (it == cite_styles_.end())
2035                 return empty;
2036         return it->second;
2037 }
2038
2039
2040 /////////////////////////////////////////////////////////////////////////
2041 //
2042 // PageSides
2043 //
2044 /////////////////////////////////////////////////////////////////////////
2045
2046 ostream & operator<<(ostream & os, PageSides p)
2047 {
2048         switch (p) {
2049         case OneSide:
2050                 os << '1';
2051                 break;
2052         case TwoSides:
2053                 os << '2';
2054                 break;
2055         }
2056         return os;
2057 }
2058
2059
2060 } // namespace lyx