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 = 78; // spitz: FontsizeFormat
  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|a4paper|a5paper|b5paper|letterpaper|legalpaper|executivepaper"),
 154           opt_pagestyle_("empty|plain|headings|fancy"), fontsize_format_("$$spt"), pagesize_("default"),
 155           pagestyle_("default"), tablestyle_("default"), columns_(1), sides_(OneSide), secnumdepth_(3),
 156           tocdepth_(3), outputType_(LATEX), outputFormat_("latex"),
 157           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                         if (name.empty()) {
 749                                 string s = "Could not read name for InsetLayout: `$$Token' "
 750                                         + lexrc.getString() + " is probably not valid UTF-8!";
 751                                 lexrc.printError(s);
 752                                 InsetLayout il;
 753                                 // Since we couldn't read the name, we just scan the rest
 754                                 // of the style and discard it.
 755                                 il.read(lexrc, *this);
 756                                 // Let's try to continue rather than abort.
 757                                 // error = true;
 758                         } else if (hasInsetLayout(name)) {
 759                                 InsetLayout & il = insetlayoutlist_[name];
 760                                 error = !il.read(lexrc, *this);
 761                         } else {
 762                                 InsetLayout il;
 763                                 il.setName(name);
 764                                 error = !il.read(lexrc, *this);
 765                                 if (!error)
 766                                         insetlayoutlist_[name] = il;
 767                         }
 768                         break;
 769                 }
 770
 771                 case TC_FLOAT:
 772                         error = !readFloat(lexrc);
 773                         break;
 774
 775                 case TC_CITEENGINE:
 776                         error = !readCiteEngine(lexrc, rt);
 777                         break;
 778
 779                 case TC_ADDTOCITEENGINE:
 780                         error = !readCiteEngine(lexrc, rt, true);
 781                         break;
 782
 783                 case TC_CITEENGINETYPE:
 784                         if (lexrc.next())
 785                                 opt_enginetype_ = rtrim(lexrc.getString());
 786                         break;
 787
 788                 case TC_CITEFORMAT:
 789                         error = !readCiteFormat(lexrc, rt);
 790                         break;
 791
 792                 case TC_CITEFRAMEWORK:
 793                         lexrc.next();
 794                         citeframework_ = rtrim(lexrc.getString());
 795                         break;
 796
 797                 case TC_MAXCITENAMES:
 798                         lexrc.next();
 799                         maxcitenames_ = size_t(lexrc.getInteger());
 800                         break;
 801
 802                 case TC_DEFAULTBIBLIO:
 803                         if (lexrc.next()) {
 804                                 vector<string> const dbs =
 805                                         getVectorFromString(rtrim(lexrc.getString()), "|");
 806                                 vector<string>::const_iterator it  = dbs.begin();
 807                                 vector<string>::const_iterator end = dbs.end();
 808                                 for (; it != end; ++it) {
 809                                         if (!contains(*it, ':')) {
 810                                                 vector<string> const enginetypes =
 811                                                         getVectorFromString(opt_enginetype_, "|");
 812                                                 for (string const &s: enginetypes)
 813                                                         cite_default_biblio_style_[s] = *it;
 814                                         } else {
 815                                                 string eng;
 816                                                 string const db = split(*it, eng, ':');
 817                                                 cite_default_biblio_style_[eng] = db;
 818                                         }
 819                                 }
 820                         }
 821                         break;
 822
 823                 case TC_BIBINTOC:
 824                         if (lexrc.next())
 825                                 bibintoc_ = lexrc.getBool();
 826                         break;
 827
 828                 case TC_FULLAUTHORLIST:
 829                         if (lexrc.next())
 830                                 cite_full_author_list_ &= lexrc.getBool();
 831                         break;
 832
 833                 case TC_NOCOUNTER:
 834                         if (lexrc.next()) {
 835                                 docstring const cnt = lexrc.getDocString();
 836                                 if (!counters_.remove(cnt))
 837                                         LYXERR0("Unable to remove counter: " + to_utf8(cnt));
 838                         }
 839                         break;
 840
 841                 case TC_IFCOUNTER:
 842                         ifcounter = true;
 843                         // fall through
 844                 case TC_COUNTER:
 845                         if (lexrc.next()) {
 846                                 docstring const name = lexrc.getDocString();
 847                                 if (name.empty()) {
 848                                         string s = "Could not read name for counter: `$$Token' "
 849                                                         + lexrc.getString() + " is probably not valid UTF-8!";
 850                                         lexrc.printError(s.c_str());
 851                                         Counter c;
 852                                         // Since we couldn't read the name, we just scan the rest
 853                                         // and discard it.
 854                                         c.read(lexrc);
 855                                 } else
 856                                         error = !counters_.read(lexrc, name, !ifcounter);
 857                         }
 858                         else {
 859                                 lexrc.printError("No name given for style: `$$Token'.");
 860                                 error = true;
 861                         }
 862                         break;
 863
 864                 case TC_TITLELATEXTYPE:
 865                         readTitleType(lexrc);
 866                         break;
 867
 868                 case TC_TITLELATEXNAME:
 869                         if (lexrc.next())
 870                                 titlename_ = lexrc.getString();
 871                         break;
 872
 873                 case TC_NOFLOAT:
 874                         if (lexrc.next()) {
 875                                 string const nofloat = lexrc.getString();
 876                                 floatlist_.erase(nofloat);
 877                         }
 878                         break;
 879
 880                 case TC_OUTLINERNAME:
 881                         error = !readOutlinerName(lexrc);
 882                         break;
 883
 884                 case TC_TABLESTYLE:
 885                         lexrc.next();
 886                         tablestyle_ = rtrim(lexrc.getString());
 887                         break;
 888                 } // end of switch
 889         }
 890
 891         // at present, we abort if we encounter an error,
 892         // so there is no point continuing.
 893         if (error)
 894                 return ERROR;
 895
 896         if (rt != BASECLASS)
 897                 return OK;
 898
 899         if (defaultlayout_.empty()) {
 900                 LYXERR0("Error: Textclass '" << name_
 901                                                 << "' is missing a defaultstyle.");
 902                 return ERROR;
 903         }
 904
 905         // Try to erase "stdinsets" from the provides_ set.
 906         // The
 907         //   Provides stdinsets 1
 908         // declaration simply tells us that the standard insets have been
 909         // defined. (It's found in stdinsets.inc but could also be used in
 910         // user-defined files.) There isn't really any such package. So we
 911         // might as well go ahead and erase it.
 912         // If we do not succeed, then it was not there, which means that
 913         // the textclass did not provide the definitions of the standard
 914         // insets. So we need to try to load them.
 915         int erased = provides_.erase("stdinsets");
 916         if (!erased) {
 917                 FileName tmp = libFileSearch("layouts", "stdinsets.inc");
 918
 919                 if (tmp.empty()) {
 920                         frontend::Alert::warning(_("Missing File"),
 921                                 _("Could not find stdinsets.inc! This may lead to data loss!"));
 922                         error = true;
 923                 } else if (!read(tmp, MERGE)) {
 924                         frontend::Alert::warning(_("Corrupt File"),
 925                                 _("Could not read stdinsets.inc! This may lead to data loss!"));
 926                         error = true;
 927                 }
 928         }
 929
 930         min_toclevel_ = Layout::NOT_IN_TOC;
 931         max_toclevel_ = Layout::NOT_IN_TOC;
 932         const_iterator lit = begin();
 933         const_iterator len = end();
 934         for (; lit != len; ++lit) {
 935                 int const toclevel = lit->toclevel;
 936                 if (toclevel != Layout::NOT_IN_TOC) {
 937                         if (min_toclevel_ == Layout::NOT_IN_TOC)
 938                                 min_toclevel_ = toclevel;
 939                         else
 940                                 min_toclevel_ = min(min_toclevel_, toclevel);
 941                         max_toclevel_ = max(max_toclevel_, toclevel);
 942                 }
 943         }
 944         LYXERR(Debug::TCLASS, "Minimum TocLevel is " << min_toclevel_
 945                 << ", maximum is " << max_toclevel_);
 946
 947         return (error ? ERROR : OK);
 948 }
 949
 950
 951 void TextClass::readTitleType(Lexer & lexrc)
 952 {
 953         LexerKeyword titleTypeTags[] = {
 954                 { "commandafter", TITLE_COMMAND_AFTER },
 955                 { "environment",  TITLE_ENVIRONMENT }
 956         };
 957
 958         PushPopHelper pph(lexrc, titleTypeTags);
 959
 960         int le = lexrc.lex();
 961         switch (le) {
 962         case Lexer::LEX_UNDEF:
 963                 lexrc.printError("Unknown output type `$$Token'");
 964                 break;
 965         case TITLE_COMMAND_AFTER:
 966         case TITLE_ENVIRONMENT:
 967                 titletype_ = static_cast<TitleLatexType>(le);
 968                 break;
 969         default:
 970                 LYXERR0("Unhandled value " << le << " in TextClass::readTitleType.");
 971                 break;
 972         }
 973 }
 974
 975
 976 void TextClass::readOutputType(Lexer & lexrc)
 977 {
 978         LexerKeyword outputTypeTags[] = {
 979                 { "docbook",  DOCBOOK },
 980                 { "latex",    LATEX },
 981                 { "literate", LITERATE }
 982         };
 983
 984         PushPopHelper pph(lexrc, outputTypeTags);
 985
 986         int le = lexrc.lex();
 987         switch (le) {
 988         case Lexer::LEX_UNDEF:
 989                 lexrc.printError("Unknown output type `$$Token'");
 990                 return;
 991         case LATEX:
 992         case DOCBOOK:
 993         case LITERATE:
 994                 outputType_ = static_cast<OutputType>(le);
 995                 break;
 996         default:
 997                 LYXERR0("Unhandled value " << le);
 998                 break;
 999         }
1000 }
1001
1002
1003 void TextClass::readClassOptions(Lexer & lexrc)
1004 {
1005         enum {
1006                 CO_FONTSIZE = 1,
1007                 CO_FONTSIZE_FORMAT,
1008                 CO_PAGESIZE,
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                 {"pagestyle", CO_PAGESTYLE }
1023         };
1024
1025         lexrc.pushTable(classOptionsTags);
1026         bool getout = false;
1027         while (!getout && lexrc.isOK()) {
1028                 int le = lexrc.lex();
1029                 switch (le) {
1030                 case Lexer::LEX_UNDEF:
1031                         lexrc.printError("Unknown ClassOption tag `$$Token'");
1032                         continue;
1033                 default:
1034                         break;
1035                 }
1036                 switch (le) {
1037                 case CO_FONTSIZE:
1038                         lexrc.next();
1039                         opt_fontsize_ = rtrim(lexrc.getString());
1040                         break;
1041                 case CO_FONTSIZE_FORMAT:
1042                         lexrc.next();
1043                         fontsize_format_ = rtrim(lexrc.getString());
1044                         break;
1045                 case CO_PAGESIZE:
1046                         lexrc.next();
1047                         opt_pagesize_ = rtrim(lexrc.getString());
1048                         break;
1049                 case CO_PAGESTYLE:
1050                         lexrc.next();
1051                         opt_pagestyle_ = rtrim(lexrc.getString());
1052                         break;
1053                 case CO_OTHER:
1054                         lexrc.next();
1055                         if (options_.empty())
1056                                 options_ = lexrc.getString();
1057                         else
1058                                 options_ += ',' + lexrc.getString();
1059                         break;
1060                 case CO_HEADER:
1061                         lexrc.next();
1062                         class_header_ = subst(lexrc.getString(), "&quot;", "\"");
1063                         break;
1064                 case CO_END:
1065                         getout = true;
1066                         break;
1067                 }
1068         }
1069         lexrc.popTable();
1070 }
1071
1072
1073 vector<CitationStyle> const & TextClass::getCiteStyles(
1074         CiteEngineType const & type) const
1075 {
1076         static vector<CitationStyle> empty;
1077         map<CiteEngineType, vector<CitationStyle> >::const_iterator it = cite_styles_.find(type);
1078         if (it == cite_styles_.end())
1079                 return empty;
1080         return it->second;
1081 }
1082
1083
1084 bool TextClass::readCiteEngine(Lexer & lexrc, ReadType rt, bool const add)
1085 {
1086         int const type = readCiteEngineType(lexrc);
1087         bool authoryear = (type & ENGINE_TYPE_AUTHORYEAR);
1088         bool numerical = (type & ENGINE_TYPE_NUMERICAL);
1089         bool defce = (type & ENGINE_TYPE_DEFAULT);
1090
1091         if (rt == CITE_ENGINE) {
1092                 // The cite engines are not supposed to overwrite
1093                 // CiteStyle defined by the class or a module.
1094                 if (authoryear)
1095                         authoryear = getCiteStyles(ENGINE_TYPE_AUTHORYEAR).empty();
1096                 if (numerical)
1097                         numerical = getCiteStyles(ENGINE_TYPE_NUMERICAL).empty();
1098                 if (defce)
1099                         defce = getCiteStyles(ENGINE_TYPE_DEFAULT).empty();
1100         }
1101
1102         if (rt != CITE_ENGINE && !add) {
1103                 // Reset if we defined CiteStyle
1104                 // from the class or a module
1105                 if (authoryear)
1106                         cite_styles_[ENGINE_TYPE_AUTHORYEAR].clear();
1107                 if (numerical)
1108                         cite_styles_[ENGINE_TYPE_NUMERICAL].clear();
1109                 if (defce)
1110                         cite_styles_[ENGINE_TYPE_DEFAULT].clear();
1111         }
1112
1113         string def;
1114         bool getout = false;
1115         while (!getout && lexrc.isOK()) {
1116                 lexrc.eatLine();
1117                 def = lexrc.getString();
1118                 def = subst(def, " ", "");
1119                 def = subst(def, "\t", "");
1120                 if (compare_ascii_no_case(def, "end") == 0) {
1121                         getout = true;
1122                         continue;
1123                 }
1124                 CitationStyle cs;
1125                 char ichar = def[0];
1126                 if (ichar == '#')
1127                         continue;
1128                 if (isUpperCase(ichar)) {
1129                         cs.forceUpperCase = true;
1130                         def[0] = lowercase(ichar);
1131                 }
1132
1133                 /** For portability reasons (between different
1134                  *  cite engines such as natbib and biblatex),
1135                  *  we distinguish between:
1136                  *  1. The LyX name as output in the LyX file
1137                  *  2. Possible aliases that might fall back to
1138                  *     the given LyX name in the current engine
1139                  *  3. The actual LaTeX command that is output
1140                  *  (2) and (3) are optional.
1141                  *  Also, the GUI string for the starred version can
1142                  *  be changed
1143                  *  The syntax is:
1144                  *  LyXName|alias,nextalias*<!stardesc!stardesctooltip>[][]=latexcmd
1145                  */
1146                 enum ScanMode {
1147                         LyXName,
1148                         Alias,
1149                         LaTeXCmd,
1150                         StarDesc
1151                 };
1152
1153                 ScanMode mode = LyXName;
1154                 ScanMode oldmode = LyXName;
1155                 string lyx_cmd;
1156                 string alias;
1157                 string latex_cmd;
1158                 string stardesc;
1159                 size_t const n = def.size();
1160                 for (size_t i = 0; i != n; ++i) {
1161                         ichar = def[i];
1162                         if (ichar == '|')
1163                                 mode = Alias;
1164                         else if (ichar == '=')
1165                                 mode = LaTeXCmd;
1166                         else if (ichar == '<') {
1167                                 oldmode = mode;
1168                                 mode = StarDesc;
1169                         } else if (ichar == '>')
1170                                 mode = oldmode;
1171                         else if (mode == LaTeXCmd)
1172                                 latex_cmd += ichar;
1173                         else if (mode == StarDesc)
1174                                 stardesc += ichar;
1175                         else if (ichar == '$')
1176                                 cs.hasQualifiedList = true;
1177                         else if (ichar == '*')
1178                                 cs.hasStarredVersion = true;
1179                         else if (ichar == '[' && cs.textAfter)
1180                                 cs.textBefore = true;
1181                         else if (ichar == '[')
1182                                 cs.textAfter = true;
1183                         else if (ichar != ']') {
1184                                 if (mode == Alias)
1185                                         alias += ichar;
1186                                 else
1187                                         lyx_cmd += ichar;
1188                         }
1189                 }
1190                 cs.name = lyx_cmd;
1191                 cs.cmd = latex_cmd.empty() ? lyx_cmd : latex_cmd;
1192                 if (!alias.empty()) {
1193                         vector<string> const aliases = getVectorFromString(alias);
1194                         for (string const &s: aliases)
1195                                 cite_command_aliases_[s] = lyx_cmd;
1196                 }
1197                 vector<string> const stardescs = getVectorFromString(stardesc, "!");
1198                 int size = int(stardesc.size());
1199                 if (size > 0)
1200                         cs.stardesc = stardescs[0];
1201                 if (size > 1)
1202                         cs.startooltip = stardescs[1];
1203                 if (add) {
1204                         if (authoryear)
1205                                 class_cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(cs);
1206                         if (numerical)
1207                                 class_cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(cs);
1208                         if (defce)
1209                                 class_cite_styles_[ENGINE_TYPE_DEFAULT].push_back(cs);
1210                 } else {
1211                         if (authoryear)
1212                                 cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(cs);
1213                         if (numerical)
1214                                 cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(cs);
1215                         if (defce)
1216                                 cite_styles_[ENGINE_TYPE_DEFAULT].push_back(cs);
1217                 }
1218         }
1219         // If we do AddToCiteEngine, do not apply yet,
1220         // except if we have already a style to add something to
1221         bool apply_ay = !add;
1222         bool apply_num = !add;
1223         bool apply_def = !add;
1224         if (add) {
1225                 if (type & ENGINE_TYPE_AUTHORYEAR)
1226                         apply_ay = !getCiteStyles(ENGINE_TYPE_AUTHORYEAR).empty();
1227                 if (type & ENGINE_TYPE_NUMERICAL)
1228                         apply_num = !getCiteStyles(ENGINE_TYPE_NUMERICAL).empty();
1229                 if (type & ENGINE_TYPE_DEFAULT)
1230                         apply_def = !getCiteStyles(ENGINE_TYPE_DEFAULT).empty();
1231         }
1232
1233         // Add the styles from AddToCiteEngine to the class' styles
1234         // (but only if they are not yet defined)
1235         for (auto const & cis : class_cite_styles_) {
1236                 // Only consider the current CiteEngineType
1237                 if (!(type & cis.first))
1238                         continue;
1239                 for (auto const & ciss : cis.second) {
1240                         bool defined = false;
1241                         // Check if the style "name" is already def'ed
1242                         for (auto const & av : getCiteStyles(cis.first))
1243                                 if (av.name == ciss.name)
1244                                         defined = true;
1245                         if (!defined) {
1246                                 if (cis.first == ENGINE_TYPE_AUTHORYEAR && apply_ay)
1247                                         cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(ciss);
1248                                 else if (cis.first == ENGINE_TYPE_NUMERICAL && apply_num)
1249                                         cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(ciss);
1250                                 else if (cis.first == ENGINE_TYPE_DEFAULT && apply_def)
1251                                         cite_styles_[ENGINE_TYPE_DEFAULT].push_back(ciss);
1252                         }
1253                 }
1254         }
1255         if (type & ENGINE_TYPE_AUTHORYEAR && apply_ay)
1256                 class_cite_styles_[ENGINE_TYPE_AUTHORYEAR].clear();
1257         if (type & ENGINE_TYPE_NUMERICAL && apply_num)
1258                 class_cite_styles_[ENGINE_TYPE_NUMERICAL].clear();
1259         if (type & ENGINE_TYPE_DEFAULT && apply_def)
1260                 class_cite_styles_[ENGINE_TYPE_DEFAULT].clear();
1261         return getout;
1262 }
1263
1264
1265 int TextClass::readCiteEngineType(Lexer & lexrc) const
1266 {
1267         static_assert(ENGINE_TYPE_DEFAULT ==
1268                                   (ENGINE_TYPE_AUTHORYEAR | ENGINE_TYPE_NUMERICAL),
1269                                   "Incorrect default engine type");
1270         if (!lexrc.next()) {
1271                 lexrc.printError("No cite engine type given for token: `$$Token'.");
1272                 return ENGINE_TYPE_DEFAULT;
1273         }
1274         string const type = rtrim(lexrc.getString());
1275         if (compare_ascii_no_case(type, "authoryear") == 0)
1276                 return ENGINE_TYPE_AUTHORYEAR;
1277         else if (compare_ascii_no_case(type, "numerical") == 0)
1278                 return ENGINE_TYPE_NUMERICAL;
1279         else if (compare_ascii_no_case(type, "default") != 0) {
1280                 string const s = "Unknown cite engine type `" + type
1281                         + "' given for token: `$$Token',";
1282                 lexrc.printError(s);
1283         }
1284         return ENGINE_TYPE_DEFAULT;
1285 }
1286
1287
1288 bool TextClass::readCiteFormat(Lexer & lexrc, ReadType rt)
1289 {
1290         int const type = readCiteEngineType(lexrc);
1291         string etype;
1292         string definition;
1293         // Cite engine definitions do not overwrite existing
1294         // definitions from the class or a module
1295         bool const overwrite = rt != CITE_ENGINE;
1296         while (lexrc.isOK()) {
1297                 lexrc.next();
1298                 etype = lexrc.getString();
1299                 if (compare_ascii_no_case(etype, "end") == 0)
1300                         break;
1301                 if (!lexrc.isOK())
1302                         return false;
1303                 lexrc.eatLine();
1304                 definition = lexrc.getString();
1305                 char initchar = etype[0];
1306                 if (initchar == '#')
1307                         continue;
1308                 if (initchar == '!' || initchar == '_' || prefixIs(etype, "B_")) {
1309                         bool defined = false;
1310                         bool aydefined = false;
1311                         bool numdefined = false;
1312                         // Check if the macro is already def'ed
1313                         for (auto const & cm : cite_macros_) {
1314                                 if (!(type & cm.first))
1315                                         continue;
1316                                 if (cm.second.find(etype) != cm.second.end()) {
1317                                         if (type == cm.first)
1318                                                 // defined as default or specific type
1319                                                 defined = true;
1320                                         if (cm.first == ENGINE_TYPE_AUTHORYEAR)
1321                                                 // defined for author-year
1322                                                 aydefined = true;
1323                                         else if (cm.first == ENGINE_TYPE_NUMERICAL)
1324                                                 // defined for numerical
1325                                                 numdefined = true;
1326                                 }
1327                         }
1328                         if (!defined || overwrite) {
1329                                 if (type & ENGINE_TYPE_AUTHORYEAR && (type != ENGINE_TYPE_DEFAULT || !aydefined))
1330                                         cite_macros_[ENGINE_TYPE_AUTHORYEAR][etype] = definition;
1331                                 if (type & ENGINE_TYPE_NUMERICAL && (type != ENGINE_TYPE_DEFAULT || !numdefined))
1332                                         cite_macros_[ENGINE_TYPE_NUMERICAL][etype] = definition;
1333                                 if (type == ENGINE_TYPE_DEFAULT)
1334                                         cite_macros_[ENGINE_TYPE_DEFAULT][etype] = definition;
1335                         }
1336                 } else {
1337                         bool defined = false;
1338                         bool aydefined = false;
1339                         bool numdefined = false;
1340                         // Check if the format is already def'ed
1341                         for (auto const & cm : cite_formats_) {
1342                                 if (!(type & cm.first))
1343                                         continue;
1344                                 if (cm.second.find(etype) != cm.second.end()) {
1345                                         if (type == cm.first)
1346                                                 // defined as default or specific type
1347                                                 defined = true;
1348                                         if (cm.first == ENGINE_TYPE_AUTHORYEAR)
1349                                                 // defined for author-year
1350                                                 aydefined = true;
1351                                         else if (cm.first == ENGINE_TYPE_NUMERICAL)
1352                                                 // defined for numerical
1353                                                 numdefined = true;
1354                                 }
1355                         }
1356                         if (!defined || overwrite){
1357                                 if (type & ENGINE_TYPE_AUTHORYEAR && (type != ENGINE_TYPE_DEFAULT || !aydefined))
1358                                         cite_formats_[ENGINE_TYPE_AUTHORYEAR][etype] = definition;
1359                                 if (type & ENGINE_TYPE_NUMERICAL && (type != ENGINE_TYPE_DEFAULT || !numdefined))
1360                                         cite_formats_[ENGINE_TYPE_NUMERICAL][etype] = definition;
1361                                 if (type == ENGINE_TYPE_DEFAULT)
1362                                         cite_formats_[ENGINE_TYPE_DEFAULT][etype] = definition;
1363                         }
1364                 }
1365         }
1366         return true;
1367 }
1368
1369
1370 bool TextClass::readFloat(Lexer & lexrc)
1371 {
1372         enum {
1373                 FT_TYPE = 1,
1374                 FT_NAME,
1375                 FT_PLACEMENT,
1376                 FT_EXT,
1377                 FT_WITHIN,
1378                 FT_STYLE,
1379                 FT_LISTNAME,
1380                 FT_USESFLOAT,
1381                 FT_PREDEFINED,
1382                 FT_HTMLSTYLE,
1383                 FT_HTMLATTR,
1384                 FT_HTMLTAG,
1385                 FT_LISTCOMMAND,
1386                 FT_REFPREFIX,
1387                 FT_ALLOWED_PLACEMENT,
1388                 FT_ALLOWS_SIDEWAYS,
1389                 FT_ALLOWS_WIDE,
1390                 FT_END
1391         };
1392
1393         LexerKeyword floatTags[] = {
1394                 { "allowedplacement", FT_ALLOWED_PLACEMENT },
1395                 { "allowssideways", FT_ALLOWS_SIDEWAYS },
1396                 { "allowswide", FT_ALLOWS_WIDE },
1397                 { "end", FT_END },
1398                 { "extension", FT_EXT },
1399                 { "guiname", FT_NAME },
1400                 { "htmlattr", FT_HTMLATTR },
1401                 { "htmlstyle", FT_HTMLSTYLE },
1402                 { "htmltag", FT_HTMLTAG },
1403                 { "ispredefined", FT_PREDEFINED },
1404                 { "listcommand", FT_LISTCOMMAND },
1405                 { "listname", FT_LISTNAME },
1406                 { "numberwithin", FT_WITHIN },
1407                 { "placement", FT_PLACEMENT },
1408                 { "refprefix", FT_REFPREFIX },
1409                 { "style", FT_STYLE },
1410                 { "type", FT_TYPE },
1411                 { "usesfloatpkg", FT_USESFLOAT }
1412         };
1413
1414         lexrc.pushTable(floatTags);
1415
1416         string ext;
1417         string htmlattr;
1418         docstring htmlstyle;
1419         string htmltag;
1420         string listname;
1421         string listcommand;
1422         string name;
1423         string placement;
1424         string allowed_placement = "!htbpH";
1425         string refprefix;
1426         string style;
1427         string type;
1428         string within;
1429         bool usesfloat = true;
1430         bool ispredefined = false;
1431         bool allowswide = true;
1432         bool allowssideways = true;
1433
1434         bool getout = false;
1435         while (!getout && lexrc.isOK()) {
1436                 int le = lexrc.lex();
1437                 switch (le) {
1438                 case Lexer::LEX_UNDEF:
1439                         lexrc.printError("Unknown float tag `$$Token'");
1440                         continue;
1441                 default:
1442                         break;
1443                 }
1444                 switch (le) {
1445                 case FT_TYPE:
1446                         lexrc.next();
1447                         type = lexrc.getString();
1448                         if (floatlist_.typeExist(type)) {
1449                                 Floating const & fl = floatlist_.getType(type);
1450                                 placement = fl.placement();
1451                                 ext = fl.ext();
1452                                 within = fl.within();
1453                                 style = fl.style();
1454                                 name = fl.name();
1455                                 listname = fl.listName();
1456                                 usesfloat = fl.usesFloatPkg();
1457                                 ispredefined = fl.isPredefined();
1458                                 listcommand = fl.listCommand();
1459                                 refprefix = fl.refPrefix();
1460                         }
1461                         break;
1462                 case FT_NAME:
1463                         lexrc.next();
1464                         name = lexrc.getString();
1465                         break;
1466                 case FT_PLACEMENT:
1467                         lexrc.next();
1468                         placement = lexrc.getString();
1469                         break;
1470                 case FT_ALLOWED_PLACEMENT:
1471                         lexrc.next();
1472                         allowed_placement = lexrc.getString();
1473                         break;
1474                 case FT_EXT:
1475                         lexrc.next();
1476                         ext = lexrc.getString();
1477                         break;
1478                 case FT_WITHIN:
1479                         lexrc.next();
1480                         within = lexrc.getString();
1481                         if (within == "none")
1482                                 within.erase();
1483                         break;
1484                 case FT_STYLE:
1485                         lexrc.next();
1486                         style = lexrc.getString();
1487                         break;
1488                 case FT_LISTCOMMAND:
1489                         lexrc.next();
1490                         listcommand = lexrc.getString();
1491                         break;
1492                 case FT_REFPREFIX:
1493                         lexrc.next();
1494                         refprefix = lexrc.getString();
1495                         break;
1496                 case FT_LISTNAME:
1497                         lexrc.next();
1498                         listname = lexrc.getString();
1499                         break;
1500                 case FT_USESFLOAT:
1501                         lexrc.next();
1502                         usesfloat = lexrc.getBool();
1503                         break;
1504                 case FT_PREDEFINED:
1505                         lexrc.next();
1506                         ispredefined = lexrc.getBool();
1507                         break;
1508                 case FT_ALLOWS_SIDEWAYS:
1509                         lexrc.next();
1510                         allowssideways = lexrc.getBool();
1511                         break;
1512                 case FT_ALLOWS_WIDE:
1513                         lexrc.next();
1514                         allowswide = lexrc.getBool();
1515                         break;
1516                 case FT_HTMLATTR:
1517                         lexrc.next();
1518                         htmlattr = lexrc.getString();
1519                         break;
1520                 case FT_HTMLSTYLE:
1521                         lexrc.next();
1522                         htmlstyle = lexrc.getLongString(from_ascii("EndHTMLStyle"));
1523                         break;
1524                 case FT_HTMLTAG:
1525                         lexrc.next();
1526                         htmltag = lexrc.getString();
1527                         break;
1528                 case FT_END:
1529                         getout = true;
1530                         break;
1531                 }
1532         }
1533
1534         lexrc.popTable();
1535
1536         // Here we have a full float if getout == true
1537         if (getout) {
1538                 if (!usesfloat && listcommand.empty()) {
1539                         // if this float uses the same auxfile as an existing one,
1540                         // there is no need for it to provide a list command.
1541                         FloatList::const_iterator it = floatlist_.begin();
1542                         FloatList::const_iterator en = floatlist_.end();
1543                         bool found_ext = false;
1544                         for (; it != en; ++it) {
1545                                 if (it->second.ext() == ext) {
1546                                         found_ext = true;
1547                                         break;
1548                                 }
1549                         }
1550                         if (!found_ext)
1551                                 LYXERR0("The layout does not provide a list command " <<
1552                                   "for the float `" << type << "'. LyX will " <<
1553                                   "not be able to produce a float list.");
1554                 }
1555                 Floating fl(type, placement, ext, within, style, name,
1556                             listname, listcommand, refprefix, allowed_placement,
1557                             htmltag, htmlattr, htmlstyle, usesfloat, ispredefined,
1558                             allowswide, allowssideways);
1559                 floatlist_.newFloat(fl);
1560                 // each float has its own counter
1561                 counters_.newCounter(from_ascii(type), from_ascii(within),
1562                                       docstring(), docstring());
1563                 // also define sub-float counters
1564                 docstring const subtype = "sub-" + from_ascii(type);
1565                 counters_.newCounter(subtype, from_ascii(type),
1566                                       "\\alph{" + subtype + "}", docstring());
1567         }
1568         return getout;
1569 }
1570
1571
1572 bool TextClass::readOutlinerName(Lexer & lexrc)
1573 {
1574         std::string type;
1575         docstring name;
1576         if (lexrc.next())
1577                 type = lexrc.getString();
1578         else {
1579                 lexrc.printError("No type given for OutlinerName: `$$Token'.");
1580                 return false;
1581         }
1582         if (lexrc.next())
1583                 name = lexrc.getDocString();
1584         else {
1585                 lexrc.printError("No name given for OutlinerName: `$$Token'.");
1586                 return false;
1587         }
1588         outliner_names_[type] = name;
1589     return true;
1590 }
1591
1592
1593 string const & TextClass::prerequisites(string const & sep) const
1594 {
1595         if (contains(prerequisites_, ',')) {
1596                 vector<string> const pres = getVectorFromString(prerequisites_);
1597                 prerequisites_ = getStringFromVector(pres, sep);
1598         }
1599         return prerequisites_;
1600 }
1601
1602
1603 bool TextClass::hasLayout(docstring const & n) const
1604 {
1605         docstring const name = n.empty() ? defaultLayoutName() : n;
1606
1607         return find_if(layoutlist_.begin(), layoutlist_.end(),
1608                        LayoutNamesEqual(name))
1609                 != layoutlist_.end();
1610 }
1611
1612
1613 bool TextClass::hasInsetLayout(docstring const & n) const
1614 {
1615         if (n.empty())
1616                 return false;
1617         InsetLayouts::const_iterator it = insetlayoutlist_.find(n);
1618         return it != insetlayoutlist_.end();
1619 }
1620
1621
1622 Layout const & TextClass::operator[](docstring const & name) const
1623 {
1624         LATTEST(!name.empty());
1625
1626         const_iterator it =
1627                 find_if(begin(), end(), LayoutNamesEqual(name));
1628
1629         if (it == end()) {
1630                 LYXERR0("We failed to find the layout '" << name
1631                        << "' in the layout list. You MUST investigate!");
1632                 for (const_iterator cit = begin(); cit != end(); ++cit)
1633                         lyxerr  << " " << to_utf8(cit->name()) << endl;
1634
1635                 // We require the name to exist
1636                 static const Layout dummy;
1637                 LASSERT(false, return dummy);
1638         }
1639
1640         return *it;
1641 }
1642
1643
1644 Layout & TextClass::operator[](docstring const & name)
1645 {
1646         LATTEST(!name.empty());
1647         // Safe to continue, given what we do below.
1648
1649         iterator it = find_if(begin(), end(), LayoutNamesEqual(name));
1650
1651         if (it == end()) {
1652                 LYXERR0("We failed to find the layout '" << to_utf8(name)
1653                        << "' in the layout list. You MUST investigate!");
1654                 for (const_iterator cit = begin(); cit != end(); ++cit)
1655                         LYXERR0(" " << to_utf8(cit->name()));
1656
1657                 // we require the name to exist
1658                 LATTEST(false);
1659                 // we are here only in release mode
1660                 layoutlist_.push_back(createBasicLayout(name, true));
1661                 it = find_if(begin(), end(), LayoutNamesEqual(name));
1662         }
1663
1664         return *it;
1665 }
1666
1667
1668 bool TextClass::deleteLayout(docstring const & name)
1669 {
1670         if (name == defaultLayoutName() || name == plainLayoutName())
1671                 return false;
1672
1673         LayoutList::iterator it =
1674                 remove_if(layoutlist_.begin(), layoutlist_.end(),
1675                           LayoutNamesEqual(name));
1676
1677         LayoutList::iterator end = layoutlist_.end();
1678         bool const ret = (it != end);
1679         layoutlist_.erase(it, end);
1680         return ret;
1681 }
1682
1683
1684 bool TextClass::deleteInsetLayout(docstring const & name)
1685 {
1686         return insetlayoutlist_.erase(name);
1687 }
1688
1689
1690 // Load textclass info if not loaded yet
1691 bool TextClass::load(string const & path) const
1692 {
1693         if (loaded_)
1694                 return true;
1695
1696         // Read style-file, provided path is searched before the system ones
1697         // If path is a file, it is loaded directly.
1698         FileName layout_file(path);
1699         if (!path.empty() && !layout_file.isReadableFile())
1700                 layout_file = FileName(addName(path, name_ + ".layout"));
1701         if (layout_file.empty() || !layout_file.exists())
1702                 layout_file = libFileSearch("layouts", name_, "layout");
1703         loaded_ = const_cast<TextClass*>(this)->read(layout_file);
1704
1705         if (!loaded_) {
1706                 lyxerr << "Error reading `"
1707                        << to_utf8(makeDisplayPath(layout_file.absFileName()))
1708                        << "'\n(Check `" << name_
1709                        << "')\nCheck your installation and "
1710                           "try Options/Reconfigure..."
1711                        << endl;
1712         }
1713
1714         return loaded_;
1715 }
1716
1717
1718 bool DocumentClass::addLayoutIfNeeded(docstring const & n) const
1719 {
1720         if (hasLayout(n))
1721                 return false;
1722
1723         layoutlist_.push_back(createBasicLayout(n, true));
1724         return true;
1725 }
1726
1727
1728 string DocumentClass::forcedLayouts() const
1729 {
1730         ostringstream os;
1731         bool first = true;
1732         const_iterator const e = end();
1733         for (const_iterator i = begin(); i != e; ++i) {
1734                 if (i->forcelocal > 0) {
1735                         if (first) {
1736                                 os << "Format " << LAYOUT_FORMAT << '\n';
1737                                 first = false;
1738                         }
1739                         i->write(os);
1740                 }
1741         }
1742         return os.str();
1743 }
1744
1745
1746 InsetLayout const & DocumentClass::insetLayout(docstring const & name) const
1747 {
1748         // FIXME The fix for the InsetLayout part of 4812 would be here:
1749         // Add the InsetLayout to the document class if it is not found.
1750         docstring n = name;
1751         InsetLayouts::const_iterator cen = insetlayoutlist_.end();
1752         while (!n.empty()) {
1753                 InsetLayouts::const_iterator cit = insetlayoutlist_.lower_bound(n);
1754                 if (cit != cen && cit->first == n) {
1755                         if (cit->second.obsoleted_by().empty())
1756                                 return cit->second;
1757                         n = cit->second.obsoleted_by();
1758                         return insetLayout(n);
1759                 }
1760                 // If we have a generic prefix (e.g., "Note:"),
1761                 // try if this one alone is found.
1762                 size_t i = n.find(':');
1763                 if (i == string::npos)
1764                         break;
1765                 n = n.substr(0, i);
1766         }
1767         // Layout "name" not found.
1768         return plainInsetLayout();
1769 }
1770
1771
1772 InsetLayout const & DocumentClass::plainInsetLayout() {
1773         static const InsetLayout plain_insetlayout_;
1774         return plain_insetlayout_;
1775 }
1776
1777
1778 docstring const & TextClass::defaultLayoutName() const
1779 {
1780         return defaultlayout_;
1781 }
1782
1783
1784 Layout const & TextClass::defaultLayout() const
1785 {
1786         return operator[](defaultLayoutName());
1787 }
1788
1789
1790 bool TextClass::isDefaultLayout(Layout const & layout) const
1791 {
1792         return layout.name() == defaultLayoutName();
1793 }
1794
1795
1796 bool TextClass::isPlainLayout(Layout const & layout) const
1797 {
1798         return layout.name() == plainLayoutName();
1799 }
1800
1801
1802 Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const
1803 {
1804         static Layout * defaultLayout = NULL;
1805
1806         if (defaultLayout) {
1807                 defaultLayout->setUnknown(unknown);
1808                 defaultLayout->setName(name);
1809                 return *defaultLayout;
1810         }
1811
1812         static char const * s = "Margin Static\n"
1813                         "LatexType Paragraph\n"
1814                         "LatexName dummy\n"
1815                         "Align Block\n"
1816                         "AlignPossible Left, Right, Center\n"
1817                         "LabelType No_Label\n"
1818                         "End";
1819         istringstream ss(s);
1820         Lexer lex(textClassTags);
1821         lex.setStream(ss);
1822         defaultLayout = new Layout;
1823         defaultLayout->setUnknown(unknown);
1824         defaultLayout->setName(name);
1825         if (!readStyle(lex, *defaultLayout)) {
1826                 // The only way this happens is because the hardcoded layout above
1827                 // is wrong.
1828                 LATTEST(false);
1829         };
1830         return *defaultLayout;
1831 }
1832
1833
1834 DocumentClassPtr getDocumentClass(
1835                 LayoutFile const & baseClass, LayoutModuleList const & modlist,
1836                 string const & cengine, bool const clone)
1837 {
1838         DocumentClassPtr doc_class =
1839             DocumentClassPtr(new DocumentClass(baseClass));
1840         LayoutModuleList::const_iterator it = modlist.begin();
1841         LayoutModuleList::const_iterator en = modlist.end();
1842         for (; it != en; ++it) {
1843                 string const modName = *it;
1844                 LyXModule * lm = theModuleList[modName];
1845                 if (!lm) {
1846                         docstring const msg =
1847                                                 bformat(_("The module %1$s has been requested by\n"
1848                                                 "this document but has not been found in the list of\n"
1849                                                 "available modules. If you recently installed it, you\n"
1850                                                 "probably need to reconfigure LyX.\n"), from_utf8(modName));
1851                         if (!clone)
1852                                 frontend::Alert::warning(_("Module not available"), msg);
1853                         continue;
1854                 }
1855                 if (!lm->isAvailable() && !clone) {
1856                         docstring const prereqs = from_utf8(getStringFromVector(lm->prerequisites(), "\n\t"));
1857                         docstring const msg =
1858                                 bformat(_("The module %1$s requires a package that is not\n"
1859                                         "available in your LaTeX installation, or a converter that\n"
1860                                         "you have not installed. LaTeX output may not be possible.\n"
1861                                         "Missing prerequisites:\n"
1862                                                 "\t%2$s\n"
1863                                         "See section 3.1.2.3 (Modules) of the User's Guide for more information."),
1864                                 from_utf8(modName), prereqs);
1865                         frontend::Alert::warning(_("Package not available"), msg, true);
1866                 }
1867                 FileName layout_file = libFileSearch("layouts", lm->getFilename());
1868                 if (!doc_class->read(layout_file, TextClass::MODULE)) {
1869                         docstring const msg =
1870                                                 bformat(_("Error reading module %1$s\n"), from_utf8(modName));
1871                         frontend::Alert::warning(_("Read Error"), msg);
1872                 }
1873         }
1874
1875         if (cengine.empty())
1876                 return doc_class;
1877
1878         LyXCiteEngine * ce = theCiteEnginesList[cengine];
1879         if (!ce) {
1880                 docstring const msg =
1881                                         bformat(_("The cite engine %1$s has been requested by\n"
1882                                         "this document but has not been found in the list of\n"
1883                                         "available engines. If you recently installed it, you\n"
1884                                         "probably need to reconfigure LyX.\n"), from_utf8(cengine));
1885                 if (!clone)
1886                         frontend::Alert::warning(_("Cite Engine not available"), msg);
1887         } else if (!ce->isAvailable() && !clone) {
1888                 docstring const prereqs = from_utf8(getStringFromVector(ce->prerequisites(), "\n\t"));
1889                 docstring const msg =
1890                         bformat(_("The cite engine %1$s requires a package that is not\n"
1891                                 "available in your LaTeX installation, or a converter that\n"
1892                                 "you have not installed. LaTeX output may not be possible.\n"
1893                                 "Missing prerequisites:\n"
1894                                         "\t%2$s\n"
1895                                 "See section 3.1.2.3 (Modules) of the User's Guide for more information."),
1896                         from_utf8(cengine), prereqs);
1897                 frontend::Alert::warning(_("Package not available"), msg, true);
1898         } else {
1899                 FileName layout_file = libFileSearch("citeengines", ce->getFilename());
1900                 if (!doc_class->read(layout_file, TextClass::CITE_ENGINE)) {
1901                         docstring const msg =
1902                                                 bformat(_("Error reading cite engine %1$s\n"), from_utf8(cengine));
1903                         frontend::Alert::warning(_("Read Error"), msg);
1904                 }
1905         }
1906
1907         return doc_class;
1908 }
1909
1910
1911 /////////////////////////////////////////////////////////////////////////
1912 //
1913 // DocumentClass
1914 //
1915 /////////////////////////////////////////////////////////////////////////
1916
1917 DocumentClass::DocumentClass(LayoutFile const & tc)
1918         : TextClass(tc)
1919 {}
1920
1921
1922 bool DocumentClass::hasLaTeXLayout(std::string const & lay) const
1923 {
1924         LayoutList::const_iterator it  = layoutlist_.begin();
1925         LayoutList::const_iterator end = layoutlist_.end();
1926         for (; it != end; ++it)
1927                 if (it->latexname() == lay)
1928                         return true;
1929         return false;
1930 }
1931
1932
1933 bool DocumentClass::provides(string const & p) const
1934 {
1935         return provides_.find(p) != provides_.end();
1936 }
1937
1938
1939 bool DocumentClass::hasTocLevels() const
1940 {
1941         return min_toclevel_ != Layout::NOT_IN_TOC;
1942 }
1943
1944
1945 Layout const & DocumentClass::getTOCLayout() const
1946 {
1947         // we're going to look for the layout with the minimum toclevel
1948         TextClass::LayoutList::const_iterator lit = begin();
1949         TextClass::LayoutList::const_iterator const len = end();
1950         int minlevel = 1000;
1951         Layout const * lay = NULL;
1952         for (; lit != len; ++lit) {
1953                 int const level = lit->toclevel;
1954                 // we don't want Part or unnumbered sections
1955                 if (level == Layout::NOT_IN_TOC || level < 0
1956                     || level >= minlevel || lit->counter.empty())
1957                         continue;
1958                 lay = &*lit;
1959                 minlevel = level;
1960         }
1961         if (lay)
1962                 return *lay;
1963         // hmm. that is very odd, so we'll do our best.
1964         return operator[](defaultLayoutName());
1965 }
1966
1967
1968 Layout const & DocumentClass::htmlTOCLayout() const
1969 {
1970         if (html_toc_section_.empty())
1971                 html_toc_section_ = getTOCLayout().name();
1972         return operator[](html_toc_section_);
1973 }
1974
1975
1976 string const DocumentClass::getCiteFormat(CiteEngineType const & type,
1977         string const & entry, bool const punct, string const & fallback) const
1978 {
1979         string default_format = "{%fullnames:author%[[%fullnames:author%, ]][[{%fullnames:editor%[[%fullnames:editor%, ed., ]]}]]}"
1980                                 "\"%title%\"{%journal%[[, {!<i>!}%journal%{!</i>!}]][[{%publisher%[[, %publisher%]]"
1981                                 "[[{%institution%[[, %institution%]]}]]}]]}{%year%[[ (%year%)]]}{%pages%[[, %pages%]]}";
1982         if (punct)
1983                 default_format += ".";
1984
1985         map<CiteEngineType, map<string, string> >::const_iterator itype = cite_formats_.find(type);
1986         if (itype == cite_formats_.end())
1987                 return default_format;
1988         map<string, string>::const_iterator it = itype->second.find(entry);
1989         if (it == itype->second.end() && !fallback.empty())
1990                 it = itype->second.find(fallback);
1991         if (it == itype->second.end())
1992                 return default_format;
1993         if (punct)
1994                 return it->second + ".";
1995         return it->second;
1996 }
1997
1998
1999 string const & DocumentClass::getCiteMacro(CiteEngineType const & type,
2000         string const & macro) const
2001 {
2002         static string empty;
2003         map<CiteEngineType, map<string, string> >::const_iterator itype = cite_macros_.find(type);
2004         if (itype == cite_macros_.end())
2005                 return empty;
2006         map<string, string>::const_iterator it = itype->second.find(macro);
2007         if (it == itype->second.end())
2008                 return empty;
2009         return it->second;
2010 }
2011
2012
2013 vector<string> const DocumentClass::citeCommands(
2014         CiteEngineType const & type) const
2015 {
2016         vector<CitationStyle> const styles = citeStyles(type);
2017         vector<CitationStyle>::const_iterator it = styles.begin();
2018         vector<CitationStyle>::const_iterator end = styles.end();
2019         vector<string> cmds;
2020         for (; it != end; ++it) {
2021                 CitationStyle const cite = *it;
2022                 cmds.push_back(cite.name);
2023         }
2024         return cmds;
2025 }
2026
2027
2028 vector<CitationStyle> const & DocumentClass::citeStyles(
2029         CiteEngineType const & type) const
2030 {
2031         static vector<CitationStyle> empty;
2032         map<CiteEngineType, vector<CitationStyle> >::const_iterator it = cite_styles_.find(type);
2033         if (it == cite_styles_.end())
2034                 return empty;
2035         return it->second;
2036 }
2037
2038
2039 /////////////////////////////////////////////////////////////////////////
2040 //
2041 // PageSides
2042 //
2043 /////////////////////////////////////////////////////////////////////////
2044
2045 ostream & operator<<(ostream & os, PageSides p)
2046 {
2047         switch (p) {
2048         case OneSide:
2049                 os << '1';
2050                 break;
2051         case TwoSides:
2052                 os << '2';
2053                 break;
2054         }
2055         return os;
2056 }
2057
2058
2059 } // namespace lyx