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 "LayoutFile.h"
  20 #include "Layout.h"
  21 #include "Lexer.h"
  22 #include "TextClass.h"
  23
  24 #include "support/convert.h"
  25 #include "support/FileName.h"
  26 #include "support/filetools.h"
  27 #include "support/lstrings.h"
  28
  29 #include "support/regex.h"
  30
  31 #include <algorithm>
  32 #include <iostream>
  33
  34 using namespace std;
  35 using namespace lyx::support;
  36
  37
  38 namespace lyx {
  39
  40 // special columntypes
  41 extern map<char, int> special_columns;
  42
  43 Preamble preamble;
  44
  45 namespace {
  46
  47 //add this to known_languages when updating to lyxformat 266:
  48 // "armenian" (needs special handling since not supported by standard babel)
  49 //add these to known_languages when updating to lyxformat 268:
  50 //"chinese-simplified", "chinese-traditional", "japanese", "korean"
  51 // Both changes require first that support for non-babel languages (CJK,
  52 // armtex) is added.
  53 /**
  54  * known babel language names (including synonyms)
  55  * not in standard babel: arabic, arabtex, armenian, belarusian, serbian-latin, thai
  56  * not yet supported by LyX: kurmanji
  57  * please keep this in sync with known_coded_languages line by line!
  58  */
  59 const char * const known_languages[] = {"acadian", "afrikaans", "albanian",
  60 "american", "arabic", "arabtex", "austrian", "bahasa", "bahasai", "bahasam",
  61 "basque", "belarusian", "brazil", "brazilian", "breton", "british", "bulgarian",
  62 "canadian", "canadien", "catalan", "croatian", "czech", "danish", "dutch",
  63 "english", "esperanto", "estonian", "farsi", "finnish", "francais", "french",
  64 "frenchb", "frenchle", "frenchpro", "galician", "german", "germanb", "greek",
  65 "hebrew", "hungarian", "icelandic", "indon", "indonesian", "interlingua",
  66 "irish", "italian", "kazakh", "latin", "latvian", "lithuanian", "lowersorbian",
  67 "lsorbian", "magyar", "malay", "meyalu", "mongolian", "naustrian", "newzealand",
  68 "ngerman", "ngermanb", "norsk", "nynorsk", "polutonikogreek", "polish",
  69 "portuges", "portuguese", "romanian", "russian", "russianb", "samin",
  70 "scottish", "serbian", "serbian-latin", "slovak", "slovene", "spanish",
  71 "swedish", "thai", "turkish", "turkmen", "ukraineb", "ukrainian",
  72 "uppersorbian", "UKenglish", "USenglish", "usorbian", "vietnam", "welsh",
  73 0};
  74
  75 /**
  76  * the same as known_languages with .lyx names
  77  * please keep this in sync with known_languages line by line!
  78  */
  79 const char * const known_coded_languages[] = {"french", "afrikaans", "albanian",
  80 "american", "arabic_arabi", "arabic_arabtex", "austrian", "bahasa", "bahasa", "bahasam",
  81 "basque", "belarusian", "brazilian", "brazilian", "breton", "british", "bulgarian",
  82 "canadian", "canadien", "catalan", "croatian", "czech", "danish", "dutch",
  83 "english", "esperanto", "estonian", "farsi", "finnish", "french", "french",
  84 "french", "french", "french", "galician", "german", "german", "greek",
  85 "hebrew", "magyar", "icelandic", "bahasa", "bahasa", "interlingua",
  86 "irish", "italian", "kazakh", "latin", "latvian", "lithuanian", "lowersorbian",
  87 "lowersorbian", "magyar", "bahasam", "bahasam", "mongolian", "naustrian", "english",
  88 "ngerman", "ngerman", "norsk", "nynorsk", "polutonikogreek", "polish",
  89 "portuguese", "portuguese", "romanian", "russian", "russian", "samin",
  90 "scottish", "serbian", "serbian-latin", "slovak", "slovene", "spanish",
  91 "swedish", "thai", "turkish", "turkmen", "ukrainian", "ukrainian",
  92 "uppersorbian", "uppersorbian", "english", "english", "vietnamese", "welsh",
  93 0};
  94
  95 /// languages with english quotes (.lyx names)
  96 const char * const known_english_quotes_languages[] = {"american", "bahasa",
  97 "bahasam", "brazilian", "canadian", "chinese-simplified", "english",
  98 "esperanto", "hebrew", "irish", "korean", "portuguese", "scottish", "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", "lmodern", "mathpazo",
 128 "mathptmx", "newcent", "utopia", 0};
 129
 130 const char * const known_sans_fonts[] = { "avant", "berasans", "cmbr", "cmss",
 131 "helvet", "lmss", 0};
 132
 133 const char * const known_typewriter_fonts[] = { "beramono", "cmtl", "cmtt",
 134 "courier", "lmtt", "luximono", "fourier", "lmodern", "mathpazo", "mathptmx",
 135 "newcent", 0};
 136
 137 const char * const known_paper_sizes[] = { "a0paper", "b0paper", "c0paper",
 138 "a1paper", "b1paper", "c1paper", "a2paper", "b2paper", "c2paper", "a3paper",
 139 "b3paper", "c3paper", "a4paper", "b4paper", "c4paper", "a5paper", "b5paper",
 140 "c5paper", "a6paper", "b6paper", "c6paper", "executivepaper", "legalpaper",
 141 "letterpaper", "b0j", "b1j", "b2j", "b3j", "b4j", "b5j", "b6j", 0};
 142
 143 const char * const known_class_paper_sizes[] = { "a4paper", "a5paper",
 144 "executivepaper", "legalpaper", "letterpaper", 0};
 145
 146 const char * const known_paper_margins[] = { "lmargin", "tmargin", "rmargin",
 147 "bmargin", "headheight", "headsep", "footskip", "columnsep", 0};
 148
 149 const char * const known_coded_paper_margins[] = { "leftmargin", "topmargin",
 150 "rightmargin", "bottommargin", "headheight", "headsep", "footskip",
 151 "columnsep", 0};
 152
 153 /// commands that can start an \if...\else...\endif sequence
 154 const char * const known_if_commands[] = {"if", "ifarydshln", "ifbraket",
 155 "ifcancel", "ifcolortbl", "ifeurosym", "ifmarginnote", "ifmmode", "ifpdf",
 156 "ifsidecap", "ifupgreek", 0};
 157
 158 const char * const known_basic_colors[] = {"blue", "black", "cyan", "green",
 159 "magenta", "red", "white", "yellow", 0};
 160
 161 const char * const known_basic_color_codes[] = {"#0000ff", "#000000", "#00ffff", "#00ff00",
 162 "#ff00ff", "#ff0000", "#ffffff", "#ffff00", 0};
 163
 164 /// conditional commands with three arguments like \@ifundefined{}{}{}
 165 const char * const known_if_3arg_commands[] = {"@ifundefined", "IfFileExists",
 166 0};
 167
 168 /// packages that work only in xetex
 169 const char * const known_xetex_packages[] = {"arabxetex", "fixlatvian",
 170 "fontbook", "fontwrap", "mathspec", "philokalia", "polyglossia", "unisugar",
 171 "xeCJK", "xecolor", "xecyr", "xeindex", "xepersian", "xunicode", 0};
 172
 173 // codes used to remove packages that are loaded automatically by LyX.
 174 // Syntax: package_beg_sep<name>package_mid_sep<package loading code>package_end_sep
 175 const char package_beg_sep = '\001';
 176 const char package_mid_sep = '\002';
 177 const char package_end_sep = '\003';
 178
 179
 180 // returns true if at least one of the options in what has been found
 181 bool handle_opt(vector<string> & opts, char const * const * what, string & target)
 182 {
 183         if (opts.empty())
 184                 return false;
 185
 186         bool found = false;
 187         // the last language option is the document language (for babel and LyX)
 188         // the last size option is the document font size
 189         vector<string>::iterator it;
 190         vector<string>::iterator position = opts.begin();
 191         for (; *what; ++what) {
 192                 it = find(opts.begin(), opts.end(), *what);
 193                 if (it != opts.end()) {
 194                         if (it >= position) {
 195                                 found = true;
 196                                 target = *what;
 197                                 position = it;
 198                         }
 199                 }
 200         }
 201         return found;
 202 }
 203
 204
 205 void delete_opt(vector<string> & opts, char const * const * what)
 206 {
 207         if (opts.empty())
 208                 return;
 209
 210         // remove found options from the list
 211         // do this after handle_opt to avoid potential memory leaks
 212         vector<string>::iterator it;
 213         for (; *what; ++what) {
 214                 it = find(opts.begin(), opts.end(), *what);
 215                 if (it != opts.end())
 216                         opts.erase(it);
 217         }
 218 }
 219
 220
 221 /*!
 222  * Split a package options string (keyval format) into a vector.
 223  * Example input:
 224  *   authorformat=smallcaps,
 225  *   commabeforerest,
 226  *   titleformat=colonsep,
 227  *   bibformat={tabular,ibidem,numbered}
 228  */
 229 vector<string> split_options(string const & input)
 230 {
 231         vector<string> options;
 232         string option;
 233         Parser p(input);
 234         while (p.good()) {
 235                 Token const & t = p.get_token();
 236                 if (t.asInput() == ",") {
 237                         options.push_back(trimSpaceAndEol(option));
 238                         option.erase();
 239                 } else if (t.asInput() == "=") {
 240                         option += '=';
 241                         p.skip_spaces(true);
 242                         if (p.next_token().asInput() == "{")
 243                                 option += '{' + p.getArg('{', '}') + '}';
 244                 } else if (t.cat() != catSpace)
 245                         option += t.asInput();
 246         }
 247
 248         if (!option.empty())
 249                 options.push_back(trimSpaceAndEol(option));
 250
 251         return options;
 252 }
 253
 254
 255 /*!
 256  * Retrieve a keyval option "name={value with=sign}" named \p name from
 257  * \p options and return the value.
 258  * The found option is also removed from \p options.
 259  */
 260 string process_keyval_opt(vector<string> & options, string name)
 261 {
 262         for (size_t i = 0; i < options.size(); ++i) {
 263                 vector<string> option;
 264                 split(options[i], option, '=');
 265                 if (option.size() < 2)
 266                         continue;
 267                 if (option[0] == name) {
 268                         options.erase(options.begin() + i);
 269                         option.erase(option.begin());
 270                         return join(option, "=");
 271                 }
 272         }
 273         return "";
 274 }
 275
 276 } // anonymous namespace
 277
 278
 279 bool Preamble::indentParagraphs() const
 280 {
 281         return h_paragraph_separation == "indent";
 282 }
 283
 284
 285 bool Preamble::isPackageUsed(string const & package) const
 286 {
 287         return used_packages.find(package) != used_packages.end();
 288 }
 289
 290
 291 vector<string> Preamble::getPackageOptions(string const & package) const
 292 {
 293         map<string, vector<string> >::const_iterator it = used_packages.find(package);
 294         if (it != used_packages.end())
 295                 return it->second;
 296         return vector<string>();
 297 }
 298
 299
 300 void Preamble::registerAutomaticallyLoadedPackage(std::string const & package)
 301 {
 302         auto_packages.insert(package);
 303 }
 304
 305
 306 void Preamble::addModule(string const & module)
 307 {
 308         used_modules.push_back(module);
 309 }
 310
 311
 312 void Preamble::suppressDate(bool suppress)
 313 {
 314         if (suppress)
 315                 h_suppress_date = "true";
 316         else
 317                 h_suppress_date = "false";
 318 }
 319
 320
 321 void Preamble::registerAuthor(std::string const & name)
 322 {
 323         Author author(from_utf8(name), empty_docstring());
 324         author.setUsed(true);
 325         authors_.record(author);
 326         h_tracking_changes = "true";
 327         h_output_changes = "true";
 328 }
 329
 330
 331 Author const & Preamble::getAuthor(std::string const & name) const
 332 {
 333         Author author(from_utf8(name), empty_docstring());
 334         for (AuthorList::Authors::const_iterator it = authors_.begin();
 335              it != authors_.end(); it++)
 336                 if (*it == author)
 337                         return *it;
 338         static Author const dummy;
 339         return dummy;
 340 }
 341
 342
 343 void Preamble::add_package(string const & name, vector<string> & options)
 344 {
 345         // every package inherits the global options
 346         if (used_packages.find(name) == used_packages.end())
 347                 used_packages[name] = split_options(h_options);
 348
 349         vector<string> & v = used_packages[name];
 350         v.insert(v.end(), options.begin(), options.end());
 351         if (name == "jurabib") {
 352                 // Don't output the order argument (see the cite command
 353                 // handling code in text.cpp).
 354                 vector<string>::iterator end =
 355                         remove(options.begin(), options.end(), "natbiborder");
 356                 end = remove(options.begin(), end, "jurabiborder");
 357                 options.erase(end, options.end());
 358         }
 359 }
 360
 361
 362 namespace {
 363
 364 // Given is a string like "scaled=0.9", return 0.9 * 100
 365 string const scale_as_percentage(string const & scale)
 366 {
 367         string::size_type pos = scale.find('=');
 368         if (pos != string::npos) {
 369                 string value = scale.substr(pos + 1);
 370                 if (isStrDbl(value))
 371                         return convert<string>(100 * convert<double>(value));
 372         }
 373         // If the input string didn't match our expectations.
 374         // return the default value "100"
 375         return "100";
 376 }
 377
 378
 379 string remove_braces(string const & value)
 380 {
 381         if (value.empty())
 382                 return value;
 383         if (value[0] == '{' && value[value.length()-1] == '}')
 384                 return value.substr(1, value.length()-2);
 385         return value;
 386 }
 387
 388 } // anonymous namespace
 389
 390
 391 Preamble::Preamble() : one_language(true)
 392 {
 393         //h_backgroundcolor;
 394         //h_boxbgcolor;
 395         h_cite_engine             = "basic";
 396         h_defskip                 = "medskip";
 397         //h_float_placement;
 398         //h_fontcolor;
 399         h_fontencoding            = "default";
 400         h_font_roman              = "default";
 401         h_font_sans               = "default";
 402         h_font_typewriter         = "default";
 403         h_font_default_family     = "default";
 404         h_font_sc                 = "false";
 405         h_font_osf                = "false";
 406         h_font_sf_scale           = "100";
 407         h_font_tt_scale           = "100";
 408         h_graphics                = "default";
 409         h_html_be_strict          = "false";
 410         h_html_css_as_file        = "0";
 411         h_html_math_output        = "0";
 412         h_inputencoding           = "auto";
 413         h_language                = "english";
 414         h_language_package        = "none";
 415         //h_listings_params;
 416         //h_margins;
 417         //h_notefontcolor;
 418         //h_options;
 419         h_output_changes          = "false";
 420         h_papercolumns            = "1";
 421         h_paperfontsize           = "default";
 422         h_paperorientation        = "portrait";
 423         h_paperpagestyle          = "default";
 424         //h_papersides;
 425         h_papersize               = "default";
 426         h_paragraph_indentation   = "default";
 427         h_paragraph_separation    = "indent";
 428         //h_pdf_title;
 429         //h_pdf_author;
 430         //h_pdf_subject;
 431         //h_pdf_keywords;
 432         h_pdf_bookmarks           = "1";
 433         h_pdf_bookmarksnumbered   = "0";
 434         h_pdf_bookmarksopen       = "0";
 435         h_pdf_bookmarksopenlevel  = "1";
 436         h_pdf_breaklinks          = "0";
 437         h_pdf_pdfborder           = "0";
 438         h_pdf_colorlinks          = "0";
 439         h_pdf_backref             = "section";
 440         h_pdf_pdfusetitle         = "1";
 441         //h_pdf_pagemode;
 442         //h_pdf_quoted_options;
 443         h_quotes_language         = "english";
 444         h_secnumdepth             = "3";
 445         h_spacing                 = "single";
 446         h_suppress_date           = "false";
 447         h_textclass               = "article";
 448         h_tocdepth                = "3";
 449         h_tracking_changes        = "false";
 450         h_use_bibtopic            = "false";
 451         h_use_indices             = "false";
 452         h_use_geometry            = "false";
 453         h_use_amsmath             = "1";
 454         h_use_default_options     = "false";
 455         h_use_esint               = "1";
 456         h_use_hyperref            = "0";
 457         h_use_mhchem              = "0";
 458         h_use_mathdots            = "0";
 459         h_use_refstyle            = "0";
 460         h_use_undertilde          = "0";
 461 }
 462
 463
 464 void Preamble::handle_hyperref(vector<string> & options)
 465 {
 466         // FIXME swallow inputencoding changes that might surround the
 467         //       hyperref setup if it was written by LyX
 468         h_use_hyperref = "1";
 469         // swallow "unicode=true", since LyX does always write that
 470         vector<string>::iterator it =
 471                 find(options.begin(), options.end(), "unicode=true");
 472         if (it != options.end())
 473                 options.erase(it);
 474         it = find(options.begin(), options.end(), "pdfusetitle");
 475         if (it != options.end()) {
 476                 h_pdf_pdfusetitle = "1";
 477                 options.erase(it);
 478         }
 479         string bookmarks = process_keyval_opt(options, "bookmarks");
 480         if (bookmarks == "true")
 481                 h_pdf_bookmarks = "1";
 482         else if (bookmarks == "false")
 483                 h_pdf_bookmarks = "0";
 484         if (h_pdf_bookmarks == "1") {
 485                 string bookmarksnumbered =
 486                         process_keyval_opt(options, "bookmarksnumbered");
 487                 if (bookmarksnumbered == "true")
 488                         h_pdf_bookmarksnumbered = "1";
 489                 else if (bookmarksnumbered == "false")
 490                         h_pdf_bookmarksnumbered = "0";
 491                 string bookmarksopen =
 492                         process_keyval_opt(options, "bookmarksopen");
 493                 if (bookmarksopen == "true")
 494                         h_pdf_bookmarksopen = "1";
 495                 else if (bookmarksopen == "false")
 496                         h_pdf_bookmarksopen = "0";
 497                 if (h_pdf_bookmarksopen == "1") {
 498                         string bookmarksopenlevel =
 499                                 process_keyval_opt(options, "bookmarksopenlevel");
 500                         if (!bookmarksopenlevel.empty())
 501                                 h_pdf_bookmarksopenlevel = bookmarksopenlevel;
 502                 }
 503         }
 504         string breaklinks = process_keyval_opt(options, "breaklinks");
 505         if (breaklinks == "true")
 506                 h_pdf_breaklinks = "1";
 507         else if (breaklinks == "false")
 508                 h_pdf_breaklinks = "0";
 509         string pdfborder = process_keyval_opt(options, "pdfborder");
 510         if (pdfborder == "{0 0 0}")
 511                 h_pdf_pdfborder = "1";
 512         else if (pdfborder == "{0 0 1}")
 513                 h_pdf_pdfborder = "0";
 514         string backref = process_keyval_opt(options, "backref");
 515         if (!backref.empty())
 516                 h_pdf_backref = backref;
 517         string colorlinks = process_keyval_opt(options, "colorlinks");
 518         if (colorlinks == "true")
 519                 h_pdf_colorlinks = "1";
 520         else if (colorlinks == "false")
 521                 h_pdf_colorlinks = "0";
 522         string pdfpagemode = process_keyval_opt(options, "pdfpagemode");
 523         if (!pdfpagemode.empty())
 524                 h_pdf_pagemode = pdfpagemode;
 525         string pdftitle = process_keyval_opt(options, "pdftitle");
 526         if (!pdftitle.empty()) {
 527                 h_pdf_title = remove_braces(pdftitle);
 528         }
 529         string pdfauthor = process_keyval_opt(options, "pdfauthor");
 530         if (!pdfauthor.empty()) {
 531                 h_pdf_author = remove_braces(pdfauthor);
 532         }
 533         string pdfsubject = process_keyval_opt(options, "pdfsubject");
 534         if (!pdfsubject.empty())
 535                 h_pdf_subject = remove_braces(pdfsubject);
 536         string pdfkeywords = process_keyval_opt(options, "pdfkeywords");
 537         if (!pdfkeywords.empty())
 538                 h_pdf_keywords = remove_braces(pdfkeywords);
 539         if (!options.empty()) {
 540                 if (!h_pdf_quoted_options.empty())
 541                         h_pdf_quoted_options += ',';
 542                 h_pdf_quoted_options += join(options, ",");
 543                 options.clear();
 544         }
 545 }
 546
 547
 548 void Preamble::handle_geometry(vector<string> & options)
 549 {
 550         h_use_geometry = "true";
 551         vector<string>::iterator it;
 552         // paper orientation
 553         if ((it = find(options.begin(), options.end(), "landscape")) != options.end()) {
 554                 h_paperorientation = "landscape";
 555                 options.erase(it);
 556         }
 557         // paper size
 558         // keyval version: "paper=letter"
 559         string paper = process_keyval_opt(options, "paper");
 560         if (!paper.empty())
 561                 h_papersize = paper + "paper";
 562         // alternative version: "letterpaper"
 563         handle_opt(options, known_paper_sizes, h_papersize);
 564         delete_opt(options, known_paper_sizes);
 565         // page margins
 566         char const * const * margin = known_paper_margins;
 567         for (; *margin; ++margin) {
 568                 string value = process_keyval_opt(options, *margin);
 569                 if (!value.empty()) {
 570                         int k = margin - known_paper_margins;
 571                         string name = known_coded_paper_margins[k];
 572                         h_margins += '\\' + name + ' ' + value + '\n';
 573                 }
 574         }
 575 }
 576
 577
 578 void Preamble::handle_package(Parser &p, string const & name,
 579                               string const & opts, bool in_lyx_preamble)
 580 {
 581         vector<string> options = split_options(opts);
 582         add_package(name, options);
 583         string scale;
 584
 585         if (is_known(name, known_xetex_packages))
 586                 xetex = true;
 587
 588         // roman fonts
 589         if (is_known(name, known_roman_fonts)) {
 590                 h_font_roman = name;
 591                 p.skip_spaces();
 592         }
 593
 594         if (name == "fourier") {
 595                 h_font_roman = "utopia";
 596                 // when font uses real small capitals
 597                 if (opts == "expert")
 598                         h_font_sc = "true";
 599         }
 600
 601         if (name == "mathpazo")
 602                 h_font_roman = "palatino";
 603
 604         if (name == "mathptmx")
 605                 h_font_roman = "times";
 606
 607         // sansserif fonts
 608         if (is_known(name, known_sans_fonts)) {
 609                 h_font_sans = name;
 610                 if (!opts.empty()) {
 611                         scale = opts;
 612                         h_font_sf_scale = scale_as_percentage(scale);
 613                 }
 614         }
 615
 616         // typewriter fonts
 617         if (is_known(name, known_typewriter_fonts)) {
 618                 // fourier can be set as roman font _only_
 619                 // fourier as typewriter is handled in handling of \ttdefault
 620                 if (name != "fourier") {
 621                         h_font_typewriter = name;
 622                         if (!opts.empty()) {
 623                                 scale = opts;
 624                                 h_font_tt_scale = scale_as_percentage(scale);
 625                         }
 626                 }
 627         }
 628
 629         // font uses old-style figure
 630         if (name == "eco")
 631                 h_font_osf = "true";
 632
 633         // after the detection and handling of special cases, we can remove the
 634         // fonts, otherwise they would appear in the preamble, see bug #7856
 635         if (is_known(name, known_roman_fonts) || is_known(name, known_sans_fonts)
 636                 ||      is_known(name, known_typewriter_fonts))
 637                 ;
 638
 639         else if (name == "amsmath" || name == "amssymb")
 640                 h_use_amsmath = "2";
 641
 642         else if (name == "esint")
 643                 h_use_esint = "2";
 644
 645         else if (name == "mhchem")
 646                 h_use_mhchem = "2";
 647
 648         else if (name == "mathdots")
 649                 h_use_mathdots = "2";
 650
 651         else if (name == "undertilde")
 652                 h_use_undertilde = "2";
 653
 654         else if (name == "babel") {
 655                 h_language_package = "default";
 656                 // One might think we would have to do nothing if babel is loaded
 657                 // without any options to prevent pollution of the preamble with this
 658                 // babel call in every roundtrip.
 659                 // But the user could have defined babel-specific things afterwards. So
 660                 // we need to keep it in the preamble to prevent cases like bug #7861.
 661                 if (!opts.empty()) {
 662                         // check if more than one option was used - used later for inputenc
 663                         if (options.begin() != options.end() - 1)
 664                                 one_language = false;
 665                         // babel takes the last language of the option of its \usepackage
 666                         // call as document language. If there is no such language option, the
 667                         // last language in the documentclass options is used.
 668                         handle_opt(options, known_languages, h_language);
 669                         // If babel is called with options, LyX puts them by default into the
 670                         // document class options. This works for most languages, except
 671                         // for Latvian, Lithuanian, Mongolian, Turkmen and Vietnamese and
 672                         // perhaps in future others.
 673                         // Therefore keep the babel call as it is as the user might have
 674                         // reasons for it.
 675                         h_preamble << "\\usepackage[" << opts << "]{babel}\n";
 676                         delete_opt(options, known_languages);
 677                 }
 678                 else
 679                         h_preamble << "\\usepackage{babel}\n";
 680         }
 681
 682         else if (name == "fontenc") {
 683                 h_fontencoding = getStringFromVector(options, ",");
 684                 /* We could do the following for better round trip support,
 685                  * but this makes the document less portable, so I skip it:
 686                 if (h_fontencoding == lyxrc.fontenc)
 687                         h_fontencoding = "global";
 688                  */
 689                 options.clear();
 690         }
 691
 692         else if (name == "inputenc" || name == "luainputenc") {
 693                 // h_inputencoding is only set when there is not more than one
 694                 // inputenc option because otherwise h_inputencoding must be
 695                 // set to "auto" (the default encoding of the document language)
 696                 // Therefore check for the "," character.
 697                 // It is also only set when there is not more than one babel
 698                 // language option.
 699                 if (opts.find(",") == string::npos && one_language == true)
 700                         h_inputencoding = opts;
 701                 if (!options.empty())
 702                         p.setEncoding(options.back());
 703                 options.clear();
 704         }
 705
 706         else if (is_known(name, known_old_language_packages)) {
 707                 // known language packages from the times before babel
 708                 // if they are found and not also babel, they will be used as
 709                 // custom language package
 710                 h_language_package = "\\usepackage{" + name + "}";
 711         }
 712
 713         else if (name == "prettyref")
 714                 ; // ignore this FIXME: Use the package separator mechanism instead
 715
 716         else if (name == "varioref")
 717                 ; // ignore this FIXME: Use the package separator mechanism instead
 718
 719         else if (name == "verbatim")
 720                 ; // ignore this FIXME: Use the package separator mechanism instead
 721
 722         else if (name == "textcomp")
 723                 ; // ignore this FIXME: Use the package separator mechanism instead
 724
 725         else if (name == "pdfpages")
 726                 ; // ignore this
 727
 728         else if (name == "lyxskak") {
 729                 // ignore this and its options
 730                 if (!options.empty())
 731                         options.clear();
 732         }
 733
 734         else if (name == "array" || name == "booktabs" || name == "calc" ||
 735                      name == "color" || name == "hhline" || name == "ifthen" ||
 736                      name == "float" || name == "longtable" || name == "makeidx" ||
 737                      name == "multirow" || name == "nomencl" || name == "setspace" ||
 738                      name == "splitidx" || name == "subscript" || name == "ulem" ||
 739                      name == "url") {
 740                 if (!in_lyx_preamble)
 741                         h_preamble << package_beg_sep << name
 742                                    << package_mid_sep << "\\usepackage{"
 743                                    << name << '}' << package_end_sep;
 744         }
 745
 746         else if (name == "graphicx")
 747                 ; // ignore this FIXME: Use the package separator mechanism instead
 748
 749         else if (name == "geometry")
 750                 handle_geometry(options);
 751
 752         else if (name == "rotfloat")
 753                 ; // ignore this FIXME: Use the package separator mechanism instead
 754
 755         else if (name == "wrapfig")
 756                 ; // ignore this FIXME: Use the package separator mechanism instead
 757
 758         else if (name == "subfig")
 759                 ; // ignore this FIXME: Use the package separator mechanism instead
 760
 761         else if (is_known(name, known_languages))
 762                 h_language = name;
 763
 764         else if (name == "natbib") {
 765                 h_cite_engine = "natbib_authoryear";
 766                 vector<string>::iterator it =
 767                         find(options.begin(), options.end(), "authoryear");
 768                 if (it != options.end())
 769                         options.erase(it);
 770                 else {
 771                         it = find(options.begin(), options.end(), "numbers");
 772                         if (it != options.end()) {
 773                                 h_cite_engine = "natbib_numerical";
 774                                 options.erase(it);
 775                         }
 776                 }
 777         }
 778
 779         else if (name == "jurabib")
 780                 h_cite_engine = "jurabib";
 781
 782         else if (name == "hyperref")
 783                 handle_hyperref(options);
 784
 785         else if (!in_lyx_preamble) {
 786                 if (options.empty())
 787                         h_preamble << "\\usepackage{" << name << "}";
 788                 else {
 789                         h_preamble << "\\usepackage[" << opts << "]{"
 790                                    << name << "}";
 791                         options.clear();
 792                 }
 793         }
 794
 795         // We need to do something with the options...
 796         if (!options.empty())
 797                 cerr << "Ignoring options '" << join(options, ",")
 798                      << "' of package " << name << '.' << endl;
 799
 800         // remove the whitespace
 801         p.skip_spaces();
 802 }
 803
 804
 805 void Preamble::handle_if(Parser & p, bool in_lyx_preamble)
 806 {
 807         while (p.good()) {
 808                 Token t = p.get_token();
 809                 if (t.cat() == catEscape &&
 810                     is_known(t.cs(), known_if_commands))
 811                         handle_if(p, in_lyx_preamble);
 812                 else {
 813                         if (!in_lyx_preamble)
 814                                 h_preamble << t.asInput();
 815                         if (t.cat() == catEscape && t.cs() == "fi")
 816                                 return;
 817                 }
 818         }
 819 }
 820
 821
 822 bool Preamble::writeLyXHeader(ostream & os, bool subdoc)
 823 {
 824         // translate from babel to LyX names
 825         h_language = babel2lyx(h_language);
 826
 827         // set the quote language
 828         // LyX only knows the following quotes languages:
 829         // english, swedish, german, polish, french and danish
 830         // (quotes for "japanese" and "chinese-traditional" are missing because
 831         //  they wouldn't be useful: http://www.lyx.org/trac/ticket/6383)
 832         // conversion list taken from
 833         // http://en.wikipedia.org/wiki/Quotation_mark,_non-English_usage
 834         // (quotes for kazakh and interlingua are unknown)
 835         // danish
 836         if (h_language == "danish")
 837                 h_quotes_language = "danish";
 838         // french
 839         else if (is_known(h_language, known_french_quotes_languages))
 840                 h_quotes_language = "french";
 841         // german
 842         else if (is_known(h_language, known_german_quotes_languages))
 843                 h_quotes_language = "german";
 844         // polish
 845         else if (is_known(h_language, known_polish_quotes_languages))
 846                 h_quotes_language = "polish";
 847         // swedish
 848         else if (is_known(h_language, known_swedish_quotes_languages))
 849                 h_quotes_language = "swedish";
 850         //english
 851         else if (is_known(h_language, known_english_quotes_languages))
 852                 h_quotes_language = "english";
 853
 854         if (contains(h_float_placement, "H"))
 855                 registerAutomaticallyLoadedPackage("float");
 856         if (h_spacing != "single" && h_spacing != "default")
 857                 registerAutomaticallyLoadedPackage("setspace");
 858
 859         // output the LyX file settings
 860         os << "#LyX file created by tex2lyx " << PACKAGE_VERSION << "\n"
 861            << "\\lyxformat " << LYX_FORMAT << '\n'
 862            << "\\begin_document\n"
 863            << "\\begin_header\n"
 864            << "\\textclass " << h_textclass << "\n";
 865         string const raw = subdoc ? empty_string() : h_preamble.str();
 866         if (!raw.empty()) {
 867                 os << "\\begin_preamble\n";
 868                 for (string::size_type i = 0; i < raw.size(); ++i) {
 869                         if (raw[i] == package_beg_sep) {
 870                                 // Here follows some package loading code that
 871                                 // must be skipped if the package is loaded
 872                                 // automatically.
 873                                 string::size_type j = raw.find(package_mid_sep, i);
 874                                 if (j == string::npos)
 875                                         return false;
 876                                 string::size_type k = raw.find(package_end_sep, j);
 877                                 if (k == string::npos)
 878                                         return false;
 879                                 string const package = raw.substr(i + 1, j - i - 1);
 880                                 string const replacement = raw.substr(j + 1, k - j - 1);
 881                                 if (auto_packages.find(package) == auto_packages.end())
 882                                         os << replacement;
 883                                 i = k;
 884                         } else
 885                                 os.put(raw[i]);
 886                 }
 887                 os << "\n\\end_preamble\n";
 888         }
 889         if (!h_options.empty())
 890                 os << "\\options " << h_options << "\n";
 891         os << "\\use_default_options " << h_use_default_options << "\n";
 892         if (!used_modules.empty()) {
 893                 os << "\\begin_modules\n";
 894                 vector<string>::const_iterator const end = used_modules.end();
 895                 vector<string>::const_iterator it = used_modules.begin();
 896                 for (; it != end; it++)
 897                         os << *it << '\n';
 898                 os << "\\end_modules\n";
 899         }
 900         os << "\\language " << h_language << "\n"
 901            << "\\language_package " << h_language_package << "\n"
 902            << "\\inputencoding " << h_inputencoding << "\n"
 903            << "\\fontencoding " << h_fontencoding << "\n"
 904            << "\\font_roman " << h_font_roman << "\n"
 905            << "\\font_sans " << h_font_sans << "\n"
 906            << "\\font_typewriter " << h_font_typewriter << "\n"
 907            << "\\font_default_family " << h_font_default_family << "\n"
 908            << "\\font_sc " << h_font_sc << "\n"
 909            << "\\font_osf " << h_font_osf << "\n"
 910            << "\\font_sf_scale " << h_font_sf_scale << "\n"
 911            << "\\font_tt_scale " << h_font_tt_scale << "\n"
 912            << "\\graphics " << h_graphics << "\n";
 913         if (!h_float_placement.empty())
 914                 os << "\\float_placement " << h_float_placement << "\n";
 915         os << "\\paperfontsize " << h_paperfontsize << "\n"
 916            << "\\spacing " << h_spacing << "\n"
 917            << "\\use_hyperref " << h_use_hyperref << '\n';
 918         if (h_use_hyperref == "1") {
 919                 if (!h_pdf_title.empty())
 920                         os << "\\pdf_title \"" << h_pdf_title << "\"\n";
 921                 if (!h_pdf_author.empty())
 922                         os << "\\pdf_author \"" << h_pdf_author << "\"\n";
 923                 if (!h_pdf_subject.empty())
 924                         os << "\\pdf_subject \"" << h_pdf_subject << "\"\n";
 925                 if (!h_pdf_keywords.empty())
 926                         os << "\\pdf_keywords \"" << h_pdf_keywords << "\"\n";
 927                 os << "\\pdf_bookmarks " << h_pdf_bookmarks << "\n"
 928                       "\\pdf_bookmarksnumbered " << h_pdf_bookmarksnumbered << "\n"
 929                       "\\pdf_bookmarksopen " << h_pdf_bookmarksopen << "\n"
 930                       "\\pdf_bookmarksopenlevel " << h_pdf_bookmarksopenlevel << "\n"
 931                       "\\pdf_breaklinks " << h_pdf_breaklinks << "\n"
 932                       "\\pdf_pdfborder " << h_pdf_pdfborder << "\n"
 933                       "\\pdf_colorlinks " << h_pdf_colorlinks << "\n"
 934                       "\\pdf_backref " << h_pdf_backref << "\n"
 935                       "\\pdf_pdfusetitle " << h_pdf_pdfusetitle << '\n';
 936                 if (!h_pdf_pagemode.empty())
 937                         os << "\\pdf_pagemode " << h_pdf_pagemode << '\n';
 938                 if (!h_pdf_quoted_options.empty())
 939                         os << "\\pdf_quoted_options \"" << h_pdf_quoted_options << "\"\n";
 940         }
 941         os << "\\papersize " << h_papersize << "\n"
 942            << "\\use_geometry " << h_use_geometry << "\n"
 943            << "\\use_amsmath " << h_use_amsmath << "\n"
 944            << "\\use_esint " << h_use_esint << "\n"
 945            << "\\use_mhchem " << h_use_mhchem << "\n"
 946            << "\\use_mathdots " << h_use_mathdots << "\n"
 947            << "\\use_undertilde " << h_use_undertilde << "\n"
 948            << "\\cite_engine " << h_cite_engine << "\n"
 949            << "\\use_bibtopic " << h_use_bibtopic << "\n"
 950            << "\\use_indices " << h_use_indices << "\n"
 951            << "\\paperorientation " << h_paperorientation << '\n'
 952            << "\\suppress_date " << h_suppress_date << '\n'
 953            << "\\use_refstyle " << h_use_refstyle << '\n';
 954         if (!h_fontcolor.empty())
 955                 os << "\\fontcolor " << h_fontcolor << '\n';
 956         if (!h_notefontcolor.empty())
 957                 os << "\\notefontcolor " << h_notefontcolor << '\n';
 958         if (!h_backgroundcolor.empty())
 959                 os << "\\backgroundcolor " << h_backgroundcolor << '\n';
 960         if (!h_boxbgcolor.empty())
 961                 os << "\\boxbgcolor " << h_boxbgcolor << '\n';
 962         os << h_margins
 963            << "\\secnumdepth " << h_secnumdepth << "\n"
 964            << "\\tocdepth " << h_tocdepth << "\n"
 965            << "\\paragraph_separation " << h_paragraph_separation << "\n";
 966         if (h_paragraph_separation == "skip")
 967                 os << "\\defskip " << h_defskip << "\n";
 968         else
 969                 os << "\\paragraph_indentation " << h_paragraph_indentation << "\n";
 970         os << "\\quotes_language " << h_quotes_language << "\n"
 971            << "\\papercolumns " << h_papercolumns << "\n"
 972            << "\\papersides " << h_papersides << "\n"
 973            << "\\paperpagestyle " << h_paperpagestyle << "\n";
 974         if (!h_listings_params.empty())
 975                 os << "\\listings_params " << h_listings_params << "\n";
 976         os << "\\tracking_changes " << h_tracking_changes << "\n"
 977            << "\\output_changes " << h_output_changes << "\n"
 978            << "\\html_math_output " << h_html_math_output << "\n"
 979            << "\\html_css_as_file " << h_html_css_as_file << "\n"
 980            << "\\html_be_strict " << h_html_be_strict << "\n"
 981            << authors_
 982            << "\\end_header\n\n"
 983            << "\\begin_body\n";
 984         return true;
 985 }
 986
 987
 988 void Preamble::parse(Parser & p, string const & forceclass,
 989                      TeX2LyXDocClass & tc)
 990 {
 991         // initialize fixed types
 992         special_columns['D'] = 3;
 993         bool is_full_document = false;
 994         bool is_lyx_file = false;
 995         bool in_lyx_preamble = false;
 996
 997         // determine whether this is a full document or a fragment for inclusion
 998         while (p.good()) {
 999                 Token const & t = p.get_token();
1000
1001                 if (t.cat() == catEscape && t.cs() == "documentclass") {
1002                         is_full_document = true;
1003                         break;
1004                 }
1005         }
1006         p.reset();
1007
1008         while (is_full_document && p.good()) {
1009                 Token const & t = p.get_token();
1010
1011 #ifdef FILEDEBUG
1012                 cerr << "t: " << t << "\n";
1013 #endif
1014
1015                 //
1016                 // cat codes
1017                 //
1018                 if (!in_lyx_preamble &&
1019                     (t.cat() == catLetter ||
1020                      t.cat() == catSuper ||
1021                      t.cat() == catSub ||
1022                      t.cat() == catOther ||
1023                      t.cat() == catMath ||
1024                      t.cat() == catActive ||
1025                      t.cat() == catBegin ||
1026                      t.cat() == catEnd ||
1027                      t.cat() == catAlign ||
1028                      t.cat() == catParameter))
1029                         h_preamble << t.cs();
1030
1031                 else if (!in_lyx_preamble &&
1032                          (t.cat() == catSpace || t.cat() == catNewline))
1033                         h_preamble << t.asInput();
1034
1035                 else if (t.cat() == catComment) {
1036                         static regex const islyxfile("%% LyX .* created this file");
1037                         static regex const usercommands("User specified LaTeX commands");
1038
1039                         string const comment = t.asInput();
1040
1041                         // magically switch encoding default if it looks like XeLaTeX
1042                         static string const magicXeLaTeX =
1043                                 "% This document must be compiled with XeLaTeX ";
1044                         if (comment.size() > magicXeLaTeX.size()
1045                                   && comment.substr(0, magicXeLaTeX.size()) == magicXeLaTeX
1046                                   && h_inputencoding == "auto") {
1047                                 cerr << "XeLaTeX comment found, switching to UTF8\n";
1048                                 h_inputencoding = "utf8";
1049                         }
1050                         smatch sub;
1051                         if (regex_search(comment, sub, islyxfile)) {
1052                                 is_lyx_file = true;
1053                                 in_lyx_preamble = true;
1054                         } else if (is_lyx_file
1055                                    && regex_search(comment, sub, usercommands))
1056                                 in_lyx_preamble = false;
1057                         else if (!in_lyx_preamble)
1058                                 h_preamble << t.asInput();
1059                 }
1060
1061                 else if (t.cs() == "pagestyle")
1062                         h_paperpagestyle = p.verbatim_item();
1063
1064                 else if (t.cs() == "date") {
1065                         string argument = p.getArg('{', '}');
1066                         if (argument.empty())
1067                                 h_suppress_date = "true";
1068                         else
1069                                 h_preamble << t.asInput() << '{' << argument << '}';
1070                 }
1071
1072                 else if (t.cs() == "color") {
1073                         string const space =
1074                                 (p.hasOpt() ? p.getOpt() : string());
1075                         string argument = p.getArg('{', '}');
1076                         // check the case that a standard color is used
1077                         if (space.empty() && is_known(argument, known_basic_colors)) {
1078                                 h_fontcolor = rgbcolor2code(argument);
1079                                 preamble.registerAutomaticallyLoadedPackage("color");
1080                         } else if (space.empty() && argument == "document_fontcolor")
1081                                 preamble.registerAutomaticallyLoadedPackage("color");
1082                         // check the case that LyX's document_fontcolor is defined
1083                         // but not used for \color
1084                         else {
1085                                 h_preamble << t.asInput();
1086                                 if (!space.empty())
1087                                         h_preamble << space;
1088                                 h_preamble << '{' << argument << '}';
1089                                 // the color might already be set because \definecolor
1090                                 // is parsed before this
1091                                 h_fontcolor = "";
1092                         }
1093                 }
1094
1095                 else if (t.cs() == "pagecolor") {
1096                         string argument = p.getArg('{', '}');
1097                         // check the case that a standard color is used
1098                         if (is_known(argument, known_basic_colors)) {
1099                                 h_backgroundcolor = rgbcolor2code(argument);
1100                         } else if (argument == "page_backgroundcolor")
1101                                 preamble.registerAutomaticallyLoadedPackage("color");
1102                         // check the case that LyX's page_backgroundcolor is defined
1103                         // but not used for \pagecolor
1104                         else {
1105                                 h_preamble << t.asInput() << '{' << argument << '}';
1106                                 // the color might already be set because \definecolor
1107                                 // is parsed before this
1108                                 h_backgroundcolor = "";
1109                         }
1110                 }
1111
1112                 else if (t.cs() == "makeatletter") {
1113                         // LyX takes care of this
1114                         p.setCatCode('@', catLetter);
1115                 }
1116
1117                 else if (t.cs() == "makeatother") {
1118                         // LyX takes care of this
1119                         p.setCatCode('@', catOther);
1120                 }
1121
1122                 else if (t.cs() == "newcommand" || t.cs() == "newcommandx"
1123                       || t.cs() == "renewcommand" || t.cs() == "renewcommandx"
1124                       || t.cs() == "providecommand" || t.cs() == "providecommandx"
1125                                 || t.cs() == "DeclareRobustCommand"
1126                       || t.cs() == "DeclareRobustCommandx"
1127                                 || t.cs() == "ProvideTextCommandDefault"
1128                                 || t.cs() == "DeclareMathAccent") {
1129                         bool star = false;
1130                         if (p.next_token().character() == '*') {
1131                                 p.get_token();
1132                                 star = true;
1133                         }
1134                         string const name = p.verbatim_item();
1135                         string const opt1 = p.getFullOpt();
1136                         string const opt2 = p.getFullOpt();
1137                         string const body = p.verbatim_item();
1138                         // font settings
1139                         if (name == "\\rmdefault")
1140                                 if (is_known(body, known_roman_fonts))
1141                                         h_font_roman = body;
1142                         if (name == "\\sfdefault")
1143                                 if (is_known(body, known_sans_fonts))
1144                                         h_font_sans = body;
1145                         if (name == "\\ttdefault")
1146                                 if (is_known(body, known_typewriter_fonts))
1147                                         h_font_typewriter = body;
1148                         if (name == "\\familydefault") {
1149                                 string family = body;
1150                                 // remove leading "\"
1151                                 h_font_default_family = family.erase(0,1);
1152                         }
1153
1154                         // remove the lyxdot definition that is re-added by LyX
1155                         // if necessary
1156                         if (name == "\\lyxdot")
1157                                 in_lyx_preamble = true;
1158
1159                         // Add the command to the known commands
1160                         add_known_command(name, opt1, !opt2.empty(), from_utf8(body));
1161
1162                         // only non-lyxspecific stuff
1163                         if (!in_lyx_preamble) {
1164                                 ostringstream ss;
1165                                 ss << '\\' << t.cs();
1166                                 if (star)
1167                                         ss << '*';
1168                                 ss << '{' << name << '}' << opt1 << opt2
1169                                    << '{' << body << "}";
1170                                 h_preamble << ss.str();
1171 /*
1172                                 ostream & out = in_preamble ? h_preamble : os;
1173                                 out << "\\" << t.cs() << "{" << name << "}"
1174                                     << opts << "{" << body << "}";
1175 */
1176                         }
1177                 }
1178
1179                 else if (t.cs() == "documentclass") {
1180                         vector<string>::iterator it;
1181                         vector<string> opts = split_options(p.getArg('[', ']'));
1182                         handle_opt(opts, known_fontsizes, h_paperfontsize);
1183                         delete_opt(opts, known_fontsizes);
1184                         // delete "pt" at the end
1185                         string::size_type i = h_paperfontsize.find("pt");
1186                         if (i != string::npos)
1187                                 h_paperfontsize.erase(i);
1188                         // The documentclass options are always parsed before the options
1189                         // of the babel call so that a language cannot overwrite the babel
1190                         // options.
1191                         handle_opt(opts, known_languages, h_language);
1192                         delete_opt(opts, known_languages);
1193
1194                         // paper orientation
1195                         if ((it = find(opts.begin(), opts.end(), "landscape")) != opts.end()) {
1196                                 h_paperorientation = "landscape";
1197                                 opts.erase(it);
1198                         }
1199                         // paper sides
1200                         if ((it = find(opts.begin(), opts.end(), "oneside"))
1201                                  != opts.end()) {
1202                                 h_papersides = "1";
1203                                 opts.erase(it);
1204                         }
1205                         if ((it = find(opts.begin(), opts.end(), "twoside"))
1206                                  != opts.end()) {
1207                                 h_papersides = "2";
1208                                 opts.erase(it);
1209                         }
1210                         // paper columns
1211                         if ((it = find(opts.begin(), opts.end(), "onecolumn"))
1212                                  != opts.end()) {
1213                                 h_papercolumns = "1";
1214                                 opts.erase(it);
1215                         }
1216                         if ((it = find(opts.begin(), opts.end(), "twocolumn"))
1217                                  != opts.end()) {
1218                                 h_papercolumns = "2";
1219                                 opts.erase(it);
1220                         }
1221                         // paper sizes
1222                         // some size options are known to any document classes, other sizes
1223                         // are handled by the \geometry command of the geometry package
1224                         handle_opt(opts, known_class_paper_sizes, h_papersize);
1225                         delete_opt(opts, known_class_paper_sizes);
1226                         // the remaining options
1227                         h_options = join(opts, ",");
1228                         // FIXME This does not work for classes that have a
1229                         //       different name in LyX than in LaTeX
1230                         h_textclass = p.getArg('{', '}');
1231                 }
1232
1233                 else if (t.cs() == "usepackage") {
1234                         string const options = p.getArg('[', ']');
1235                         string const name = p.getArg('{', '}');
1236                         vector<string> vecnames;
1237                         split(name, vecnames, ',');
1238                         vector<string>::const_iterator it  = vecnames.begin();
1239                         vector<string>::const_iterator end = vecnames.end();
1240                         for (; it != end; ++it)
1241                                 handle_package(p, trimSpaceAndEol(*it), options,
1242                                                in_lyx_preamble);
1243                 }
1244
1245                 else if (t.cs() == "inputencoding") {
1246                         string const encoding = p.getArg('{','}');
1247                         h_inputencoding = encoding;
1248                         p.setEncoding(encoding);
1249                 }
1250
1251                 else if (t.cs() == "newenvironment") {
1252                         string const name = p.getArg('{', '}');
1253                         string const opt1 = p.getFullOpt();
1254                         string const opt2 = p.getFullOpt();
1255                         string const beg = p.verbatim_item();
1256                         string const end = p.verbatim_item();
1257                         if (!in_lyx_preamble) {
1258                                 h_preamble << "\\newenvironment{" << name
1259                                            << '}' << opt1 << opt2 << '{'
1260                                            << beg << "}{" << end << '}';
1261                         }
1262                         add_known_environment(name, opt1, !opt2.empty(),
1263                                               from_utf8(beg), from_utf8(end));
1264
1265                 }
1266
1267                 else if (t.cs() == "def") {
1268                         string name = p.get_token().cs();
1269                         while (p.next_token().cat() != catBegin)
1270                                 name += p.get_token().cs();
1271                         if (!in_lyx_preamble)
1272                                 h_preamble << "\\def\\" << name << '{'
1273                                            << p.verbatim_item() << "}";
1274                 }
1275
1276                 else if (t.cs() == "newcolumntype") {
1277                         string const name = p.getArg('{', '}');
1278                         trimSpaceAndEol(name);
1279                         int nargs = 0;
1280                         string opts = p.getOpt();
1281                         if (!opts.empty()) {
1282                                 istringstream is(string(opts, 1));
1283                                 is >> nargs;
1284                         }
1285                         special_columns[name[0]] = nargs;
1286                         h_preamble << "\\newcolumntype{" << name << "}";
1287                         if (nargs)
1288                                 h_preamble << "[" << nargs << "]";
1289                         h_preamble << "{" << p.verbatim_item() << "}";
1290                 }
1291
1292                 else if (t.cs() == "setcounter") {
1293                         string const name = p.getArg('{', '}');
1294                         string const content = p.getArg('{', '}');
1295                         if (name == "secnumdepth")
1296                                 h_secnumdepth = content;
1297                         else if (name == "tocdepth")
1298                                 h_tocdepth = content;
1299                         else
1300                                 h_preamble << "\\setcounter{" << name << "}{" << content << "}";
1301                 }
1302
1303                 else if (t.cs() == "setlength") {
1304                         string const name = p.verbatim_item();
1305                         string const content = p.verbatim_item();
1306                         // the paragraphs are only not indented when \parindent is set to zero
1307                         if (name == "\\parindent" && content != "") {
1308                                 if (content[0] == '0')
1309                                         h_paragraph_separation = "skip";
1310                                 else
1311                                         h_paragraph_indentation = translate_len(content);
1312                         } else if (name == "\\parskip") {
1313                                 if (content == "\\smallskipamount")
1314                                         h_defskip = "smallskip";
1315                                 else if (content == "\\medskipamount")
1316                                         h_defskip = "medskip";
1317                                 else if (content == "\\bigskipamount")
1318                                         h_defskip = "bigskip";
1319                                 else
1320                                         h_defskip = content;
1321                         } else
1322                                 h_preamble << "\\setlength{" << name << "}{" << content << "}";
1323                 }
1324
1325                 else if (t.cs() == "onehalfspacing")
1326                         h_spacing = "onehalf";
1327
1328                 else if (t.cs() == "doublespacing")
1329                         h_spacing = "double";
1330
1331                 else if (t.cs() == "setstretch")
1332                         h_spacing = "other " + p.verbatim_item();
1333
1334                 else if (t.cs() == "begin") {
1335                         string const name = p.getArg('{', '}');
1336                         if (name == "document")
1337                                 break;
1338                         h_preamble << "\\begin{" << name << "}";
1339                 }
1340
1341                 else if (t.cs() == "geometry") {
1342                         vector<string> opts = split_options(p.getArg('{', '}'));
1343                         handle_geometry(opts);
1344                 }
1345
1346                 else if (t.cs() == "definecolor") {
1347                         string const color = p.getArg('{', '}');
1348                         string const space = p.getArg('{', '}');
1349                         string const value = p.getArg('{', '}');
1350                         if (color == "document_fontcolor" && space == "rgb") {
1351                                 RGBColor c(RGBColorFromLaTeX(value));
1352                                 h_fontcolor = X11hexname(c);
1353                         } else if (color == "note_fontcolor" && space == "rgb") {
1354                                 RGBColor c(RGBColorFromLaTeX(value));
1355                                 h_notefontcolor = X11hexname(c);
1356                         } else if (color == "page_backgroundcolor" && space == "rgb") {
1357                                 RGBColor c(RGBColorFromLaTeX(value));
1358                                 h_backgroundcolor = X11hexname(c);
1359                         } else if (color == "shadecolor" && space == "rgb") {
1360                                 RGBColor c(RGBColorFromLaTeX(value));
1361                                 h_boxbgcolor = X11hexname(c);
1362                         } else {
1363                                 h_preamble << "\\definecolor{" << color
1364                                            << "}{" << space << "}{" << value
1365                                            << '}';
1366                         }
1367                 }
1368
1369                 else if (t.cs() == "jurabibsetup") {
1370                         // FIXME p.getArg('{', '}') is most probably wrong (it
1371                         //       does not handle nested braces).
1372                         //       Use p.verbatim_item() instead.
1373                         vector<string> jurabibsetup =
1374                                 split_options(p.getArg('{', '}'));
1375                         // add jurabibsetup to the jurabib package options
1376                         add_package("jurabib", jurabibsetup);
1377                         if (!jurabibsetup.empty()) {
1378                                 h_preamble << "\\jurabibsetup{"
1379                                            << join(jurabibsetup, ",") << '}';
1380                         }
1381                 }
1382
1383                 else if (t.cs() == "hypersetup") {
1384                         vector<string> hypersetup =
1385                                 split_options(p.verbatim_item());
1386                         // add hypersetup to the hyperref package options
1387                         handle_hyperref(hypersetup);
1388                         if (!hypersetup.empty()) {
1389                                 h_preamble << "\\hypersetup{"
1390                                            << join(hypersetup, ",") << '}';
1391                         }
1392                 }
1393
1394                 else if (is_known(t.cs(), known_if_3arg_commands)) {
1395                         // prevent misparsing of \usepackage if it is used
1396                         // as an argument (see e.g. our own output of
1397                         // \@ifundefined above)
1398                         string const arg1 = p.verbatim_item();
1399                         string const arg2 = p.verbatim_item();
1400                         string const arg3 = p.verbatim_item();
1401                         // test case \@ifundefined{date}{}{\date{}}
1402                         if (t.cs() == "@ifundefined" && arg1 == "date" &&
1403                             arg2.empty() && arg3 == "\\date{}") {
1404                                 h_suppress_date = "true";
1405                         // older tex2lyx versions did output
1406                         // \@ifundefined{definecolor}{\usepackage{color}}{}
1407                         } else if (t.cs() == "@ifundefined" &&
1408                                    arg1 == "definecolor" &&
1409                                    arg2 == "\\usepackage{color}" &&
1410                                    arg3.empty()) {
1411                                 if (!in_lyx_preamble)
1412                                         h_preamble << package_beg_sep
1413                                                    << "color"
1414                                                    << package_mid_sep
1415                                                    << "\\@ifundefined{definecolor}{color}{}"
1416                                                    << package_end_sep;
1417                         // test for case
1418                         //\@ifundefined{showcaptionsetup}{}{%
1419                         // \PassOptionsToPackage{caption=false}{subfig}}
1420                         // that LyX uses for subfloats
1421                         } else if (t.cs() == "@ifundefined" &&
1422                                    arg1 == "showcaptionsetup" && arg2.empty()
1423                                 && arg3 == "%\n \\PassOptionsToPackage{caption=false}{subfig}") {
1424                                 ; // do nothing
1425                         } else if (!in_lyx_preamble) {
1426                                 h_preamble << t.asInput()
1427                                            << '{' << arg1 << '}'
1428                                            << '{' << arg2 << '}'
1429                                            << '{' << arg3 << '}';
1430                         }
1431                 }
1432
1433                 else if (is_known(t.cs(), known_if_commands)) {
1434                         // must not parse anything in conditional code, since
1435                         // LyX would output the parsed contents unconditionally
1436                         if (!in_lyx_preamble)
1437                                 h_preamble << t.asInput();
1438                         handle_if(p, in_lyx_preamble);
1439                 }
1440
1441                 else if (!t.cs().empty() && !in_lyx_preamble)
1442                         h_preamble << '\\' << t.cs();
1443         }
1444
1445         // remove the whitespace
1446         p.skip_spaces();
1447
1448         // Force textclass if the user wanted it
1449         if (!forceclass.empty())
1450                 h_textclass = forceclass;
1451         if (noweb_mode && !prefixIs(h_textclass, "literate-"))
1452                 h_textclass.insert(0, "literate-");
1453         tc.setName(h_textclass);
1454         if (!tc.load()) {
1455                 cerr << "Error: Could not read layout file for textclass \"" << h_textclass << "\"." << endl;
1456                 exit(EXIT_FAILURE);
1457         }
1458         if (h_papersides.empty()) {
1459                 ostringstream ss;
1460                 ss << tc.sides();
1461                 h_papersides = ss.str();
1462         }
1463 }
1464
1465
1466 string babel2lyx(string const & language)
1467 {
1468         char const * const * where = is_known(language, known_languages);
1469         if (where)
1470                 return known_coded_languages[where - known_languages];
1471         return language;
1472 }
1473
1474
1475 string rgbcolor2code(string const & name)
1476 {
1477         char const * const * where = is_known(name, known_basic_colors);
1478         if (where) {
1479                 // "red", "green" etc
1480                 return known_basic_color_codes[where - known_basic_colors];
1481         }
1482         // "255,0,0", "0,255,0" etc
1483         RGBColor c(RGBColorFromLaTeX(name));
1484         return X11hexname(c);
1485 }
1486
1487 // }])
1488
1489
1490 } // namespace lyx