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_geometry            = "false";
 452         h_use_amsmath             = "1";
 453         h_use_default_options     = "false";
 454         h_use_esint               = "1";
 455         h_use_hyperref            = "0";
 456         h_use_mhchem              = "0";
 457         h_use_mathdots            = "0";
 458         h_use_refstyle            = "0";
 459         h_use_undertilde          = "0";
 460 }
 461
 462
 463 void Preamble::handle_hyperref(vector<string> & options)
 464 {
 465         // FIXME swallow inputencoding changes that might surround the
 466         //       hyperref setup if it was written by LyX
 467         h_use_hyperref = "1";
 468         // swallow "unicode=true", since LyX does always write that
 469         vector<string>::iterator it =
 470                 find(options.begin(), options.end(), "unicode=true");
 471         if (it != options.end())
 472                 options.erase(it);
 473         it = find(options.begin(), options.end(), "pdfusetitle");
 474         if (it != options.end()) {
 475                 h_pdf_pdfusetitle = "1";
 476                 options.erase(it);
 477         }
 478         string bookmarks = process_keyval_opt(options, "bookmarks");
 479         if (bookmarks == "true")
 480                 h_pdf_bookmarks = "1";
 481         else if (bookmarks == "false")
 482                 h_pdf_bookmarks = "0";
 483         if (h_pdf_bookmarks == "1") {
 484                 string bookmarksnumbered =
 485                         process_keyval_opt(options, "bookmarksnumbered");
 486                 if (bookmarksnumbered == "true")
 487                         h_pdf_bookmarksnumbered = "1";
 488                 else if (bookmarksnumbered == "false")
 489                         h_pdf_bookmarksnumbered = "0";
 490                 string bookmarksopen =
 491                         process_keyval_opt(options, "bookmarksopen");
 492                 if (bookmarksopen == "true")
 493                         h_pdf_bookmarksopen = "1";
 494                 else if (bookmarksopen == "false")
 495                         h_pdf_bookmarksopen = "0";
 496                 if (h_pdf_bookmarksopen == "1") {
 497                         string bookmarksopenlevel =
 498                                 process_keyval_opt(options, "bookmarksopenlevel");
 499                         if (!bookmarksopenlevel.empty())
 500                                 h_pdf_bookmarksopenlevel = bookmarksopenlevel;
 501                 }
 502         }
 503         string breaklinks = process_keyval_opt(options, "breaklinks");
 504         if (breaklinks == "true")
 505                 h_pdf_breaklinks = "1";
 506         else if (breaklinks == "false")
 507                 h_pdf_breaklinks = "0";
 508         string pdfborder = process_keyval_opt(options, "pdfborder");
 509         if (pdfborder == "{0 0 0}")
 510                 h_pdf_pdfborder = "1";
 511         else if (pdfborder == "{0 0 1}")
 512                 h_pdf_pdfborder = "0";
 513         string backref = process_keyval_opt(options, "backref");
 514         if (!backref.empty())
 515                 h_pdf_backref = backref;
 516         string colorlinks = process_keyval_opt(options, "colorlinks");
 517         if (colorlinks == "true")
 518                 h_pdf_colorlinks = "1";
 519         else if (colorlinks == "false")
 520                 h_pdf_colorlinks = "0";
 521         string pdfpagemode = process_keyval_opt(options, "pdfpagemode");
 522         if (!pdfpagemode.empty())
 523                 h_pdf_pagemode = pdfpagemode;
 524         string pdftitle = process_keyval_opt(options, "pdftitle");
 525         if (!pdftitle.empty()) {
 526                 h_pdf_title = remove_braces(pdftitle);
 527         }
 528         string pdfauthor = process_keyval_opt(options, "pdfauthor");
 529         if (!pdfauthor.empty()) {
 530                 h_pdf_author = remove_braces(pdfauthor);
 531         }
 532         string pdfsubject = process_keyval_opt(options, "pdfsubject");
 533         if (!pdfsubject.empty())
 534                 h_pdf_subject = remove_braces(pdfsubject);
 535         string pdfkeywords = process_keyval_opt(options, "pdfkeywords");
 536         if (!pdfkeywords.empty())
 537                 h_pdf_keywords = remove_braces(pdfkeywords);
 538         if (!options.empty()) {
 539                 if (!h_pdf_quoted_options.empty())
 540                         h_pdf_quoted_options += ',';
 541                 h_pdf_quoted_options += join(options, ",");
 542                 options.clear();
 543         }
 544 }
 545
 546
 547 void Preamble::handle_geometry(vector<string> & options)
 548 {
 549         h_use_geometry = "true";
 550         vector<string>::iterator it;
 551         // paper orientation
 552         if ((it = find(options.begin(), options.end(), "landscape")) != options.end()) {
 553                 h_paperorientation = "landscape";
 554                 options.erase(it);
 555         }
 556         // paper size
 557         // keyval version: "paper=letter"
 558         string paper = process_keyval_opt(options, "paper");
 559         if (!paper.empty())
 560                 h_papersize = paper + "paper";
 561         // alternative version: "letterpaper"
 562         handle_opt(options, known_paper_sizes, h_papersize);
 563         delete_opt(options, known_paper_sizes);
 564         // page margins
 565         char const * const * margin = known_paper_margins;
 566         for (; *margin; ++margin) {
 567                 string value = process_keyval_opt(options, *margin);
 568                 if (!value.empty()) {
 569                         int k = margin - known_paper_margins;
 570                         string name = known_coded_paper_margins[k];
 571                         h_margins += '\\' + name + ' ' + value + '\n';
 572                 }
 573         }
 574 }
 575
 576
 577 void Preamble::handle_package(Parser &p, string const & name,
 578                               string const & opts, bool in_lyx_preamble)
 579 {
 580         vector<string> options = split_options(opts);
 581         add_package(name, options);
 582         string scale;
 583
 584         if (is_known(name, known_xetex_packages))
 585                 xetex = true;
 586
 587         // roman fonts
 588         if (is_known(name, known_roman_fonts)) {
 589                 h_font_roman = name;
 590                 p.skip_spaces();
 591         }
 592
 593         if (name == "fourier") {
 594                 h_font_roman = "utopia";
 595                 // when font uses real small capitals
 596                 if (opts == "expert")
 597                         h_font_sc = "true";
 598         }
 599
 600         if (name == "mathpazo")
 601                 h_font_roman = "palatino";
 602
 603         if (name == "mathptmx")
 604                 h_font_roman = "times";
 605
 606         // sansserif fonts
 607         if (is_known(name, known_sans_fonts)) {
 608                 h_font_sans = name;
 609                 if (!opts.empty()) {
 610                         scale = opts;
 611                         h_font_sf_scale = scale_as_percentage(scale);
 612                 }
 613         }
 614
 615         // typewriter fonts
 616         if (is_known(name, known_typewriter_fonts)) {
 617                 // fourier can be set as roman font _only_
 618                 // fourier as typewriter is handled in handling of \ttdefault
 619                 if (name != "fourier") {
 620                         h_font_typewriter = name;
 621                         if (!opts.empty()) {
 622                                 scale = opts;
 623                                 h_font_tt_scale = scale_as_percentage(scale);
 624                         }
 625                 }
 626         }
 627
 628         // font uses old-style figure
 629         if (name == "eco")
 630                 h_font_osf = "true";
 631
 632         // after the detection and handling of special cases, we can remove the
 633         // fonts, otherwise they would appear in the preamble, see bug #7856
 634         if (is_known(name, known_roman_fonts) || is_known(name, known_sans_fonts)
 635                 ||      is_known(name, known_typewriter_fonts))
 636                 ;
 637
 638         else if (name == "amsmath" || name == "amssymb")
 639                 h_use_amsmath = "2";
 640
 641         else if (name == "esint")
 642                 h_use_esint = "2";
 643
 644         else if (name == "mhchem")
 645                 h_use_mhchem = "2";
 646
 647         else if (name == "mathdots")
 648                 h_use_mathdots = "2";
 649
 650         else if (name == "undertilde")
 651                 h_use_undertilde = "2";
 652
 653         else if (name == "babel") {
 654                 h_language_package = "default";
 655                 // One might think we would have to do nothing if babel is loaded
 656                 // without any options to prevent pollution of the preamble with this
 657                 // babel call in every roundtrip.
 658                 // But the user could have defined babel-specific things afterwards. So
 659                 // we need to keep it in the preamble to prevent cases like bug #7861.
 660                 if (!opts.empty()) {
 661                         // check if more than one option was used - used later for inputenc
 662                         if (options.begin() != options.end() - 1)
 663                                 one_language = false;
 664                         // babel takes the last language of the option of its \usepackage
 665                         // call as document language. If there is no such language option, the
 666                         // last language in the documentclass options is used.
 667                         handle_opt(options, known_languages, h_language);
 668                         // If babel is called with options, LyX puts them by default into the
 669                         // document class options. This works for most languages, except
 670                         // for Latvian, Lithuanian, Mongolian, Turkmen and Vietnamese and
 671                         // perhaps in future others.
 672                         // Therefore keep the babel call as it is as the user might have
 673                         // reasons for it.
 674                         h_preamble << "\\usepackage[" << opts << "]{babel}\n";
 675                         delete_opt(options, known_languages);
 676                 }
 677                 else
 678                         h_preamble << "\\usepackage{babel}\n";
 679         }
 680
 681         else if (name == "fontenc") {
 682                 h_fontencoding = getStringFromVector(options, ",");
 683                 /* We could do the following for better round trip support,
 684                  * but this makes the document less portable, so I skip it:
 685                 if (h_fontencoding == lyxrc.fontenc)
 686                         h_fontencoding = "global";
 687                  */
 688                 options.clear();
 689         }
 690
 691         else if (name == "inputenc" || name == "luainputenc") {
 692                 // h_inputencoding is only set when there is not more than one
 693                 // inputenc option because otherwise h_inputencoding must be
 694                 // set to "auto" (the default encoding of the document language)
 695                 // Therefore check for the "," character.
 696                 // It is also only set when there is not more than one babel
 697                 // language option.
 698                 if (opts.find(",") == string::npos && one_language == true)
 699                         h_inputencoding = opts;
 700                 if (!options.empty())
 701                         p.setEncoding(options.back());
 702                 options.clear();
 703         }
 704
 705         else if (is_known(name, known_old_language_packages)) {
 706                 // known language packages from the times before babel
 707                 // if they are found and not also babel, they will be used as
 708                 // cutom language package
 709                 h_language_package = "\\usepackage{" + name + "}";
 710         }
 711
 712         else if (name == "makeidx")
 713                 ; // ignore this
 714
 715         else if (name == "prettyref")
 716                 ; // ignore this
 717
 718         else if (name == "varioref")
 719                 ; // ignore this
 720
 721         else if (name == "verbatim")
 722                 ; // ignore this
 723
 724         else if (name == "nomencl")
 725                 ; // ignore this
 726
 727         else if (name == "textcomp")
 728                 ; // ignore this
 729
 730         else if (name == "lyxskak") {
 731                 // ignore this and its options
 732                 if (!options.empty())
 733                         options.clear();
 734         }
 735
 736         else if (name == "url")
 737                 ; // ignore this
 738
 739         else if (name == "array" || name == "booktabs" ||
 740                          name == "color" || name == "hhline" ||
 741                          name == "longtable" || name == "subscript" ||
 742                          name == "ulem") {
 743                 if (!in_lyx_preamble)
 744                         h_preamble << package_beg_sep << name
 745                                    << package_mid_sep << "\\usepackage{"
 746                                    << name << '}' << package_end_sep;
 747         }
 748
 749         else if (name == "graphicx")
 750                 ; // ignore this
 751
 752         else if (name == "setspace")
 753                 ; // ignore this
 754
 755         else if (name == "geometry")
 756                 handle_geometry(options);
 757
 758         else if (name == "rotfloat")
 759                 ; // ignore this
 760
 761         else if (name == "wrapfig")
 762                 ; // ignore this
 763
 764         else if (name == "subfig")
 765                 ; // ignore this
 766
 767         else if (is_known(name, known_languages))
 768                 h_language = name;
 769
 770         else if (name == "natbib") {
 771                 h_cite_engine = "natbib_authoryear";
 772                 vector<string>::iterator it =
 773                         find(options.begin(), options.end(), "authoryear");
 774                 if (it != options.end())
 775                         options.erase(it);
 776                 else {
 777                         it = find(options.begin(), options.end(), "numbers");
 778                         if (it != options.end()) {
 779                                 h_cite_engine = "natbib_numerical";
 780                                 options.erase(it);
 781                         }
 782                 }
 783         }
 784
 785         else if (name == "jurabib")
 786                 h_cite_engine = "jurabib";
 787
 788         else if (name == "hyperref")
 789                 handle_hyperref(options);
 790
 791         else if (!in_lyx_preamble) {
 792                 if (options.empty())
 793                         h_preamble << "\\usepackage{" << name << "}";
 794                 else {
 795                         h_preamble << "\\usepackage[" << opts << "]{"
 796                                    << name << "}";
 797                         options.clear();
 798                 }
 799         }
 800
 801         // We need to do something with the options...
 802         if (!options.empty())
 803                 cerr << "Ignoring options '" << join(options, ",")
 804                      << "' of package " << name << '.' << endl;
 805
 806         // remove the whitespace
 807         p.skip_spaces();
 808 }
 809
 810
 811 void Preamble::handle_if(Parser & p, bool in_lyx_preamble)
 812 {
 813         while (p.good()) {
 814                 Token t = p.get_token();
 815                 if (t.cat() == catEscape &&
 816                     is_known(t.cs(), known_if_commands))
 817                         handle_if(p, in_lyx_preamble);
 818                 else {
 819                         if (!in_lyx_preamble)
 820                                 h_preamble << t.asInput();
 821                         if (t.cat() == catEscape && t.cs() == "fi")
 822                                 return;
 823                 }
 824         }
 825 }
 826
 827
 828 bool Preamble::writeLyXHeader(ostream & os)
 829 {
 830         // translate from babel to LyX names
 831         h_language = babel2lyx(h_language);
 832
 833         // set the quote language
 834         // LyX only knows the following quotes languages:
 835         // english, swedish, german, polish, french and danish
 836         // (quotes for "japanese" and "chinese-traditional" are missing because
 837         //  they wouldn't be useful: http://www.lyx.org/trac/ticket/6383)
 838         // conversion list taken from
 839         // http://en.wikipedia.org/wiki/Quotation_mark,_non-English_usage
 840         // (quotes for kazakh and interlingua are unknown)
 841         // danish
 842         if (h_language == "danish")
 843                 h_quotes_language = "danish";
 844         // french
 845         else if (is_known(h_language, known_french_quotes_languages))
 846                 h_quotes_language = "french";
 847         // german
 848         else if (is_known(h_language, known_german_quotes_languages))
 849                 h_quotes_language = "german";
 850         // polish
 851         else if (is_known(h_language, known_polish_quotes_languages))
 852                 h_quotes_language = "polish";
 853         // swedish
 854         else if (is_known(h_language, known_swedish_quotes_languages))
 855                 h_quotes_language = "swedish";
 856         //english
 857         else if (is_known(h_language, known_english_quotes_languages))
 858                 h_quotes_language = "english";
 859
 860         // output the LyX file settings
 861         os << "#LyX file created by tex2lyx " << PACKAGE_VERSION << "\n"
 862            << "\\lyxformat " << LYX_FORMAT << '\n'
 863            << "\\begin_document\n"
 864            << "\\begin_header\n"
 865            << "\\textclass " << h_textclass << "\n";
 866         string const raw = h_preamble.str();
 867         if (!raw.empty()) {
 868                 os << "\\begin_preamble\n";
 869                 for (string::size_type i = 0; i < raw.size(); ++i) {
 870                         if (raw[i] == package_beg_sep) {
 871                                 // Here follows some package loading code that
 872                                 // must be skipped if the package is loaded
 873                                 // automatically.
 874                                 string::size_type j = raw.find(package_mid_sep, i);
 875                                 if (j == string::npos)
 876                                         return false;
 877                                 string::size_type k = raw.find(package_end_sep, j);
 878                                 if (k == string::npos)
 879                                         return false;
 880                                 string const package = raw.substr(i + 1, j - i - 1);
 881                                 string const replacement = raw.substr(j + 1, k - j - 1);
 882                                 if (auto_packages.find(package) == auto_packages.end())
 883                                         os << replacement;
 884                                 i = k;
 885                         } else
 886                                 os.put(raw[i]);
 887                 }
 888                 os << "\n\\end_preamble\n";
 889         }
 890         if (!h_options.empty())
 891                 os << "\\options " << h_options << "\n";
 892         os << "\\use_default_options " << h_use_default_options << "\n";
 893         if (!used_modules.empty()) {
 894                 os << "\\begin_modules\n";
 895                 vector<string>::const_iterator const end = used_modules.end();
 896                 vector<string>::const_iterator it = used_modules.begin();
 897                 for (; it != end; it++)
 898                         os << *it << '\n';
 899                 os << "\\end_modules\n";
 900         }
 901         os << "\\language " << h_language << "\n"
 902            << "\\language_package " << h_language_package << "\n"
 903            << "\\inputencoding " << h_inputencoding << "\n"
 904            << "\\fontencoding " << h_fontencoding << "\n"
 905            << "\\font_roman " << h_font_roman << "\n"
 906            << "\\font_sans " << h_font_sans << "\n"
 907            << "\\font_typewriter " << h_font_typewriter << "\n"
 908            << "\\font_default_family " << h_font_default_family << "\n"
 909            << "\\font_sc " << h_font_sc << "\n"
 910            << "\\font_osf " << h_font_osf << "\n"
 911            << "\\font_sf_scale " << h_font_sf_scale << "\n"
 912            << "\\font_tt_scale " << h_font_tt_scale << "\n"
 913            << "\\graphics " << h_graphics << "\n";
 914         if (!h_float_placement.empty())
 915                 os << "\\float_placement " << h_float_placement << "\n";
 916         os << "\\paperfontsize " << h_paperfontsize << "\n"
 917            << "\\spacing " << h_spacing << "\n"
 918            << "\\use_hyperref " << h_use_hyperref << '\n';
 919         if (h_use_hyperref == "1") {
 920                 if (!h_pdf_title.empty())
 921                         os << "\\pdf_title \"" << h_pdf_title << "\"\n";
 922                 if (!h_pdf_author.empty())
 923                         os << "\\pdf_author \"" << h_pdf_author << "\"\n";
 924                 if (!h_pdf_subject.empty())
 925                         os << "\\pdf_subject \"" << h_pdf_subject << "\"\n";
 926                 if (!h_pdf_keywords.empty())
 927                         os << "\\pdf_keywords \"" << h_pdf_keywords << "\"\n";
 928                 os << "\\pdf_bookmarks " << h_pdf_bookmarks << "\n"
 929                       "\\pdf_bookmarksnumbered " << h_pdf_bookmarksnumbered << "\n"
 930                       "\\pdf_bookmarksopen " << h_pdf_bookmarksopen << "\n"
 931                       "\\pdf_bookmarksopenlevel " << h_pdf_bookmarksopenlevel << "\n"
 932                       "\\pdf_breaklinks " << h_pdf_breaklinks << "\n"
 933                       "\\pdf_pdfborder " << h_pdf_pdfborder << "\n"
 934                       "\\pdf_colorlinks " << h_pdf_colorlinks << "\n"
 935                       "\\pdf_backref " << h_pdf_backref << "\n"
 936                       "\\pdf_pdfusetitle " << h_pdf_pdfusetitle << '\n';
 937                 if (!h_pdf_pagemode.empty())
 938                         os << "\\pdf_pagemode " << h_pdf_pagemode << '\n';
 939                 if (!h_pdf_quoted_options.empty())
 940                         os << "\\pdf_quoted_options \"" << h_pdf_quoted_options << "\"\n";
 941         }
 942         os << "\\papersize " << h_papersize << "\n"
 943            << "\\use_geometry " << h_use_geometry << "\n"
 944            << "\\use_amsmath " << h_use_amsmath << "\n"
 945            << "\\use_esint " << h_use_esint << "\n"
 946            << "\\use_mhchem " << h_use_mhchem << "\n"
 947            << "\\use_mathdots " << h_use_mathdots << "\n"
 948            << "\\use_undertilde " << h_use_undertilde << "\n"
 949            << "\\cite_engine " << h_cite_engine << "\n"
 950            << "\\use_bibtopic " << h_use_bibtopic << "\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         // clear preamble for subdocuments
 985         h_preamble.str("");
 986         return true;
 987 }
 988
 989
 990 void Preamble::parse(Parser & p, string const & forceclass,
 991                      TeX2LyXDocClass & tc)
 992 {
 993         // initialize fixed types
 994         special_columns['D'] = 3;
 995         bool is_full_document = false;
 996         bool is_lyx_file = false;
 997         bool in_lyx_preamble = false;
 998
 999         // determine whether this is a full document or a fragment for inclusion
1000         while (p.good()) {
1001                 Token const & t = p.get_token();
1002
1003                 if (t.cat() == catEscape && t.cs() == "documentclass") {
1004                         is_full_document = true;
1005                         break;
1006                 }
1007         }
1008         p.reset();
1009
1010         while (is_full_document && p.good()) {
1011                 Token const & t = p.get_token();
1012
1013 #ifdef FILEDEBUG
1014                 cerr << "t: " << t << "\n";
1015 #endif
1016
1017                 //
1018                 // cat codes
1019                 //
1020                 if (!in_lyx_preamble &&
1021                     (t.cat() == catLetter ||
1022                      t.cat() == catSuper ||
1023                      t.cat() == catSub ||
1024                      t.cat() == catOther ||
1025                      t.cat() == catMath ||
1026                      t.cat() == catActive ||
1027                      t.cat() == catBegin ||
1028                      t.cat() == catEnd ||
1029                      t.cat() == catAlign ||
1030                      t.cat() == catParameter))
1031                         h_preamble << t.cs();
1032
1033                 else if (!in_lyx_preamble &&
1034                          (t.cat() == catSpace || t.cat() == catNewline))
1035                         h_preamble << t.asInput();
1036
1037                 else if (t.cat() == catComment) {
1038                         static regex const islyxfile("%% LyX .* created this file");
1039                         static regex const usercommands("User specified LaTeX commands");
1040
1041                         string const comment = t.asInput();
1042
1043                         // magically switch encoding default if it looks like XeLaTeX
1044                         static string const magicXeLaTeX =
1045                                 "% This document must be compiled with XeLaTeX ";
1046                         if (comment.size() > magicXeLaTeX.size()
1047                                   && comment.substr(0, magicXeLaTeX.size()) == magicXeLaTeX
1048                                   && h_inputencoding == "auto") {
1049                                 cerr << "XeLaTeX comment found, switching to UTF8\n";
1050                                 h_inputencoding = "utf8";
1051                         }
1052                         smatch sub;
1053                         if (regex_search(comment, sub, islyxfile)) {
1054                                 is_lyx_file = true;
1055                                 in_lyx_preamble = true;
1056                         } else if (is_lyx_file
1057                                    && regex_search(comment, sub, usercommands))
1058                                 in_lyx_preamble = false;
1059                         else if (!in_lyx_preamble)
1060                                 h_preamble << t.asInput();
1061                 }
1062
1063                 else if (t.cs() == "pagestyle")
1064                         h_paperpagestyle = p.verbatim_item();
1065
1066                 else if (t.cs() == "date") {
1067                         string argument = p.getArg('{', '}');
1068                         if (argument.empty())
1069                                 h_suppress_date = "true";
1070                         else
1071                                 h_preamble << t.asInput() << '{' << argument << '}';
1072                 }
1073
1074                 else if (t.cs() == "color") {
1075                         string const space =
1076                                 (p.hasOpt() ? p.getOpt() : string());
1077                         string argument = p.getArg('{', '}');
1078                         // check the case that a standard color is used
1079                         if (space.empty() && is_known(argument, known_basic_colors)) {
1080                                 h_fontcolor = rgbcolor2code(argument);
1081                                 preamble.registerAutomaticallyLoadedPackage("color");
1082                         } else if (space.empty() && argument == "document_fontcolor")
1083                                 preamble.registerAutomaticallyLoadedPackage("color");
1084                         // check the case that LyX's document_fontcolor is defined
1085                         // but not used for \color
1086                         else {
1087                                 h_preamble << t.asInput();
1088                                 if (!space.empty())
1089                                         h_preamble << space;
1090                                 h_preamble << '{' << argument << '}';
1091                                 // the color might already be set because \definecolor
1092                                 // is parsed before this
1093                                 h_fontcolor = "";
1094                         }
1095                 }
1096
1097                 else if (t.cs() == "pagecolor") {
1098                         string argument = p.getArg('{', '}');
1099                         // check the case that a standard color is used
1100                         if (is_known(argument, known_basic_colors)) {
1101                                 h_backgroundcolor = rgbcolor2code(argument);
1102                         } else if (argument == "page_backgroundcolor")
1103                                 preamble.registerAutomaticallyLoadedPackage("color");
1104                         // check the case that LyX's page_backgroundcolor is defined
1105                         // but not used for \pagecolor
1106                         else {
1107                                 h_preamble << t.asInput() << '{' << argument << '}';
1108                                 // the color might already be set because \definecolor
1109                                 // is parsed before this
1110                                 h_backgroundcolor = "";
1111                         }
1112                 }
1113
1114                 else if (t.cs() == "makeatletter") {
1115                         // LyX takes care of this
1116                         p.setCatCode('@', catLetter);
1117                 }
1118
1119                 else if (t.cs() == "makeatother") {
1120                         // LyX takes care of this
1121                         p.setCatCode('@', catOther);
1122                 }
1123
1124                 else if (t.cs() == "newcommand" || t.cs() == "newcommandx"
1125                       || t.cs() == "renewcommand" || t.cs() == "renewcommandx"
1126                       || t.cs() == "providecommand" || t.cs() == "providecommandx"
1127                                 || t.cs() == "DeclareRobustCommand"
1128                       || t.cs() == "DeclareRobustCommandx"
1129                                 || t.cs() == "ProvideTextCommandDefault"
1130                                 || t.cs() == "DeclareMathAccent") {
1131                         bool star = false;
1132                         if (p.next_token().character() == '*') {
1133                                 p.get_token();
1134                                 star = true;
1135                         }
1136                         string const name = p.verbatim_item();
1137                         string const opt1 = p.getFullOpt();
1138                         string const opt2 = p.getFullOpt();
1139                         string const body = p.verbatim_item();
1140                         // font settings
1141                         if (name == "\\rmdefault")
1142                                 if (is_known(body, known_roman_fonts))
1143                                         h_font_roman = body;
1144                         if (name == "\\sfdefault")
1145                                 if (is_known(body, known_sans_fonts))
1146                                         h_font_sans = body;
1147                         if (name == "\\ttdefault")
1148                                 if (is_known(body, known_typewriter_fonts))
1149                                         h_font_typewriter = body;
1150                         if (name == "\\familydefault") {
1151                                 string family = body;
1152                                 // remove leading "\"
1153                                 h_font_default_family = family.erase(0,1);
1154                         }
1155
1156                         // remove the lyxdot definition that is re-added by LyX
1157                         // if necessary
1158                         if (name == "\\lyxdot")
1159                                 in_lyx_preamble = true;
1160
1161                         // Add the command to the known commands
1162                         add_known_command(name, opt1, !opt2.empty(), from_utf8(body));
1163
1164                         // only non-lyxspecific stuff
1165                         if (!in_lyx_preamble) {
1166                                 ostringstream ss;
1167                                 ss << '\\' << t.cs();
1168                                 if (star)
1169                                         ss << '*';
1170                                 ss << '{' << name << '}' << opt1 << opt2
1171                                    << '{' << body << "}";
1172                                 h_preamble << ss.str();
1173 /*
1174                                 ostream & out = in_preamble ? h_preamble : os;
1175                                 out << "\\" << t.cs() << "{" << name << "}"
1176                                     << opts << "{" << body << "}";
1177 */
1178                         }
1179                 }
1180
1181                 else if (t.cs() == "documentclass") {
1182                         vector<string>::iterator it;
1183                         vector<string> opts = split_options(p.getArg('[', ']'));
1184                         handle_opt(opts, known_fontsizes, h_paperfontsize);
1185                         delete_opt(opts, known_fontsizes);
1186                         // delete "pt" at the end
1187                         string::size_type i = h_paperfontsize.find("pt");
1188                         if (i != string::npos)
1189                                 h_paperfontsize.erase(i);
1190                         // The documentclass options are always parsed before the options
1191                         // of the babel call so that a language cannot overwrite the babel
1192                         // options.
1193                         handle_opt(opts, known_languages, h_language);
1194                         delete_opt(opts, known_languages);
1195
1196                         // paper orientation
1197                         if ((it = find(opts.begin(), opts.end(), "landscape")) != opts.end()) {
1198                                 h_paperorientation = "landscape";
1199                                 opts.erase(it);
1200                         }
1201                         // paper sides
1202                         if ((it = find(opts.begin(), opts.end(), "oneside"))
1203                                  != opts.end()) {
1204                                 h_papersides = "1";
1205                                 opts.erase(it);
1206                         }
1207                         if ((it = find(opts.begin(), opts.end(), "twoside"))
1208                                  != opts.end()) {
1209                                 h_papersides = "2";
1210                                 opts.erase(it);
1211                         }
1212                         // paper columns
1213                         if ((it = find(opts.begin(), opts.end(), "onecolumn"))
1214                                  != opts.end()) {
1215                                 h_papercolumns = "1";
1216                                 opts.erase(it);
1217                         }
1218                         if ((it = find(opts.begin(), opts.end(), "twocolumn"))
1219                                  != opts.end()) {
1220                                 h_papercolumns = "2";
1221                                 opts.erase(it);
1222                         }
1223                         // paper sizes
1224                         // some size options are known to any document classes, other sizes
1225                         // are handled by the \geometry command of the geometry package
1226                         handle_opt(opts, known_class_paper_sizes, h_papersize);
1227                         delete_opt(opts, known_class_paper_sizes);
1228                         // the remaining options
1229                         h_options = join(opts, ",");
1230                         // FIXME This does not work for classes that have a
1231                         //       different name in LyX than in LaTeX
1232                         h_textclass = p.getArg('{', '}');
1233                 }
1234
1235                 else if (t.cs() == "usepackage") {
1236                         string const options = p.getArg('[', ']');
1237                         string const name = p.getArg('{', '}');
1238                         vector<string> vecnames;
1239                         split(name, vecnames, ',');
1240                         vector<string>::const_iterator it  = vecnames.begin();
1241                         vector<string>::const_iterator end = vecnames.end();
1242                         for (; it != end; ++it)
1243                                 handle_package(p, trimSpaceAndEol(*it), options,
1244                                                in_lyx_preamble);
1245                 }
1246
1247                 else if (t.cs() == "inputencoding") {
1248                         string const encoding = p.getArg('{','}');
1249                         h_inputencoding = encoding;
1250                         p.setEncoding(encoding);
1251                 }
1252
1253                 else if (t.cs() == "newenvironment") {
1254                         string const name = p.getArg('{', '}');
1255                         string const opt1 = p.getFullOpt();
1256                         string const opt2 = p.getFullOpt();
1257                         string const beg = p.verbatim_item();
1258                         string const end = p.verbatim_item();
1259                         if (!in_lyx_preamble) {
1260                                 h_preamble << "\\newenvironment{" << name
1261                                            << '}' << opt1 << opt2 << '{'
1262                                            << beg << "}{" << end << '}';
1263                         }
1264                         add_known_environment(name, opt1, !opt2.empty(),
1265                                               from_utf8(beg), from_utf8(end));
1266
1267                 }
1268
1269                 else if (t.cs() == "def") {
1270                         string name = p.get_token().cs();
1271                         while (p.next_token().cat() != catBegin)
1272                                 name += p.get_token().cs();
1273                         if (!in_lyx_preamble)
1274                                 h_preamble << "\\def\\" << name << '{'
1275                                            << p.verbatim_item() << "}";
1276                 }
1277
1278                 else if (t.cs() == "newcolumntype") {
1279                         string const name = p.getArg('{', '}');
1280                         trimSpaceAndEol(name);
1281                         int nargs = 0;
1282                         string opts = p.getOpt();
1283                         if (!opts.empty()) {
1284                                 istringstream is(string(opts, 1));
1285                                 is >> nargs;
1286                         }
1287                         special_columns[name[0]] = nargs;
1288                         h_preamble << "\\newcolumntype{" << name << "}";
1289                         if (nargs)
1290                                 h_preamble << "[" << nargs << "]";
1291                         h_preamble << "{" << p.verbatim_item() << "}";
1292                 }
1293
1294                 else if (t.cs() == "setcounter") {
1295                         string const name = p.getArg('{', '}');
1296                         string const content = p.getArg('{', '}');
1297                         if (name == "secnumdepth")
1298                                 h_secnumdepth = content;
1299                         else if (name == "tocdepth")
1300                                 h_tocdepth = content;
1301                         else
1302                                 h_preamble << "\\setcounter{" << name << "}{" << content << "}";
1303                 }
1304
1305                 else if (t.cs() == "setlength") {
1306                         string const name = p.verbatim_item();
1307                         string const content = p.verbatim_item();
1308                         // the paragraphs are only not indented when \parindent is set to zero
1309                         if (name == "\\parindent" && content != "") {
1310                                 if (content[0] == '0')
1311                                         h_paragraph_separation = "skip";
1312                                 else
1313                                         h_paragraph_indentation = translate_len(content);
1314                         } else if (name == "\\parskip") {
1315                                 if (content == "\\smallskipamount")
1316                                         h_defskip = "smallskip";
1317                                 else if (content == "\\medskipamount")
1318                                         h_defskip = "medskip";
1319                                 else if (content == "\\bigskipamount")
1320                                         h_defskip = "bigskip";
1321                                 else
1322                                         h_defskip = content;
1323                         } else
1324                                 h_preamble << "\\setlength{" << name << "}{" << content << "}";
1325                 }
1326
1327                 else if (t.cs() == "onehalfspacing")
1328                         h_spacing = "onehalf";
1329
1330                 else if (t.cs() == "doublespacing")
1331                         h_spacing = "double";
1332
1333                 else if (t.cs() == "setstretch")
1334                         h_spacing = "other " + p.verbatim_item();
1335
1336                 else if (t.cs() == "begin") {
1337                         string const name = p.getArg('{', '}');
1338                         if (name == "document")
1339                                 break;
1340                         h_preamble << "\\begin{" << name << "}";
1341                 }
1342
1343                 else if (t.cs() == "geometry") {
1344                         vector<string> opts = split_options(p.getArg('{', '}'));
1345                         handle_geometry(opts);
1346                 }
1347
1348                 else if (t.cs() == "definecolor") {
1349                         string const color = p.getArg('{', '}');
1350                         string const space = p.getArg('{', '}');
1351                         string const value = p.getArg('{', '}');
1352                         if (color == "document_fontcolor" && space == "rgb") {
1353                                 RGBColor c(RGBColorFromLaTeX(value));
1354                                 h_fontcolor = X11hexname(c);
1355                         } else if (color == "note_fontcolor" && space == "rgb") {
1356                                 RGBColor c(RGBColorFromLaTeX(value));
1357                                 h_notefontcolor = X11hexname(c);
1358                         } else if (color == "page_backgroundcolor" && space == "rgb") {
1359                                 RGBColor c(RGBColorFromLaTeX(value));
1360                                 h_backgroundcolor = X11hexname(c);
1361                         } else if (color == "shadecolor" && space == "rgb") {
1362                                 RGBColor c(RGBColorFromLaTeX(value));
1363                                 h_boxbgcolor = X11hexname(c);
1364                         } else {
1365                                 h_preamble << "\\definecolor{" << color
1366                                            << "}{" << space << "}{" << value
1367                                            << '}';
1368                         }
1369                 }
1370
1371                 else if (t.cs() == "jurabibsetup") {
1372                         // FIXME p.getArg('{', '}') is most probably wrong (it
1373                         //       does not handle nested braces).
1374                         //       Use p.verbatim_item() instead.
1375                         vector<string> jurabibsetup =
1376                                 split_options(p.getArg('{', '}'));
1377                         // add jurabibsetup to the jurabib package options
1378                         add_package("jurabib", jurabibsetup);
1379                         if (!jurabibsetup.empty()) {
1380                                 h_preamble << "\\jurabibsetup{"
1381                                            << join(jurabibsetup, ",") << '}';
1382                         }
1383                 }
1384
1385                 else if (t.cs() == "hypersetup") {
1386                         vector<string> hypersetup =
1387                                 split_options(p.verbatim_item());
1388                         // add hypersetup to the hyperref package options
1389                         handle_hyperref(hypersetup);
1390                         if (!hypersetup.empty()) {
1391                                 h_preamble << "\\hypersetup{"
1392                                            << join(hypersetup, ",") << '}';
1393                         }
1394                 }
1395
1396                 else if (is_known(t.cs(), known_if_3arg_commands)) {
1397                         // prevent misparsing of \usepackage if it is used
1398                         // as an argument (see e.g. our own output of
1399                         // \@ifundefined above)
1400                         string const arg1 = p.verbatim_item();
1401                         string const arg2 = p.verbatim_item();
1402                         string const arg3 = p.verbatim_item();
1403                         // test case \@ifundefined{date}{}{\date{}}
1404                         if (t.cs() == "@ifundefined" && arg1 == "date" &&
1405                             arg2.empty() && arg3 == "\\date{}") {
1406                                 h_suppress_date = "true";
1407                         // older tex2lyx versions did output
1408                         // \@ifundefined{definecolor}{\usepackage{color}}{}
1409                         } else if (t.cs() == "@ifundefined" &&
1410                                    arg1 == "definecolor" &&
1411                                    arg2 == "\\usepackage{color}" &&
1412                                    arg3.empty()) {
1413                                 if (!in_lyx_preamble)
1414                                         h_preamble << package_beg_sep
1415                                                    << "color"
1416                                                    << package_mid_sep
1417                                                    << "\\@ifundefined{definecolor}{color}{}"
1418                                                    << package_end_sep;
1419                         // test for case
1420                         //\@ifundefined{showcaptionsetup}{}{%
1421                         // \PassOptionsToPackage{caption=false}{subfig}}
1422                         // that LyX uses for subfloats
1423                         } else if (t.cs() == "@ifundefined" &&
1424                                    arg1 == "showcaptionsetup" && arg2.empty()
1425                                 && arg3 == "%\n \\PassOptionsToPackage{caption=false}{subfig}") {
1426                                 ; // do nothing
1427                         } else if (!in_lyx_preamble) {
1428                                 h_preamble << t.asInput()
1429                                            << '{' << arg1 << '}'
1430                                            << '{' << arg2 << '}'
1431                                            << '{' << arg3 << '}';
1432                         }
1433                 }
1434
1435                 else if (is_known(t.cs(), known_if_commands)) {
1436                         // must not parse anything in conditional code, since
1437                         // LyX would output the parsed contents unconditionally
1438                         if (!in_lyx_preamble)
1439                                 h_preamble << t.asInput();
1440                         handle_if(p, in_lyx_preamble);
1441                 }
1442
1443                 else if (!t.cs().empty() && !in_lyx_preamble)
1444                         h_preamble << '\\' << t.cs();
1445         }
1446
1447         // remove the whitespace
1448         p.skip_spaces();
1449
1450         // Force textclass if the user wanted it
1451         if (!forceclass.empty())
1452                 h_textclass = forceclass;
1453         if (noweb_mode && !prefixIs(h_textclass, "literate-"))
1454                 h_textclass.insert(0, "literate-");
1455         tc.setName(h_textclass);
1456         if (!tc.load()) {
1457                 cerr << "Error: Could not read layout file for textclass \"" << h_textclass << "\"." << endl;
1458                 exit(EXIT_FAILURE);
1459         }
1460         if (h_papersides.empty()) {
1461                 ostringstream ss;
1462                 ss << tc.sides();
1463                 h_papersides = ss.str();
1464         }
1465 }
1466
1467
1468 string babel2lyx(string const & language)
1469 {
1470         char const * const * where = is_known(language, known_languages);
1471         if (where)
1472                 return known_coded_languages[where - known_languages];
1473         return language;
1474 }
1475
1476
1477 string rgbcolor2code(string const & name)
1478 {
1479         char const * const * where = is_known(name, known_basic_colors);
1480         if (where) {
1481                 // "red", "green" etc
1482                 return known_basic_color_codes[where - known_basic_colors];
1483         }
1484         // "255,0,0", "0,255,0" etc
1485         RGBColor c(RGBColorFromLaTeX(name));
1486         return X11hexname(c);
1487 }
1488
1489 // }])
1490
1491
1492 } // namespace lyx