src/tex2lyx/Preamble.cpp

   1 /**
   2  * \file Preamble.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author André Pönitz
   7  * \author Uwe Stöhr
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 // {[(
  13
  14 #include <config.h>
  15
  16 #include "Preamble.h"
  17 #include "tex2lyx.h"
  18
  19 #include "Encoding.h"
  20 #include "LayoutFile.h"
  21 #include "Layout.h"
  22 #include "Lexer.h"
  23 #include "TextClass.h"
  24
  25 #include "support/convert.h"
  26 #include "support/FileName.h"
  27 #include "support/filetools.h"
  28 #include "support/lstrings.h"
  29
  30 #include "support/regex.h"
  31
  32 #include <algorithm>
  33 #include <iostream>
  34
  35 using namespace std;
  36 using namespace lyx::support;
  37
  38
  39 namespace lyx {
  40
  41 // special columntypes
  42 extern map<char, int> special_columns;
  43
  44 Preamble preamble;
  45
  46 namespace {
  47
  48 // CJK languages are handled in text.cpp, polyglossia languages are listed
  49 // further down.
  50 /**
  51  * known babel language names (including synonyms)
  52  * not in standard babel: arabic, arabtex, armenian, belarusian, serbian-latin, thai
  53  * please keep this in sync with known_coded_languages line by line!
  54  */
  55 const char * const known_languages[] = {"acadian", "afrikaans", "albanian",
  56 "american", "arabic", "arabtex", "australian", "austrian", "bahasa", "bahasai",
  57 "bahasam", "basque", "belarusian", "brazil", "brazilian", "breton", "british",
  58 "bulgarian", "canadian", "canadien", "catalan", "croatian", "czech", "danish",
  59 "dutch", "english", "esperanto", "estonian", "farsi", "finnish", "francais",
  60 "french", "frenchb", "frenchle", "frenchpro", "galician", "german", "germanb",
  61 "greek", "hebrew", "hungarian", "icelandic", "indon", "indonesian", "interlingua",
  62 "irish", "italian", "japanese", "kazakh", "kurmanji", "latin", "latvian", "lithuanian",
  63 "lowersorbian", "lsorbian", "magyar", "malay", "meyalu", "mongolian", "naustrian",
  64 "newzealand", "ngerman", "ngermanb", "norsk", "nynorsk", "polutonikogreek", "polish",
  65 "portuges", "portuguese", "romanian", "russian", "russianb", "samin",
  66 "scottish", "serbian", "serbian-latin", "slovak", "slovene", "spanish",
  67 "swedish", "thai", "turkish", "turkmen", "ukraineb", "ukrainian",
  68 "uppersorbian", "UKenglish", "USenglish", "usorbian", "vietnam", "welsh",
  69 0};
  70
  71 /**
  72  * the same as known_languages with .lyx names
  73  * please keep this in sync with known_languages line by line!
  74  */
  75 const char * const known_coded_languages[] = {"french", "afrikaans", "albanian",
  76 "american", "arabic_arabi", "arabic_arabtex", "australian", "austrian", "bahasa", "bahasa",
  77 "bahasam", "basque", "belarusian", "brazilian", "brazilian", "breton", "british",
  78 "bulgarian", "canadian", "canadien", "catalan", "croatian", "czech", "danish",
  79 "dutch", "english", "esperanto", "estonian", "farsi", "finnish", "french",
  80 "french", "french", "french", "french", "galician", "german", "german",
  81 "greek", "hebrew", "magyar", "icelandic", "bahasa", "bahasa", "interlingua",
  82 "irish", "italian", "japanese", "kazakh", "kurmanji", "latin", "latvian", "lithuanian",
  83 "lowersorbian", "lowersorbian", "magyar", "bahasam", "bahasam", "mongolian", "naustrian",
  84 "newzealand", "ngerman", "ngerman", "norsk", "nynorsk", "polutonikogreek", "polish",
  85 "portuguese", "portuguese", "romanian", "russian", "russian", "samin",
  86 "scottish", "serbian", "serbian-latin", "slovak", "slovene", "spanish",
  87 "swedish", "thai", "turkish", "turkmen", "ukrainian", "ukrainian",
  88 "uppersorbian", "uppersorbian", "english", "english", "vietnamese", "welsh",
  89 0};
  90
  91 /// languages with danish quotes (.lyx names)
  92 const char * const known_danish_quotes_languages[] = {"danish", 0};
  93
  94 /// languages with english quotes (.lyx names)
  95 const char * const known_english_quotes_languages[] = {"american", "australian",
  96 "bahasa", "bahasam", "brazilian", "canadian", "chinese-simplified", "english",
  97 "esperanto", "hebrew", "irish", "korean", "newzealand", "portuguese", "scottish",
  98 "thai", 0};
  99
 100 /// languages with french quotes (.lyx names)
 101 const char * const known_french_quotes_languages[] = {"albanian",
 102 "arabic_arabi", "arabic_arabtex", "basque", "canadien", "catalan", "french",
 103 "galician", "greek", "italian", "norsk", "nynorsk", "polutonikogreek",
 104 "russian", "spanish", "spanish-mexico", "turkish", "turkmen", "ukrainian",
 105 "vietnamese", 0};
 106
 107 /// languages with german quotes (.lyx names)
 108 const char * const known_german_quotes_languages[] = {"austrian", "bulgarian",
 109 "czech", "german", "icelandic", "lithuanian", "lowersorbian", "naustrian",
 110 "ngerman", "serbian", "serbian-latin", "slovak", "slovene", "uppersorbian", 0};
 111
 112 /// languages with polish quotes (.lyx names)
 113 const char * const known_polish_quotes_languages[] = {"afrikaans", "croatian",
 114 "dutch", "estonian", "magyar", "polish", "romanian", 0};
 115
 116 /// languages with swedish quotes (.lyx names)
 117 const char * const known_swedish_quotes_languages[] = {"finnish",
 118 "swedish", 0};
 119
 120 /// known language packages from the times before babel
 121 const char * const known_old_language_packages[] = {"french", "frenchle",
 122 "frenchpro", "german", "ngerman", "pmfrench", 0};
 123
 124 char const * const known_fontsizes[] = { "10pt", "11pt", "12pt", 0 };
 125
 126 const char * const known_roman_fonts[] = { "ae", "beraserif", "bookman",
 127 "ccfonts", "chancery", "charter", "cmr", "fourier", "garamondx", "libertine-type1",
 128 "lmodern", "mathdesign", "mathpazo", "mathptmx", "newcent", "tgbonum",
 129 "tgchorus", "tgpagella", "tgschola", "tgtermes", "utopia", 0};
 130
 131 const char * const known_sans_fonts[] = { "avant", "berasans", "biolinum-type1",
 132 "cmbr", "cmss", "helvet", "kurier", "kurierl", "lmss", "tgadventor", "tgheros", 0};
 133
 134 const char * const known_kurier_fonts[] = { "kurier", "kurierl", "kurier-condensed",
 135 "kurier-light-condensed", 0};
 136
 137 const char * const known_typewriter_fonts[] = { "beramono", "cmtl", "cmtt",
 138 "courier", "lmtt", "luximono", "fourier", "lmodern", "mathpazo", "mathptmx",
 139 "newcent", "tgcursor", "txtt", 0};
 140
 141 const char * const known_math_fonts[] = { "eulervm", "newtxmath", 0};
 142
 143 const char * const known_paper_sizes[] = { "a0paper", "b0paper", "c0paper",
 144 "a1paper", "b1paper", "c1paper", "a2paper", "b2paper", "c2paper", "a3paper",
 145 "b3paper", "c3paper", "a4paper", "b4paper", "c4paper", "a5paper", "b5paper",
 146 "c5paper", "a6paper", "b6paper", "c6paper", "executivepaper", "legalpaper",
 147 "letterpaper", "b0j", "b1j", "b2j", "b3j", "b4j", "b5j", "b6j", 0};
 148
 149 const char * const known_class_paper_sizes[] = { "a4paper", "a5paper",
 150 "executivepaper", "legalpaper", "letterpaper", 0};
 151
 152 const char * const known_paper_margins[] = { "lmargin", "tmargin", "rmargin",
 153 "bmargin", "headheight", "headsep", "footskip", "columnsep", 0};
 154
 155 const char * const known_coded_paper_margins[] = { "leftmargin", "topmargin",
 156 "rightmargin", "bottommargin", "headheight", "headsep", "footskip",
 157 "columnsep", 0};
 158
 159 /// commands that can start an \if...\else...\endif sequence
 160 const char * const known_if_commands[] = {"if", "ifarydshln", "ifbraket",
 161 "ifcancel", "ifcolortbl", "ifeurosym", "ifmarginnote", "ifmmode", "ifpdf",
 162 "ifsidecap", "ifupgreek", 0};
 163
 164 const char * const known_basic_colors[] = {"blue", "black", "cyan", "green",
 165 "magenta", "red", "white", "yellow", 0};
 166
 167 const char * const known_basic_color_codes[] = {"#0000ff", "#000000", "#00ffff", "#00ff00",
 168 "#ff00ff", "#ff0000", "#ffffff", "#ffff00", 0};
 169
 170 /// conditional commands with three arguments like \@ifundefined{}{}{}
 171 const char * const known_if_3arg_commands[] = {"@ifundefined", "IfFileExists",
 172 0};
 173
 174 /// packages that work only in xetex
 175 /// polyglossia is handled separately
 176 const char * const known_xetex_packages[] = {"arabxetex", "fixlatvian",
 177 "fontbook", "fontwrap", "mathspec", "philokalia", "unisugar",
 178 "xeCJK", "xecolor", "xecyr", "xeindex", "xepersian", "xunicode", 0};
 179
 180 /// packages that are automatically skipped if loaded by LyX
 181 const char * const known_lyx_packages[] = {"amsbsy", "amsmath", "amssymb",
 182 "amstext", "amsthm", "array", "babel", "booktabs", "calc", "CJK", "color", "float",
 183 "fontspec", "graphicx", "hhline", "ifthen", "longtable", "makeidx", "multirow",
 184 "nomencl", "pdfpages", "rotating", "rotfloat", "splitidx", "setspace",
 185 "subscript", "textcomp", "ulem", "url", "varioref", "verbatim", "wrapfig",
 186 "xunicode", 0};
 187
 188 // codes used to remove packages that are loaded automatically by LyX.
 189 // Syntax: package_beg_sep<name>package_mid_sep<package loading code>package_end_sep
 190 const char package_beg_sep = '\001';
 191 const char package_mid_sep = '\002';
 192 const char package_end_sep = '\003';
 193
 194
 195 // returns true if at least one of the options in what has been found
 196 bool handle_opt(vector<string> & opts, char const * const * what, string & target)
 197 {
 198         if (opts.empty())
 199                 return false;
 200
 201         bool found = false;
 202         // the last language option is the document language (for babel and LyX)
 203         // the last size option is the document font size
 204         vector<string>::iterator it;
 205         vector<string>::iterator position = opts.begin();
 206         for (; *what; ++what) {
 207                 it = find(opts.begin(), opts.end(), *what);
 208                 if (it != opts.end()) {
 209                         if (it >= position) {
 210                                 found = true;
 211                                 target = *what;
 212                                 position = it;
 213                         }
 214                 }
 215         }
 216         return found;
 217 }
 218
 219
 220 void delete_opt(vector<string> & opts, char const * const * what)
 221 {
 222         if (opts.empty())
 223                 return;
 224
 225         // remove found options from the list
 226         // do this after handle_opt to avoid potential memory leaks
 227         vector<string>::iterator it;
 228         for (; *what; ++what) {
 229                 it = find(opts.begin(), opts.end(), *what);
 230                 if (it != opts.end())
 231                         opts.erase(it);
 232         }
 233 }
 234
 235
 236 /*!
 237  * Split a package options string (keyval format) into a vector.
 238  * Example input:
 239  *   authorformat=smallcaps,
 240  *   commabeforerest,
 241  *   titleformat=colonsep,
 242  *   bibformat={tabular,ibidem,numbered}
 243  */
 244 vector<string> split_options(string const & input)
 245 {
 246         vector<string> options;
 247         string option;
 248         Parser p(input);
 249         while (p.good()) {
 250                 Token const & t = p.get_token();
 251                 if (t.asInput() == ",") {
 252                         options.push_back(trimSpaceAndEol(option));
 253                         option.erase();
 254                 } else if (t.asInput() == "=") {
 255                         option += '=';
 256                         p.skip_spaces(true);
 257                         if (p.next_token().asInput() == "{")
 258                                 option += '{' + p.getArg('{', '}') + '}';
 259                 } else if (t.cat() != catSpace)
 260                         option += t.asInput();
 261         }
 262
 263         if (!option.empty())
 264                 options.push_back(trimSpaceAndEol(option));
 265
 266         return options;
 267 }
 268
 269
 270 /*!
 271  * Retrieve a keyval option "name={value with=sign}" named \p name from
 272  * \p options and return the value.
 273  * The found option is also removed from \p options.
 274  */
 275 string process_keyval_opt(vector<string> & options, string name)
 276 {
 277         for (size_t i = 0; i < options.size(); ++i) {
 278                 vector<string> option;
 279                 split(options[i], option, '=');
 280                 if (option.size() < 2)
 281                         continue;
 282                 if (option[0] == name) {
 283                         options.erase(options.begin() + i);
 284                         option.erase(option.begin());
 285                         return join(option, "=");
 286                 }
 287         }
 288         return "";
 289 }
 290
 291 } // anonymous namespace
 292
 293
 294 /**
 295  * known polyglossia language names (including variants)
 296  */
 297 const char * const Preamble::polyglossia_languages[] = {
 298 "albanian", "croatian", "hebrew", "norsk", "swedish", "amharic", "czech", "hindi",
 299 "nynorsk", "syriac", "arabic", "danish", "icelandic", "occitan", "tamil",
 300 "armenian", "divehi", "interlingua", "polish", "telugu", "asturian", "dutch",
 301 "irish", "portuges", "thai", "bahasai", "english", "italian", "romanian", "turkish",
 302 "bahasam", "esperanto", "lao", "russian", "turkmen", "basque", "estonian", "latin",
 303 "samin", "ukrainian", "bengali", "farsi", "latvian", "sanskrit", "urdu", "brazil",
 304 "brazilian", "finnish", "lithuanian", "scottish", "usorbian", "breton", "french",
 305 "lsorbian", "serbian", "vietnamese", "bulgarian", "galician", "magyar", "slovak",
 306 "welsh", "catalan", "german", "malayalam", "slovenian", "coptic", "greek",
 307 "marathi", "spanish",
 308 "american", "ancient", "australian", "british", "monotonic", "newzealand",
 309 "polytonic", 0};
 310
 311 /**
 312  * the same as polyglossia_languages with .lyx names
 313  * please keep this in sync with polyglossia_languages line by line!
 314  */
 315 const char * const Preamble::coded_polyglossia_languages[] = {
 316 "albanian", "croatian", "hebrew", "norsk", "swedish", "amharic", "czech", "hindi",
 317 "nynorsk", "syriac", "arabic_arabi", "danish", "icelandic", "occitan", "tamil",
 318 "armenian", "divehi", "interlingua", "polish", "telugu", "asturian", "dutch",
 319 "irish", "portuges", "thai", "bahasa", "english", "italian", "romanian", "turkish",
 320 "bahasam", "esperanto", "lao", "russian", "turkmen", "basque", "estonian", "latin",
 321 "samin", "ukrainian", "bengali", "farsi", "latvian", "sanskrit", "urdu", "brazilian",
 322 "brazilian", "finnish", "lithuanian", "scottish", "uppersorbian", "breton", "french",
 323 "lowersorbian", "serbian", "vietnamese", "bulgarian", "galician", "magyar", "slovak",
 324 "welsh", "catalan", "ngerman", "malayalam", "slovene", "coptic", "greek",
 325 "marathi", "spanish",
 326 "american", "ancientgreek", "australian", "british", "greek", "newzealand",
 327 "polutonikogreek", 0};
 328
 329
 330 bool Preamble::indentParagraphs() const
 331 {
 332         return h_paragraph_separation == "indent";
 333 }
 334
 335
 336 bool Preamble::isPackageUsed(string const & package) const
 337 {
 338         return used_packages.find(package) != used_packages.end();
 339 }
 340
 341
 342 vector<string> Preamble::getPackageOptions(string const & package) const
 343 {
 344         map<string, vector<string> >::const_iterator it = used_packages.find(package);
 345         if (it != used_packages.end())
 346                 return it->second;
 347         return vector<string>();
 348 }
 349
 350
 351 void Preamble::registerAutomaticallyLoadedPackage(std::string const & package)
 352 {
 353         auto_packages.insert(package);
 354 }
 355
 356
 357 void Preamble::addModule(string const & module)
 358 {
 359         used_modules.push_back(module);
 360 }
 361
 362
 363 void Preamble::suppressDate(bool suppress)
 364 {
 365         if (suppress)
 366                 h_suppress_date = "true";
 367         else
 368                 h_suppress_date = "false";
 369 }
 370
 371
 372 void Preamble::registerAuthor(std::string const & name)
 373 {
 374         Author author(from_utf8(name), empty_docstring());
 375         author.setUsed(true);
 376         authors_.record(author);
 377         h_tracking_changes = "true";
 378         h_output_changes = "true";
 379 }
 380
 381
 382 Author const & Preamble::getAuthor(std::string const & name) const
 383 {
 384         Author author(from_utf8(name), empty_docstring());
 385         for (AuthorList::Authors::const_iterator it = authors_.begin();
 386              it != authors_.end(); ++it)
 387                 if (*it == author)
 388                         return *it;
 389         static Author const dummy;
 390         return dummy;
 391 }
 392
 393
 394 void Preamble::add_package(string const & name, vector<string> & options)
 395 {
 396         // every package inherits the global options
 397         if (used_packages.find(name) == used_packages.end())
 398                 used_packages[name] = split_options(h_options);
 399
 400         vector<string> & v = used_packages[name];
 401         v.insert(v.end(), options.begin(), options.end());
 402         if (name == "jurabib") {
 403                 // Don't output the order argument (see the cite command
 404                 // handling code in text.cpp).
 405                 vector<string>::iterator end =
 406                         remove(options.begin(), options.end(), "natbiborder");
 407                 end = remove(options.begin(), end, "jurabiborder");
 408                 options.erase(end, options.end());
 409         }
 410 }
 411
 412
 413 namespace {
 414
 415 // Given is a string like "scaled=0.9" or "Scale=0.9", return 0.9 * 100
 416 bool scale_as_percentage(string const & scale, string & percentage)
 417 {
 418         string::size_type pos = scale.find('=');
 419         if (pos != string::npos) {
 420                 string value = scale.substr(pos + 1);
 421                 if (isStrDbl(value)) {
 422                         percentage = convert<string>(100 * convert<double>(value));
 423                         return true;
 424                 }
 425         }
 426         return false;
 427 }
 428
 429
 430 string remove_braces(string const & value)
 431 {
 432         if (value.empty())
 433                 return value;
 434         if (value[0] == '{' && value[value.length()-1] == '}')
 435                 return value.substr(1, value.length()-2);
 436         return value;
 437 }
 438
 439 } // anonymous namespace
 440
 441
 442 Preamble::Preamble() : one_language(true), title_layout_found(false),
 443         h_font_cjk_set(false)
 444 {
 445         //h_backgroundcolor;
 446         //h_boxbgcolor;
 447         h_biblio_style            = "plain";
 448         h_bibtex_command          = "default";
 449         h_cite_engine             = "basic";
 450         h_cite_engine_type        = "numerical";
 451         h_color                   = "#008000";
 452         h_defskip                 = "medskip";
 453         //h_float_placement;
 454         //h_fontcolor;
 455         h_fontencoding            = "default";
 456         h_font_roman              = "default";
 457         h_font_sans               = "default";
 458         h_font_typewriter         = "default";
 459         h_font_math               = "auto";
 460         h_font_default_family     = "default";
 461         h_use_non_tex_fonts       = "false";
 462         h_font_sc                 = "false";
 463         h_font_osf                = "false";
 464         h_font_sf_scale           = "100";
 465         h_font_tt_scale           = "100";
 466         //h_font_cjk
 467         h_graphics                = "default";
 468         h_default_output_format   = "default";
 469         h_html_be_strict          = "false";
 470         h_html_css_as_file        = "0";
 471         h_html_math_output        = "0";
 472         h_index                   = "Index";
 473         h_index_command           = "default";
 474         h_inputencoding           = "auto";
 475         h_justification           = "true";
 476         h_language                = "english";
 477         h_language_package        = "none";
 478         //h_listings_params;
 479         h_maintain_unincluded_children = "false";
 480         //h_margins;
 481         //h_notefontcolor;
 482         //h_options;
 483         h_output_changes          = "false";
 484         h_output_sync             = "0";
 485         //h_output_sync_macro
 486         h_papercolumns            = "1";
 487         h_paperfontsize           = "default";
 488         h_paperorientation        = "portrait";
 489         h_paperpagestyle          = "default";
 490         //h_papersides;
 491         h_papersize               = "default";
 492         h_paragraph_indentation   = "default";
 493         h_paragraph_separation    = "indent";
 494         //h_pdf_title;
 495         //h_pdf_author;
 496         //h_pdf_subject;
 497         //h_pdf_keywords;
 498         h_pdf_bookmarks           = "1";
 499         h_pdf_bookmarksnumbered   = "0";
 500         h_pdf_bookmarksopen       = "0";
 501         h_pdf_bookmarksopenlevel  = "1";
 502         h_pdf_breaklinks          = "0";
 503         h_pdf_pdfborder           = "0";
 504         h_pdf_colorlinks          = "0";
 505         h_pdf_backref             = "section";
 506         h_pdf_pdfusetitle         = "1";
 507         //h_pdf_pagemode;
 508         //h_pdf_quoted_options;
 509         h_quotes_language         = "english";
 510         h_secnumdepth             = "3";
 511         h_shortcut                = "idx";
 512         h_spacing                 = "single";
 513         h_suppress_date           = "false";
 514         h_textclass               = "article";
 515         h_tocdepth                = "3";
 516         h_tracking_changes        = "false";
 517         h_use_bibtopic            = "false";
 518         h_use_indices             = "false";
 519         h_use_geometry            = "false";
 520         h_use_default_options     = "false";
 521         h_use_hyperref            = "false";
 522         h_use_refstyle            = "0";
 523         h_use_packages["amsmath"]    = "1";
 524         h_use_packages["amssymb"]    = "0";
 525         h_use_packages["esint"]      = "1";
 526         h_use_packages["mhchem"]     = "0";
 527         h_use_packages["mathdots"]   = "0";
 528         h_use_packages["mathtools"]  = "0";
 529         h_use_packages["stackrel"]   = "0";
 530         h_use_packages["stmaryrd"]   = "0";
 531         h_use_packages["undertilde"] = "0";
 532 }
 533
 534
 535 void Preamble::handle_hyperref(vector<string> & options)
 536 {
 537         // FIXME swallow inputencoding changes that might surround the
 538         //       hyperref setup if it was written by LyX
 539         h_use_hyperref = "true";
 540         // swallow "unicode=true", since LyX does always write that
 541         vector<string>::iterator it =
 542                 find(options.begin(), options.end(), "unicode=true");
 543         if (it != options.end())
 544                 options.erase(it);
 545         it = find(options.begin(), options.end(), "pdfusetitle");
 546         if (it != options.end()) {
 547                 h_pdf_pdfusetitle = "1";
 548                 options.erase(it);
 549         }
 550         string bookmarks = process_keyval_opt(options, "bookmarks");
 551         if (bookmarks == "true")
 552                 h_pdf_bookmarks = "1";
 553         else if (bookmarks == "false")
 554                 h_pdf_bookmarks = "0";
 555         if (h_pdf_bookmarks == "1") {
 556                 string bookmarksnumbered =
 557                         process_keyval_opt(options, "bookmarksnumbered");
 558                 if (bookmarksnumbered == "true")
 559                         h_pdf_bookmarksnumbered = "1";
 560                 else if (bookmarksnumbered == "false")
 561                         h_pdf_bookmarksnumbered = "0";
 562                 string bookmarksopen =
 563                         process_keyval_opt(options, "bookmarksopen");
 564                 if (bookmarksopen == "true")
 565                         h_pdf_bookmarksopen = "1";
 566                 else if (bookmarksopen == "false")
 567                         h_pdf_bookmarksopen = "0";
 568                 if (h_pdf_bookmarksopen == "1") {
 569                         string bookmarksopenlevel =
 570                                 process_keyval_opt(options, "bookmarksopenlevel");
 571                         if (!bookmarksopenlevel.empty())
 572                                 h_pdf_bookmarksopenlevel = bookmarksopenlevel;
 573                 }
 574         }
 575         string breaklinks = process_keyval_opt(options, "breaklinks");
 576         if (breaklinks == "true")
 577                 h_pdf_breaklinks = "1";
 578         else if (breaklinks == "false")
 579                 h_pdf_breaklinks = "0";
 580         string pdfborder = process_keyval_opt(options, "pdfborder");
 581         if (pdfborder == "{0 0 0}")
 582                 h_pdf_pdfborder = "1";
 583         else if (pdfborder == "{0 0 1}")
 584                 h_pdf_pdfborder = "0";
 585         string backref = process_keyval_opt(options, "backref");
 586         if (!backref.empty())
 587                 h_pdf_backref = backref;
 588         string colorlinks = process_keyval_opt(options, "colorlinks");
 589         if (colorlinks == "true")
 590                 h_pdf_colorlinks = "1";
 591         else if (colorlinks == "false")
 592                 h_pdf_colorlinks = "0";
 593         string pdfpagemode = process_keyval_opt(options, "pdfpagemode");
 594         if (!pdfpagemode.empty())
 595                 h_pdf_pagemode = pdfpagemode;
 596         string pdftitle = process_keyval_opt(options, "pdftitle");
 597         if (!pdftitle.empty()) {
 598                 h_pdf_title = remove_braces(pdftitle);
 599         }
 600         string pdfauthor = process_keyval_opt(options, "pdfauthor");
 601         if (!pdfauthor.empty()) {
 602                 h_pdf_author = remove_braces(pdfauthor);
 603         }
 604         string pdfsubject = process_keyval_opt(options, "pdfsubject");
 605         if (!pdfsubject.empty())
 606                 h_pdf_subject = remove_braces(pdfsubject);
 607         string pdfkeywords = process_keyval_opt(options, "pdfkeywords");
 608         if (!pdfkeywords.empty())
 609                 h_pdf_keywords = remove_braces(pdfkeywords);
 610         if (!options.empty()) {
 611                 if (!h_pdf_quoted_options.empty())
 612                         h_pdf_quoted_options += ',';
 613                 h_pdf_quoted_options += join(options, ",");
 614                 options.clear();
 615         }
 616 }
 617
 618
 619 void Preamble::handle_geometry(vector<string> & options)
 620 {
 621         h_use_geometry = "true";
 622         vector<string>::iterator it;
 623         // paper orientation
 624         if ((it = find(options.begin(), options.end(), "landscape")) != options.end()) {
 625                 h_paperorientation = "landscape";
 626                 options.erase(it);
 627         }
 628         // paper size
 629         // keyval version: "paper=letter"
 630         string paper = process_keyval_opt(options, "paper");
 631         if (!paper.empty())
 632                 h_papersize = paper + "paper";
 633         // alternative version: "letterpaper"
 634         handle_opt(options, known_paper_sizes, h_papersize);
 635         delete_opt(options, known_paper_sizes);
 636         // page margins
 637         char const * const * margin = known_paper_margins;
 638         for (; *margin; ++margin) {
 639                 string value = process_keyval_opt(options, *margin);
 640                 if (!value.empty()) {
 641                         int k = margin - known_paper_margins;
 642                         string name = known_coded_paper_margins[k];
 643                         h_margins += '\\' + name + ' ' + value + '\n';
 644                 }
 645         }
 646 }
 647
 648
 649 void Preamble::handle_package(Parser &p, string const & name,
 650                               string const & opts, bool in_lyx_preamble)
 651 {
 652         vector<string> options = split_options(opts);
 653         add_package(name, options);
 654         char const * const * where = 0;
 655
 656         if (is_known(name, known_xetex_packages)) {
 657                 xetex = true;
 658                 h_use_non_tex_fonts = "true";
 659                 registerAutomaticallyLoadedPackage("fontspec");
 660                 if (h_inputencoding == "auto")
 661                         p.setEncoding("UTF-8");
 662         }
 663
 664         // roman fonts
 665         if (is_known(name, known_roman_fonts))
 666                 h_font_roman = name;
 667
 668         if (name == "fourier") {
 669                 h_font_roman = "utopia";
 670                 // when font uses real small capitals
 671                 if (opts == "expert")
 672                         h_font_sc = "true";
 673         }
 674
 675         if (name == "garamondx") {
 676                 h_font_roman = "garamondx";
 677                 if (opts == "osfI")
 678                         h_font_osf = "true";
 679         }
 680
 681         if (name == "libertine-type1") {
 682                 h_font_roman = "libertine";
 683                 if (opts == "lining")
 684                         h_font_osf = "false";
 685                 else
 686                         h_font_osf = "true";
 687         }
 688
 689         if (name == "mathdesign") {
 690                 if (opts.find("charter") != string::npos)
 691                         h_font_roman = "md-charter";
 692                 if (opts.find("garamond") != string::npos)
 693                         h_font_roman = "md-garamond";
 694                 if (opts.find("utopia") != string::npos)
 695                         h_font_roman = "md-utopia";
 696                 if (opts.find("expert") != string::npos) {
 697                         h_font_sc = "true";
 698                         h_font_osf = "true";
 699                 }
 700         }
 701
 702         else if (name == "mathpazo")
 703                 h_font_roman = "palatino";
 704
 705         else if (name == "mathptmx")
 706                 h_font_roman = "times";
 707
 708         // sansserif fonts
 709         if (is_known(name, known_sans_fonts)) {
 710                 h_font_sans = name;
 711                 if (options.size() == 1) {
 712                         if (scale_as_percentage(opts, h_font_sf_scale))
 713                                 options.clear();
 714                 }
 715         }
 716
 717         if (name == "biolinum-type1")
 718                 h_font_sans = "biolinum";
 719
 720         // typewriter fonts
 721         if (is_known(name, known_typewriter_fonts)) {
 722                 // fourier can be set as roman font _only_
 723                 // fourier as typewriter is handled in handling of \ttdefault
 724                 if (name != "fourier") {
 725                         h_font_typewriter = name;
 726                         if (options.size() == 1) {
 727                                 if (scale_as_percentage(opts, h_font_tt_scale))
 728                                         options.clear();
 729                         }
 730                 }
 731         }
 732
 733         // font uses old-style figure
 734         if (name == "eco")
 735                 h_font_osf = "true";
 736
 737         // math fonts
 738         if (is_known(name, known_math_fonts))
 739                 h_font_math = name;
 740
 741         if (name == "newtxmath") {
 742                 if (opts.empty())
 743                         h_font_math = "newtxmath";
 744                 else if (opts == "garamondx")
 745                         h_font_math = "garamondx-ntxm";
 746                 else if (opts == "libertine")
 747                         h_font_math = "libertine-ntxm";
 748                 else if (opts == "minion")
 749                         h_font_math = "minion-ntxm";
 750         }
 751
 752         if (name == "refstyle")
 753                 h_use_refstyle = "1";
 754
 755         // after the detection and handling of special cases, we can remove the
 756         // fonts, otherwise they would appear in the preamble, see bug #7856
 757         if (is_known(name, known_roman_fonts) || is_known(name, known_sans_fonts)
 758                 ||      is_known(name, known_typewriter_fonts) || is_known(name, known_math_fonts))
 759                 ;
 760
 761         else if (name == "amsmath" || name == "amssymb" ||
 762                  name == "esint" || name == "mhchem" || name == "mathdots" ||
 763                  name == "mathtools" || name == "stackrel" ||
 764                  name == "stmaryrd" || name == "undertilde")
 765                 h_use_packages[name] = "2";
 766
 767         else if (name == "babel") {
 768                 h_language_package = "default";
 769                 // One might think we would have to do nothing if babel is loaded
 770                 // without any options to prevent pollution of the preamble with this
 771                 // babel call in every roundtrip.
 772                 // But the user could have defined babel-specific things afterwards. So
 773                 // we need to keep it in the preamble to prevent cases like bug #7861.
 774                 if (!opts.empty()) {
 775                         // check if more than one option was used - used later for inputenc
 776                         if (options.begin() != options.end() - 1)
 777                                 one_language = false;
 778                         // babel takes the last language of the option of its \usepackage
 779                         // call as document language. If there is no such language option, the
 780                         // last language in the documentclass options is used.
 781                         handle_opt(options, known_languages, h_language);
 782                         // translate the babel name to a LyX name
 783                         h_language = babel2lyx(h_language);
 784                         if (h_language == "japanese") {
 785                                 // For Japanese, the encoding isn't indicated in the source
 786                                 // file, and there's really not much we can do. We could
 787                                 // 1) offer a list of possible encodings to choose from, or
 788                                 // 2) determine the encoding of the file by inspecting it.
 789                                 // For the time being, we leave the encoding alone so that
 790                                 // we don't get iconv errors when making a wrong guess, and
 791                                 // we will output a note at the top of the document
 792                                 // explaining what to do.
 793                                 Encoding const * const enc = encodings.fromIconvName(
 794                                         p.getEncoding(), Encoding::japanese, false);
 795                                 if (enc)
 796                                         h_inputencoding = enc->name();
 797                                 is_nonCJKJapanese = true;
 798                                 // in this case babel can be removed from the preamble
 799                                 registerAutomaticallyLoadedPackage("babel");
 800                         } else {
 801                                 // If babel is called with options, LyX puts them by default into the
 802                                 // document class options. This works for most languages, except
 803                                 // for Latvian, Lithuanian, Mongolian, Turkmen and Vietnamese and
 804                                 // perhaps in future others.
 805                                 // Therefore keep the babel call as it is as the user might have
 806                                 // reasons for it.
 807                                 h_preamble << "\\usepackage[" << opts << "]{babel}\n";
 808                         }
 809                         delete_opt(options, known_languages);
 810                 }
 811                 else
 812                         h_preamble << "\\usepackage{babel}\n";
 813         }
 814
 815         else if (name == "polyglossia") {
 816                 h_language_package = "default";
 817                 h_default_output_format = "pdf4";
 818                 h_use_non_tex_fonts = "true";
 819                 xetex = true;
 820                 registerAutomaticallyLoadedPackage("xunicode");
 821                 if (h_inputencoding == "auto")
 822                         p.setEncoding("UTF-8");
 823         }
 824
 825         else if (name == "CJK") {
 826                 // set the encoding to "auto" because it might be set to "default" by the babel handling
 827                 // and this would not be correct for CJK
 828                 if (h_inputencoding == "default")
 829                         h_inputencoding = "auto";
 830                 registerAutomaticallyLoadedPackage("CJK");
 831         }
 832
 833         else if (name == "CJKutf8") {
 834                 h_inputencoding = "UTF8";
 835                 p.setEncoding("UTF-8");
 836                 registerAutomaticallyLoadedPackage("CJKutf8");
 837         }
 838
 839         else if (name == "fontenc") {
 840                 h_fontencoding = getStringFromVector(options, ",");
 841                 /* We could do the following for better round trip support,
 842                  * but this makes the document less portable, so I skip it:
 843                 if (h_fontencoding == lyxrc.fontenc)
 844                         h_fontencoding = "global";
 845                  */
 846                 options.clear();
 847         }
 848
 849         else if (name == "inputenc" || name == "luainputenc") {
 850                 // h_inputencoding is only set when there is not more than one
 851                 // inputenc option because otherwise h_inputencoding must be
 852                 // set to "auto" (the default encoding of the document language)
 853                 // Therefore check for the "," character.
 854                 // It is also only set when there is not more than one babel
 855                 // language option.
 856                 if (!opts.empty()) {
 857                         if (opts.find(",") == string::npos && one_language == true) {
 858                                 h_inputencoding = opts;
 859                                 // FIXME: if this line is used, tex2lyx swallows the next character
 860                                 // in the file behind "{inputenc}"
 861                                 //p.setEncoding(opts);
 862                         } else {
 863                                 h_preamble << "\\usepackage[" << opts << "}{" << name << "}\n";
 864                                 // FIXME: enabling this introduces bug #8525
 865                                 //p.setEncoding(options.back(), Encoding::inputenc);
 866                         }
 867                         options.clear();
 868                 } else
 869                         h_preamble << "\\usepackage{" << name << "}\n";
 870         }
 871
 872         else if (name == "srcltx") {
 873                 h_output_sync = "1";
 874                 if (!opts.empty()) {
 875                         h_output_sync_macro = "\\usepackage[" + opts + "]{srcltx}";
 876                         options.clear();
 877                 } else
 878                         h_output_sync_macro = "\\usepackage{srcltx}";
 879         }
 880
 881         else if (is_known(name, known_old_language_packages)) {
 882                 // known language packages from the times before babel
 883                 // if they are found and not also babel, they will be used as
 884                 // custom language package
 885                 h_language_package = "\\usepackage{" + name + "}";
 886         }
 887
 888         else if (name == "prettyref")
 889                 ; // ignore this FIXME: Use the package separator mechanism instead
 890
 891         else if (name == "lyxskak") {
 892                 // ignore this and its options
 893                 const char * const o[] = {"ps", "mover", 0};
 894                 delete_opt(options, o);
 895         }
 896
 897         else if (is_known(name, known_lyx_packages) && options.empty()) {
 898                 if (name == "splitidx")
 899                         h_use_indices = "true";
 900                 if (!in_lyx_preamble) {
 901                         h_preamble << package_beg_sep << name
 902                                    << package_mid_sep << "\\usepackage{"
 903                                    << name << '}';
 904                         if (p.next_token().cat() == catNewline ||
 905                             (p.next_token().cat() == catSpace &&
 906                              p.next_next_token().cat() == catNewline))
 907                                 h_preamble << '\n';
 908                         h_preamble << package_end_sep;
 909                 }
 910         }
 911
 912         else if (name == "geometry")
 913                 handle_geometry(options);
 914
 915         else if (name == "subfig")
 916                 ; // ignore this FIXME: Use the package separator mechanism instead
 917
 918         else if ((where = is_known(name, known_languages)))
 919                 h_language = known_coded_languages[where - known_languages];
 920
 921         else if (name == "natbib") {
 922                 h_biblio_style = "plainnat";
 923                 h_cite_engine = "natbib";
 924                 h_cite_engine_type = "authoryear";
 925                 vector<string>::iterator it =
 926                         find(options.begin(), options.end(), "authoryear");
 927                 if (it != options.end())
 928                         options.erase(it);
 929                 else {
 930                         it = find(options.begin(), options.end(), "numbers");
 931                         if (it != options.end()) {
 932                                 h_cite_engine_type = "numerical";
 933                                 options.erase(it);
 934                         }
 935                 }
 936         }
 937
 938         else if (name == "jurabib") {
 939                 h_biblio_style = "jurabib";
 940                 h_cite_engine = "jurabib";
 941                 h_cite_engine_type = "authoryear";
 942         }
 943
 944         else if (name == "hyperref")
 945                 handle_hyperref(options);
 946
 947         else if (!in_lyx_preamble) {
 948                 if (options.empty())
 949                         h_preamble << "\\usepackage{" << name << '}';
 950                 else {
 951                         h_preamble << "\\usepackage[" << opts << "]{"
 952                                    << name << '}';
 953                         options.clear();
 954                 }
 955                 if (p.next_token().cat() == catNewline ||
 956                     (p.next_token().cat() == catSpace &&
 957                      p.next_next_token().cat() == catNewline))
 958                         h_preamble << '\n';
 959         }
 960
 961         // We need to do something with the options...
 962         if (!options.empty())
 963                 cerr << "Ignoring options '" << join(options, ",")
 964                      << "' of package " << name << '.' << endl;
 965
 966         // remove the whitespace
 967         p.skip_spaces();
 968 }
 969
 970
 971 void Preamble::handle_if(Parser & p, bool in_lyx_preamble)
 972 {
 973         while (p.good()) {
 974                 Token t = p.get_token();
 975                 if (t.cat() == catEscape &&
 976                     is_known(t.cs(), known_if_commands))
 977                         handle_if(p, in_lyx_preamble);
 978                 else {
 979                         if (!in_lyx_preamble)
 980                                 h_preamble << t.asInput();
 981                         if (t.cat() == catEscape && t.cs() == "fi")
 982                                 return;
 983                 }
 984         }
 985 }
 986
 987
 988 bool Preamble::writeLyXHeader(ostream & os, bool subdoc)
 989 {
 990         // set the quote language
 991         // LyX only knows the following quotes languages:
 992         // english, swedish, german, polish, french and danish
 993         // (quotes for "japanese" and "chinese-traditional" are missing because
 994         //  they wouldn't be useful: http://www.lyx.org/trac/ticket/6383)
 995         // conversion list taken from
 996         // http://en.wikipedia.org/wiki/Quotation_mark,_non-English_usage
 997         // (quotes for kazakh and interlingua are unknown)
 998         // danish
 999         if (is_known(h_language, known_danish_quotes_languages))
1000                 h_quotes_language = "danish";
1001         // french
1002         else if (is_known(h_language, known_french_quotes_languages))
1003                 h_quotes_language = "french";
1004         // german
1005         else if (is_known(h_language, known_german_quotes_languages))
1006                 h_quotes_language = "german";
1007         // polish
1008         else if (is_known(h_language, known_polish_quotes_languages))
1009                 h_quotes_language = "polish";
1010         // swedish
1011         else if (is_known(h_language, known_swedish_quotes_languages))
1012                 h_quotes_language = "swedish";
1013         //english
1014         else if (is_known(h_language, known_english_quotes_languages))
1015                 h_quotes_language = "english";
1016
1017         if (contains(h_float_placement, "H"))
1018                 registerAutomaticallyLoadedPackage("float");
1019         if (h_spacing != "single" && h_spacing != "default")
1020                 registerAutomaticallyLoadedPackage("setspace");
1021         if (h_use_packages["amsmath"] == "2") {
1022                 // amsbsy and amstext are already provided by amsmath
1023                 registerAutomaticallyLoadedPackage("amsbsy");
1024                 registerAutomaticallyLoadedPackage("amstext");
1025         }
1026
1027         // output the LyX file settings
1028         os << "#LyX file created by tex2lyx " << PACKAGE_VERSION << "\n"
1029            << "\\lyxformat " << LYX_FORMAT << '\n'
1030            << "\\begin_document\n"
1031            << "\\begin_header\n"
1032            << "\\textclass " << h_textclass << "\n";
1033         string const raw = subdoc ? empty_string() : h_preamble.str();
1034         if (!raw.empty()) {
1035                 os << "\\begin_preamble\n";
1036                 for (string::size_type i = 0; i < raw.size(); ++i) {
1037                         if (raw[i] == package_beg_sep) {
1038                                 // Here follows some package loading code that
1039                                 // must be skipped if the package is loaded
1040                                 // automatically.
1041                                 string::size_type j = raw.find(package_mid_sep, i);
1042                                 if (j == string::npos)
1043                                         return false;
1044                                 string::size_type k = raw.find(package_end_sep, j);
1045                                 if (k == string::npos)
1046                                         return false;
1047                                 string const package = raw.substr(i + 1, j - i - 1);
1048                                 string const replacement = raw.substr(j + 1, k - j - 1);
1049                                 if (auto_packages.find(package) == auto_packages.end())
1050                                         os << replacement;
1051                                 i = k;
1052                         } else
1053                                 os.put(raw[i]);
1054                 }
1055                 os << "\n\\end_preamble\n";
1056         }
1057         if (!h_options.empty())
1058                 os << "\\options " << h_options << "\n";
1059         os << "\\use_default_options " << h_use_default_options << "\n";
1060         if (!used_modules.empty()) {
1061                 os << "\\begin_modules\n";
1062                 vector<string>::const_iterator const end = used_modules.end();
1063                 vector<string>::const_iterator it = used_modules.begin();
1064                 for (; it != end; ++it)
1065                         os << *it << '\n';
1066                 os << "\\end_modules\n";
1067         }
1068         os << "\\maintain_unincluded_children " << h_maintain_unincluded_children << "\n"
1069            << "\\language " << h_language << "\n"
1070            << "\\language_package " << h_language_package << "\n"
1071            << "\\inputencoding " << h_inputencoding << "\n"
1072            << "\\fontencoding " << h_fontencoding << "\n"
1073            << "\\font_roman " << h_font_roman << "\n"
1074            << "\\font_sans " << h_font_sans << "\n"
1075            << "\\font_typewriter " << h_font_typewriter << "\n"
1076            << "\\font_math " << h_font_math << "\n"
1077            << "\\font_default_family " << h_font_default_family << "\n"
1078            << "\\use_non_tex_fonts " << h_use_non_tex_fonts << "\n"
1079            << "\\font_sc " << h_font_sc << "\n"
1080            << "\\font_osf " << h_font_osf << "\n"
1081            << "\\font_sf_scale " << h_font_sf_scale << "\n"
1082            << "\\font_tt_scale " << h_font_tt_scale << '\n';
1083         if (!h_font_cjk.empty())
1084                 os << "\\font_cjk " << h_font_cjk << '\n';
1085         os << "\\graphics " << h_graphics << '\n'
1086            << "\\default_output_format " << h_default_output_format << "\n"
1087            << "\\output_sync " << h_output_sync << "\n";
1088         if (h_output_sync == "1")
1089                 os << "\\output_sync_macro \"" << h_output_sync_macro << "\"\n";
1090         os << "\\bibtex_command " << h_bibtex_command << "\n"
1091            << "\\index_command " << h_index_command << "\n";
1092         if (!h_float_placement.empty())
1093                 os << "\\float_placement " << h_float_placement << "\n";
1094         os << "\\paperfontsize " << h_paperfontsize << "\n"
1095            << "\\spacing " << h_spacing << "\n"
1096            << "\\use_hyperref " << h_use_hyperref << '\n';
1097         if (h_use_hyperref == "true") {
1098                 if (!h_pdf_title.empty())
1099                         os << "\\pdf_title \"" << h_pdf_title << "\"\n";
1100                 if (!h_pdf_author.empty())
1101                         os << "\\pdf_author \"" << h_pdf_author << "\"\n";
1102                 if (!h_pdf_subject.empty())
1103                         os << "\\pdf_subject \"" << h_pdf_subject << "\"\n";
1104                 if (!h_pdf_keywords.empty())
1105                         os << "\\pdf_keywords \"" << h_pdf_keywords << "\"\n";
1106                 os << "\\pdf_bookmarks " << h_pdf_bookmarks << "\n"
1107                       "\\pdf_bookmarksnumbered " << h_pdf_bookmarksnumbered << "\n"
1108                       "\\pdf_bookmarksopen " << h_pdf_bookmarksopen << "\n"
1109                       "\\pdf_bookmarksopenlevel " << h_pdf_bookmarksopenlevel << "\n"
1110                       "\\pdf_breaklinks " << h_pdf_breaklinks << "\n"
1111                       "\\pdf_pdfborder " << h_pdf_pdfborder << "\n"
1112                       "\\pdf_colorlinks " << h_pdf_colorlinks << "\n"
1113                       "\\pdf_backref " << h_pdf_backref << "\n"
1114                       "\\pdf_pdfusetitle " << h_pdf_pdfusetitle << '\n';
1115                 if (!h_pdf_pagemode.empty())
1116                         os << "\\pdf_pagemode " << h_pdf_pagemode << '\n';
1117                 if (!h_pdf_quoted_options.empty())
1118                         os << "\\pdf_quoted_options \"" << h_pdf_quoted_options << "\"\n";
1119         }
1120         os << "\\papersize " << h_papersize << "\n"
1121            << "\\use_geometry " << h_use_geometry << '\n';
1122         for (map<string, string>::const_iterator it = h_use_packages.begin();
1123              it != h_use_packages.end(); ++it)
1124                 os << "\\use_package " << it->first << ' ' << it->second << '\n';
1125         os << "\\cite_engine " << h_cite_engine << '\n'
1126            << "\\cite_engine_type " << h_cite_engine_type << '\n'
1127            << "\\biblio_style " << h_biblio_style << "\n"
1128            << "\\use_bibtopic " << h_use_bibtopic << "\n"
1129            << "\\use_indices " << h_use_indices << "\n"
1130            << "\\paperorientation " << h_paperorientation << '\n'
1131            << "\\suppress_date " << h_suppress_date << '\n'
1132            << "\\justification " << h_justification << '\n'
1133            << "\\use_refstyle " << h_use_refstyle << '\n';
1134         if (!h_fontcolor.empty())
1135                 os << "\\fontcolor " << h_fontcolor << '\n';
1136         if (!h_notefontcolor.empty())
1137                 os << "\\notefontcolor " << h_notefontcolor << '\n';
1138         if (!h_backgroundcolor.empty())
1139                 os << "\\backgroundcolor " << h_backgroundcolor << '\n';
1140         if (!h_boxbgcolor.empty())
1141                 os << "\\boxbgcolor " << h_boxbgcolor << '\n';
1142         os << "\\index " << h_index << '\n'
1143            << "\\shortcut " << h_shortcut << '\n'
1144            << "\\color " << h_color << '\n'
1145            << "\\end_index\n";
1146         os << h_margins
1147            << "\\secnumdepth " << h_secnumdepth << "\n"
1148            << "\\tocdepth " << h_tocdepth << "\n"
1149            << "\\paragraph_separation " << h_paragraph_separation << "\n";
1150         if (h_paragraph_separation == "skip")
1151                 os << "\\defskip " << h_defskip << "\n";
1152         else
1153                 os << "\\paragraph_indentation " << h_paragraph_indentation << "\n";
1154         os << "\\quotes_language " << h_quotes_language << "\n"
1155            << "\\papercolumns " << h_papercolumns << "\n"
1156            << "\\papersides " << h_papersides << "\n"
1157            << "\\paperpagestyle " << h_paperpagestyle << "\n";
1158         if (!h_listings_params.empty())
1159                 os << "\\listings_params " << h_listings_params << "\n";
1160         os << "\\tracking_changes " << h_tracking_changes << "\n"
1161            << "\\output_changes " << h_output_changes << "\n"
1162            << "\\html_math_output " << h_html_math_output << "\n"
1163            << "\\html_css_as_file " << h_html_css_as_file << "\n"
1164            << "\\html_be_strict " << h_html_be_strict << "\n"
1165            << authors_
1166            << "\\end_header\n\n"
1167            << "\\begin_body\n";
1168         return true;
1169 }
1170
1171
1172 void Preamble::parse(Parser & p, string const & forceclass,
1173                      TeX2LyXDocClass & tc)
1174 {
1175         // initialize fixed types
1176         special_columns['D'] = 3;
1177         bool is_full_document = false;
1178         bool is_lyx_file = false;
1179         bool in_lyx_preamble = false;
1180
1181         // determine whether this is a full document or a fragment for inclusion
1182         while (p.good()) {
1183                 Token const & t = p.get_token();
1184
1185                 if (t.cat() == catEscape && t.cs() == "documentclass") {
1186                         is_full_document = true;
1187                         break;
1188                 }
1189         }
1190         p.reset();
1191
1192         while (is_full_document && p.good()) {
1193                 Token const & t = p.get_token();
1194
1195 #ifdef FILEDEBUG
1196                 cerr << "t: " << t << "\n";
1197 #endif
1198
1199                 //
1200                 // cat codes
1201                 //
1202                 if (!in_lyx_preamble &&
1203                     (t.cat() == catLetter ||
1204                      t.cat() == catSuper ||
1205                      t.cat() == catSub ||
1206                      t.cat() == catOther ||
1207                      t.cat() == catMath ||
1208                      t.cat() == catActive ||
1209                      t.cat() == catBegin ||
1210                      t.cat() == catEnd ||
1211                      t.cat() == catAlign ||
1212                      t.cat() == catParameter))
1213                         h_preamble << t.cs();
1214
1215                 else if (!in_lyx_preamble &&
1216                          (t.cat() == catSpace || t.cat() == catNewline))
1217                         h_preamble << t.asInput();
1218
1219                 else if (t.cat() == catComment) {
1220                         static regex const islyxfile("%% LyX .* created this file");
1221                         static regex const usercommands("User specified LaTeX commands");
1222
1223                         string const comment = t.asInput();
1224
1225                         // magically switch encoding default if it looks like XeLaTeX
1226                         static string const magicXeLaTeX =
1227                                 "% This document must be compiled with XeLaTeX ";
1228                         if (comment.size() > magicXeLaTeX.size()
1229                                   && comment.substr(0, magicXeLaTeX.size()) == magicXeLaTeX
1230                                   && h_inputencoding == "auto") {
1231                                 cerr << "XeLaTeX comment found, switching to UTF8\n";
1232                                 h_inputencoding = "utf8";
1233                         }
1234                         smatch sub;
1235                         if (regex_search(comment, sub, islyxfile)) {
1236                                 is_lyx_file = true;
1237                                 in_lyx_preamble = true;
1238                         } else if (is_lyx_file
1239                                    && regex_search(comment, sub, usercommands))
1240                                 in_lyx_preamble = false;
1241                         else if (!in_lyx_preamble)
1242                                 h_preamble << t.asInput();
1243                 }
1244
1245                 else if (t.cs() == "pagestyle")
1246                         h_paperpagestyle = p.verbatim_item();
1247
1248                 else if (t.cs() == "setdefaultlanguage") {
1249                         xetex = true;
1250                         // We don't yet care about non-language variant options
1251                         // because LyX doesn't support this yet, see bug #8214
1252                         if (p.hasOpt()) {
1253                                 string langopts = p.getOpt();
1254                                 // check if the option contains a variant, if yes, extract it
1255                                 string::size_type pos_var = langopts.find("variant");
1256                                 string::size_type i = langopts.find(',', pos_var);
1257                                 string::size_type k = langopts.find('=', pos_var);
1258                                 if (pos_var != string::npos){
1259                                         string variant;
1260                                         if (i == string::npos)
1261                                                 variant = langopts.substr(k + 1, langopts.length() - k - 2);
1262                                         else
1263                                                 variant = langopts.substr(k + 1, i - k - 1);
1264                                         h_language = variant;
1265                                 }
1266                                 p.verbatim_item();
1267                         } else
1268                                 h_language = p.verbatim_item();
1269                         //finally translate the poyglossia name to a LyX name
1270                         h_language = polyglossia2lyx(h_language);
1271                 }
1272
1273                 else if (t.cs() == "setotherlanguage") {
1274                         // We don't yet care about the option because LyX doesn't
1275                         // support this yet, see bug #8214
1276                         p.hasOpt() ? p.getOpt() : string();
1277                         p.verbatim_item();
1278                 }
1279
1280                 else if (t.cs() == "setmainfont") {
1281                         // we don't care about the option
1282                         p.hasOpt() ? p.getOpt() : string();
1283                         h_font_roman = p.getArg('{', '}');
1284                 }
1285
1286                 else if (t.cs() == "setsansfont" || t.cs() == "setmonofont") {
1287                         // LyX currently only supports the scale option
1288                         string scale;
1289                         if (p.hasOpt()) {
1290                                 string fontopts = p.getArg('[', ']');
1291                                 // check if the option contains a scaling, if yes, extract it
1292                                 string::size_type pos = fontopts.find("Scale");
1293                                 if (pos != string::npos) {
1294                                         string::size_type i = fontopts.find(',', pos);
1295                                         if (i == string::npos)
1296                                                 scale_as_percentage(fontopts.substr(pos + 1), scale);
1297                                         else
1298                                                 scale_as_percentage(fontopts.substr(pos, i - pos), scale);
1299                                 }
1300                         }
1301                         if (t.cs() == "setsansfont") {
1302                                 if (!scale.empty())
1303                                         h_font_sf_scale = scale;
1304                                 h_font_sans = p.getArg('{', '}');
1305                         } else {
1306                                 if (!scale.empty())
1307                                         h_font_tt_scale = scale;
1308                                 h_font_typewriter = p.getArg('{', '}');
1309                         }
1310                 }
1311
1312                 else if (t.cs() == "date") {
1313                         string argument = p.getArg('{', '}');
1314                         if (argument.empty())
1315                                 h_suppress_date = "true";
1316                         else
1317                                 h_preamble << t.asInput() << '{' << argument << '}';
1318                 }
1319
1320                 else if (t.cs() == "color") {
1321                         string const space =
1322                                 (p.hasOpt() ? p.getOpt() : string());
1323                         string argument = p.getArg('{', '}');
1324                         // check the case that a standard color is used
1325                         if (space.empty() && is_known(argument, known_basic_colors)) {
1326                                 h_fontcolor = rgbcolor2code(argument);
1327                                 preamble.registerAutomaticallyLoadedPackage("color");
1328                         } else if (space.empty() && argument == "document_fontcolor")
1329                                 preamble.registerAutomaticallyLoadedPackage("color");
1330                         // check the case that LyX's document_fontcolor is defined
1331                         // but not used for \color
1332                         else {
1333                                 h_preamble << t.asInput();
1334                                 if (!space.empty())
1335                                         h_preamble << space;
1336                                 h_preamble << '{' << argument << '}';
1337                                 // the color might already be set because \definecolor
1338                                 // is parsed before this
1339                                 h_fontcolor = "";
1340                         }
1341                 }
1342
1343                 else if (t.cs() == "pagecolor") {
1344                         string argument = p.getArg('{', '}');
1345                         // check the case that a standard color is used
1346                         if (is_known(argument, known_basic_colors)) {
1347                                 h_backgroundcolor = rgbcolor2code(argument);
1348                         } else if (argument == "page_backgroundcolor")
1349                                 preamble.registerAutomaticallyLoadedPackage("color");
1350                         // check the case that LyX's page_backgroundcolor is defined
1351                         // but not used for \pagecolor
1352                         else {
1353                                 h_preamble << t.asInput() << '{' << argument << '}';
1354                                 // the color might already be set because \definecolor
1355                                 // is parsed before this
1356                                 h_backgroundcolor = "";
1357                         }
1358                 }
1359
1360                 else if (t.cs() == "makeatletter") {
1361                         // LyX takes care of this
1362                         p.setCatcode('@', catLetter);
1363                 }
1364
1365                 else if (t.cs() == "makeatother") {
1366                         // LyX takes care of this
1367                         p.setCatcode('@', catOther);
1368                 }
1369
1370                 else if (t.cs() == "newcommand" || t.cs() == "newcommandx"
1371                       || t.cs() == "renewcommand" || t.cs() == "renewcommandx"
1372                       || t.cs() == "providecommand" || t.cs() == "providecommandx"
1373                                 || t.cs() == "DeclareRobustCommand"
1374                       || t.cs() == "DeclareRobustCommandx"
1375                                 || t.cs() == "ProvideTextCommandDefault"
1376                                 || t.cs() == "DeclareMathAccent") {
1377                         bool star = false;
1378                         if (p.next_token().character() == '*') {
1379                                 p.get_token();
1380                                 star = true;
1381                         }
1382                         string const name = p.verbatim_item();
1383                         string const opt1 = p.getFullOpt();
1384                         string const opt2 = p.getFullOpt();
1385                         string const body = p.verbatim_item();
1386                         // store the in_lyx_preamble setting
1387                         bool const was_in_lyx_preamble = in_lyx_preamble;
1388                         // font settings
1389                         if (name == "\\rmdefault")
1390                                 if (is_known(body, known_roman_fonts)) {
1391                                         h_font_roman = body;
1392                                         p.skip_spaces();
1393                                         in_lyx_preamble = true;
1394                                 }
1395                         if (name == "\\sfdefault")
1396                                 if (is_known(body, known_sans_fonts)) {
1397                                         h_font_sans = body;
1398                                         p.skip_spaces();
1399                                         in_lyx_preamble = true;
1400                                 }
1401                         if (name == "\\ttdefault")
1402                                 if (is_known(body, known_typewriter_fonts)) {
1403                                         h_font_typewriter = body;
1404                                         p.skip_spaces();
1405                                         in_lyx_preamble = true;
1406                                 }
1407                         if (name == "\\familydefault") {
1408                                 string family = body;
1409                                 // remove leading "\"
1410                                 h_font_default_family = family.erase(0,1);
1411                                 p.skip_spaces();
1412                                 in_lyx_preamble = true;
1413                         }
1414
1415                         if (name == "\\bfdefault")
1416                                 // LyX re-adds this if a kurier font is used
1417                                 if (is_known(h_font_sans, known_kurier_fonts) && body == "b") {
1418                                         p.skip_spaces();
1419                                         in_lyx_preamble = true;
1420                                 }
1421
1422                         // remove the lyxdot definition that is re-added by LyX
1423                         // if necessary
1424                         if (name == "\\lyxdot") {
1425                                 p.skip_spaces();
1426                                 in_lyx_preamble = true;
1427                         }
1428
1429                         // Add the command to the known commands
1430                         add_known_command(name, opt1, !opt2.empty(), from_utf8(body));
1431
1432                         // only non-lyxspecific stuff
1433                         if (!in_lyx_preamble) {
1434                                 ostringstream ss;
1435                                 ss << '\\' << t.cs();
1436                                 if (star)
1437                                         ss << '*';
1438                                 ss << '{' << name << '}' << opt1 << opt2
1439                                    << '{' << body << "}";
1440                                 h_preamble << ss.str();
1441 /*
1442                                 ostream & out = in_preamble ? h_preamble : os;
1443                                 out << "\\" << t.cs() << "{" << name << "}"
1444                                     << opts << "{" << body << "}";
1445 */
1446                         }
1447                         // restore the in_lyx_preamble setting
1448                         in_lyx_preamble = was_in_lyx_preamble;
1449                 }
1450
1451                 else if (t.cs() == "edef"){
1452                         // we only support this for kurier fonts
1453                         string const command = p.next_token().asInput();
1454                         p.get_token();
1455                         if (command == "\\sfdefault") {
1456                                 p.getArg('{', '}');
1457                                 if (h_font_sans == "kurier")
1458                                         h_font_sans = "kurier-condensed";
1459                                 if (h_font_sans == "kurierl")
1460                                         h_font_sans = "kurier-light-condensed";
1461                                 p.skip_spaces();
1462                         }
1463                         else
1464                                 h_preamble << "\\edef" << command << "{" << p.getArg('{', '}') << "}\n";
1465                 }
1466
1467                 else if (t.cs() == "documentclass") {
1468                         vector<string>::iterator it;
1469                         vector<string> opts = split_options(p.getArg('[', ']'));
1470                         handle_opt(opts, known_fontsizes, h_paperfontsize);
1471                         delete_opt(opts, known_fontsizes);
1472                         // delete "pt" at the end
1473                         string::size_type i = h_paperfontsize.find("pt");
1474                         if (i != string::npos)
1475                                 h_paperfontsize.erase(i);
1476                         // The documentclass options are always parsed before the options
1477                         // of the babel call so that a language cannot overwrite the babel
1478                         // options.
1479                         handle_opt(opts, known_languages, h_language);
1480                         delete_opt(opts, known_languages);
1481
1482                         // paper orientation
1483                         if ((it = find(opts.begin(), opts.end(), "landscape")) != opts.end()) {
1484                                 h_paperorientation = "landscape";
1485                                 opts.erase(it);
1486                         }
1487                         // paper sides
1488                         if ((it = find(opts.begin(), opts.end(), "oneside"))
1489                                  != opts.end()) {
1490                                 h_papersides = "1";
1491                                 opts.erase(it);
1492                         }
1493                         if ((it = find(opts.begin(), opts.end(), "twoside"))
1494                                  != opts.end()) {
1495                                 h_papersides = "2";
1496                                 opts.erase(it);
1497                         }
1498                         // paper columns
1499                         if ((it = find(opts.begin(), opts.end(), "onecolumn"))
1500                                  != opts.end()) {
1501                                 h_papercolumns = "1";
1502                                 opts.erase(it);
1503                         }
1504                         if ((it = find(opts.begin(), opts.end(), "twocolumn"))
1505                                  != opts.end()) {
1506                                 h_papercolumns = "2";
1507                                 opts.erase(it);
1508                         }
1509                         // paper sizes
1510                         // some size options are known to any document classes, other sizes
1511                         // are handled by the \geometry command of the geometry package
1512                         handle_opt(opts, known_class_paper_sizes, h_papersize);
1513                         delete_opt(opts, known_class_paper_sizes);
1514                         // the remaining options
1515                         h_options = join(opts, ",");
1516                         // FIXME This does not work for classes that have a
1517                         //       different name in LyX than in LaTeX
1518                         h_textclass = p.getArg('{', '}');
1519                         p.skip_spaces();
1520                 }
1521
1522                 else if (t.cs() == "usepackage") {
1523                         string const options = p.getArg('[', ']');
1524                         string const name = p.getArg('{', '}');
1525                         vector<string> vecnames;
1526                         split(name, vecnames, ',');
1527                         vector<string>::const_iterator it  = vecnames.begin();
1528                         vector<string>::const_iterator end = vecnames.end();
1529                         for (; it != end; ++it)
1530                                 handle_package(p, trimSpaceAndEol(*it), options,
1531                                                in_lyx_preamble);
1532                 }
1533
1534                 else if (t.cs() == "inputencoding") {
1535                         string const encoding = p.getArg('{','}');
1536                         h_inputencoding = encoding;
1537                         p.setEncoding(encoding, Encoding::inputenc);
1538                 }
1539
1540                 else if (t.cs() == "newenvironment") {
1541                         string const name = p.getArg('{', '}');
1542                         string const opt1 = p.getFullOpt();
1543                         string const opt2 = p.getFullOpt();
1544                         string const beg = p.verbatim_item();
1545                         string const end = p.verbatim_item();
1546                         if (!in_lyx_preamble) {
1547                                 h_preamble << "\\newenvironment{" << name
1548                                            << '}' << opt1 << opt2 << '{'
1549                                            << beg << "}{" << end << '}';
1550                         }
1551                         add_known_environment(name, opt1, !opt2.empty(),
1552                                               from_utf8(beg), from_utf8(end));
1553
1554                 }
1555
1556                 else if (t.cs() == "newtheorem") {
1557                         string const name = p.getArg('{', '}');
1558                         string const opt1 = p.getFullOpt();
1559                         string const opt2 = p.getFullOpt();
1560                         string const body = p.verbatim_item();
1561                         string const opt3 = p.getFullOpt();
1562
1563                         add_known_theorem(name, opt1, !opt2.empty(),
1564                                 from_utf8("\\newtheorem{" + name + '}' +
1565                                           opt1 + opt2 + '{' + body + '}' + opt3));
1566
1567                         if (!in_lyx_preamble)
1568                                 h_preamble << "\\newtheorem{" << name << '}'
1569                                            << opt1 << opt2 << '{' << '}' << opt3;
1570                 }
1571
1572                 else if (t.cs() == "def") {
1573                         string name = p.get_token().cs();
1574                         // In fact, name may be more than the name:
1575                         // In the test case of bug 8116
1576                         // name == "csname SF@gobble@opt \endcsname".
1577                         // Therefore, we need to use asInput() instead of cs().
1578                         while (p.next_token().cat() != catBegin)
1579                                 name += p.get_token().asInput();
1580                         if (!in_lyx_preamble)
1581                                 h_preamble << "\\def\\" << name << '{'
1582                                            << p.verbatim_item() << "}";
1583                 }
1584
1585                 else if (t.cs() == "newcolumntype") {
1586                         string const name = p.getArg('{', '}');
1587                         trimSpaceAndEol(name);
1588                         int nargs = 0;
1589                         string opts = p.getOpt();
1590                         if (!opts.empty()) {
1591                                 istringstream is(string(opts, 1));
1592                                 is >> nargs;
1593                         }
1594                         special_columns[name[0]] = nargs;
1595                         h_preamble << "\\newcolumntype{" << name << "}";
1596                         if (nargs)
1597                                 h_preamble << "[" << nargs << "]";
1598                         h_preamble << "{" << p.verbatim_item() << "}";
1599                 }
1600
1601                 else if (t.cs() == "setcounter") {
1602                         string const name = p.getArg('{', '}');
1603                         string const content = p.getArg('{', '}');
1604                         if (name == "secnumdepth")
1605                                 h_secnumdepth = content;
1606                         else if (name == "tocdepth")
1607                                 h_tocdepth = content;
1608                         else
1609                                 h_preamble << "\\setcounter{" << name << "}{" << content << "}";
1610                 }
1611
1612                 else if (t.cs() == "setlength") {
1613                         string const name = p.verbatim_item();
1614                         string const content = p.verbatim_item();
1615                         // the paragraphs are only not indented when \parindent is set to zero
1616                         if (name == "\\parindent" && content != "") {
1617                                 if (content[0] == '0')
1618                                         h_paragraph_separation = "skip";
1619                                 else
1620                                         h_paragraph_indentation = translate_len(content);
1621                         } else if (name == "\\parskip") {
1622                                 if (content == "\\smallskipamount")
1623                                         h_defskip = "smallskip";
1624                                 else if (content == "\\medskipamount")
1625                                         h_defskip = "medskip";
1626                                 else if (content == "\\bigskipamount")
1627                                         h_defskip = "bigskip";
1628                                 else
1629                                         h_defskip = content;
1630                         } else
1631                                 h_preamble << "\\setlength{" << name << "}{" << content << "}";
1632                 }
1633
1634                 else if (t.cs() == "onehalfspacing")
1635                         h_spacing = "onehalf";
1636
1637                 else if (t.cs() == "doublespacing")
1638                         h_spacing = "double";
1639
1640                 else if (t.cs() == "setstretch")
1641                         h_spacing = "other " + p.verbatim_item();
1642
1643                 else if (t.cs() == "synctex") {
1644                         // the scheme is \synctex=value
1645                         // where value can only be "1" or "-1"
1646                         h_output_sync = "1";
1647                         // there can be any character behind the value (e.g. a linebreak or a '\'
1648                         // therefore we extract it char by char
1649                         p.get_token();
1650                         string value = p.get_token().asInput();
1651                         if (value == "-")
1652                                 value += p.get_token().asInput();
1653                         h_output_sync_macro = "\\synctex=" + value;
1654                 }
1655
1656                 else if (t.cs() == "begin") {
1657                         string const name = p.getArg('{', '}');
1658                         if (name == "document")
1659                                 break;
1660                         h_preamble << "\\begin{" << name << "}";
1661                 }
1662
1663                 else if (t.cs() == "geometry") {
1664                         vector<string> opts = split_options(p.getArg('{', '}'));
1665                         handle_geometry(opts);
1666                 }
1667
1668                 else if (t.cs() == "definecolor") {
1669                         string const color = p.getArg('{', '}');
1670                         string const space = p.getArg('{', '}');
1671                         string const value = p.getArg('{', '}');
1672                         if (color == "document_fontcolor" && space == "rgb") {
1673                                 RGBColor c(RGBColorFromLaTeX(value));
1674                                 h_fontcolor = X11hexname(c);
1675                         } else if (color == "note_fontcolor" && space == "rgb") {
1676                                 RGBColor c(RGBColorFromLaTeX(value));
1677                                 h_notefontcolor = X11hexname(c);
1678                         } else if (color == "page_backgroundcolor" && space == "rgb") {
1679                                 RGBColor c(RGBColorFromLaTeX(value));
1680                                 h_backgroundcolor = X11hexname(c);
1681                         } else if (color == "shadecolor" && space == "rgb") {
1682                                 RGBColor c(RGBColorFromLaTeX(value));
1683                                 h_boxbgcolor = X11hexname(c);
1684                         } else {
1685                                 h_preamble << "\\definecolor{" << color
1686                                            << "}{" << space << "}{" << value
1687                                            << '}';
1688                         }
1689                 }
1690
1691                 else if (t.cs() == "bibliographystyle")
1692                         h_biblio_style = p.verbatim_item();
1693
1694                 else if (t.cs() == "jurabibsetup") {
1695                         // FIXME p.getArg('{', '}') is most probably wrong (it
1696                         //       does not handle nested braces).
1697                         //       Use p.verbatim_item() instead.
1698                         vector<string> jurabibsetup =
1699                                 split_options(p.getArg('{', '}'));
1700                         // add jurabibsetup to the jurabib package options
1701                         add_package("jurabib", jurabibsetup);
1702                         if (!jurabibsetup.empty()) {
1703                                 h_preamble << "\\jurabibsetup{"
1704                                            << join(jurabibsetup, ",") << '}';
1705                         }
1706                 }
1707
1708                 else if (t.cs() == "hypersetup") {
1709                         vector<string> hypersetup =
1710                                 split_options(p.verbatim_item());
1711                         // add hypersetup to the hyperref package options
1712                         handle_hyperref(hypersetup);
1713                         if (!hypersetup.empty()) {
1714                                 h_preamble << "\\hypersetup{"
1715                                            << join(hypersetup, ",") << '}';
1716                         }
1717                 }
1718
1719                 else if (is_known(t.cs(), known_if_3arg_commands)) {
1720                         // prevent misparsing of \usepackage if it is used
1721                         // as an argument (see e.g. our own output of
1722                         // \@ifundefined above)
1723                         string const arg1 = p.verbatim_item();
1724                         string const arg2 = p.verbatim_item();
1725                         string const arg3 = p.verbatim_item();
1726                         // test case \@ifundefined{date}{}{\date{}}
1727                         if (t.cs() == "@ifundefined" && arg1 == "date" &&
1728                             arg2.empty() && arg3 == "\\date{}") {
1729                                 h_suppress_date = "true";
1730                         // older tex2lyx versions did output
1731                         // \@ifundefined{definecolor}{\usepackage{color}}{}
1732                         } else if (t.cs() == "@ifundefined" &&
1733                                    arg1 == "definecolor" &&
1734                                    arg2 == "\\usepackage{color}" &&
1735                                    arg3.empty()) {
1736                                 if (!in_lyx_preamble)
1737                                         h_preamble << package_beg_sep
1738                                                    << "color"
1739                                                    << package_mid_sep
1740                                                    << "\\@ifundefined{definecolor}{color}{}"
1741                                                    << package_end_sep;
1742                         // test for case
1743                         //\@ifundefined{showcaptionsetup}{}{%
1744                         // \PassOptionsToPackage{caption=false}{subfig}}
1745                         // that LyX uses for subfloats
1746                         } else if (t.cs() == "@ifundefined" &&
1747                                    arg1 == "showcaptionsetup" && arg2.empty()
1748                                 && arg3 == "%\n \\PassOptionsToPackage{caption=false}{subfig}") {
1749                                 ; // do nothing
1750                         } else if (!in_lyx_preamble) {
1751                                 h_preamble << t.asInput()
1752                                            << '{' << arg1 << '}'
1753                                            << '{' << arg2 << '}'
1754                                            << '{' << arg3 << '}';
1755                         }
1756                 }
1757
1758                 else if (is_known(t.cs(), known_if_commands)) {
1759                         // must not parse anything in conditional code, since
1760                         // LyX would output the parsed contents unconditionally
1761                         if (!in_lyx_preamble)
1762                                 h_preamble << t.asInput();
1763                         handle_if(p, in_lyx_preamble);
1764                 }
1765
1766                 else if (!t.cs().empty() && !in_lyx_preamble)
1767                         h_preamble << '\\' << t.cs();
1768         }
1769
1770         // remove the whitespace
1771         p.skip_spaces();
1772
1773         // Force textclass if the user wanted it
1774         if (!forceclass.empty())
1775                 h_textclass = forceclass;
1776         tc.setName(h_textclass);
1777         if (!tc.load()) {
1778                 cerr << "Error: Could not read layout file for textclass \"" << h_textclass << "\"." << endl;
1779                 exit(EXIT_FAILURE);
1780         }
1781         if (h_papersides.empty()) {
1782                 ostringstream ss;
1783                 ss << tc.sides();
1784                 h_papersides = ss.str();
1785         }
1786
1787         // If the CJK package is used we cannot set the document language from
1788         // the babel options. Instead, we guess which language is used most
1789         // and set this one.
1790         default_language = h_language;
1791         if (is_full_document &&
1792             (auto_packages.find("CJK") != auto_packages.end() ||
1793              auto_packages.find("CJKutf8") != auto_packages.end())) {
1794                 p.pushPosition();
1795                 h_language = guessLanguage(p, default_language);
1796                 p.popPosition();
1797         }
1798 }
1799
1800
1801 string babel2lyx(string const & language)
1802 {
1803         char const * const * where = is_known(language, known_languages);
1804         if (where)
1805                 return known_coded_languages[where - known_languages];
1806         return language;
1807 }
1808
1809
1810 string Preamble::polyglossia2lyx(string const & language)
1811 {
1812         char const * const * where = is_known(language, polyglossia_languages);
1813         if (where)
1814                 return coded_polyglossia_languages[where - polyglossia_languages];
1815         return language;
1816 }
1817
1818
1819 string rgbcolor2code(string const & name)
1820 {
1821         char const * const * where = is_known(name, known_basic_colors);
1822         if (where) {
1823                 // "red", "green" etc
1824                 return known_basic_color_codes[where - known_basic_colors];
1825         }
1826         // "255,0,0", "0,255,0" etc
1827         RGBColor c(RGBColorFromLaTeX(name));
1828         return X11hexname(c);
1829 }
1830
1831 // }])
1832
1833
1834 } // namespace lyx