X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftex2lyx%2Ftex2lyx.cpp;h=edcba48578162d2d26f3b703bd0d4139a781078a;hb=777a2a9baa1b7e5f2bec0cc584cca6a77f34e918;hp=89b766cc791f01bdd3cdb345db944b5c513b1af0;hpb=41740ea915ee7a95206d780b6256e660cef39c6e;p=lyx.git diff --git a/src/tex2lyx/tex2lyx.cpp b/src/tex2lyx/tex2lyx.cpp index 89b766cc79..edcba48578 100644 --- a/src/tex2lyx/tex2lyx.cpp +++ b/src/tex2lyx/tex2lyx.cpp @@ -24,6 +24,7 @@ #include "Preamble.h" #include "TextClass.h" +#include "support/ConsoleApplication.h" #include "support/convert.h" #include "support/ExceptionMessage.h" #include "support/filetools.h" @@ -35,6 +36,7 @@ #include #include +#include #include #include #include @@ -170,30 +172,32 @@ void add_known_theorem(string const & theorem, string const & o1, } -Layout const * findLayoutWithoutModule(TextClass const & textclass, - string const & name, bool command) +Layout const * findLayoutWithoutModule(TextClass const & tc, + string const & name, bool command, + string const & latexparam) { - DocumentClass::const_iterator it = textclass.begin(); - DocumentClass::const_iterator en = textclass.end(); - for (; it != en; ++it) { - if (it->latexname() == name && - ((command && it->isCommand()) || (!command && it->isEnvironment()))) - return &*it; + for (auto const & lay : tc) { + if (lay.latexname() == name && + (latexparam.empty() || + (!lay.latexparam().empty() && suffixIs(latexparam, lay.latexparam()))) && + ((command && lay.isCommand()) || (!command && lay.isEnvironment()))) + return &lay; } return 0; } -InsetLayout const * findInsetLayoutWithoutModule(TextClass const & textclass, - string const & name, bool command) +InsetLayout const * findInsetLayoutWithoutModule(TextClass const & tc, + string const & name, bool command, + string const & latexparam) { - DocumentClass::InsetLayouts::const_iterator it = textclass.insetLayouts().begin(); - DocumentClass::InsetLayouts::const_iterator en = textclass.insetLayouts().end(); - for (; it != en; ++it) { - if (it->second.latexname() == name && - ((command && it->second.latextype() == InsetLayout::COMMAND) || - (!command && it->second.latextype() == InsetLayout::ENVIRONMENT))) - return &(it->second); + for (auto const & ilay : tc.insetLayouts()) { + if (ilay.second.latexname() == name && + (latexparam.empty() || + (!ilay.second.latexparam().empty() && suffixIs(latexparam, ilay.second.latexparam()))) && + ((command && ilay.second.latextype() == InsetLayout::COMMAND) || + (!command && ilay.second.latextype() == InsetLayout::ENVIRONMENT))) + return &(ilay.second); } return 0; } @@ -309,7 +313,7 @@ bool addModule(string const & module) return false; } -} +} // namespace bool checkModule(string const & name, bool command) @@ -317,17 +321,18 @@ bool checkModule(string const & name, bool command) // Cache to avoid slowdown by repated searches static set failed[2]; - // Only add the module if the command was actually defined in the LyX preamble + // Record whether the command was actually defined in the LyX preamble bool theorem = false; + bool preamble_def = true; if (command) { if (possible_textclass_commands.find('\\' + name) == possible_textclass_commands.end()) - return false; + preamble_def = false; } else { if (possible_textclass_environments.find(name) == possible_textclass_environments.end()) { if (possible_textclass_theorems.find(name) != possible_textclass_theorems.end()) theorem = true; else - return false; + preamble_def = false; } } if (failed[command].find(name) != failed[command].end()) @@ -337,12 +342,16 @@ bool checkModule(string const & name, bool command) LayoutFile const & baseClass = LayoutFileList::get()[textclass.name()]; // Try to find a module that defines the command. - // Only add it if the definition can be found in the preamble of the - // style that corresponds to the command. This is a heuristic and - // different from the way how we parse the builtin commands of the - // text class (in that case we only compare the name), but it is - // needed since it is not unlikely that two different modules define a + // For commands with preamble definitions we prefer modules where the definition + // can be found in the preamble of the style that corresponds to the command. + // For others we check whether the command or module requires a package that is loaded + // in the tex file and use a style with the respective command. + // This is a heuristic and different from the way how we parse the builtin + // commands of the text class (in that case we only compare the name), + // but it is needed since it is not unlikely that two different modules define a // command with the same name. + string found_module; + vector potential_modules; ModuleMap::iterator const end = modules.end(); for (ModuleMap::iterator it = modules.begin(); it != end; ++it) { string const module = it->first; @@ -354,40 +363,101 @@ bool checkModule(string const & name, bool command) continue; DocumentClassConstPtr c = it->second; Layout const * layout = findLayoutWithoutModule(*c, name, command); - InsetLayout const * insetlayout = layout ? 0 : + InsetLayout const * insetlayout = layout ? nullptr : findInsetLayoutWithoutModule(*c, name, command); - docstring preamble; - if (layout) - preamble = layout->preamble(); - else if (insetlayout) - preamble = insetlayout->preamble(); - if (preamble.empty()) + docstring dpre; + std::set cmd_reqs; + bool found_style = false; + if (layout) { + found_style = true; + dpre = layout->preamble(); + std::set lreqs = layout->requires(); + if (!lreqs.empty()) + cmd_reqs.insert(lreqs.begin(), lreqs.end()); + } else if (insetlayout) { + found_style = true; + dpre = insetlayout->preamble(); + std::set lreqs = insetlayout->requires(); + if (!lreqs.empty()) + cmd_reqs.insert(lreqs.begin(), lreqs.end()); + } + if (dpre.empty() && preamble_def) continue; - bool add = false; - if (command) { - FullCommand const & cmd = - possible_textclass_commands['\\' + name]; - if (preamble.find(cmd.def) != docstring::npos) - add = true; - } else if (theorem) { - FullCommand const & thm = - possible_textclass_theorems[name]; - if (preamble.find(thm.def) != docstring::npos) - add = true; - } else { - FullEnvironment const & env = - possible_textclass_environments[name]; - if (preamble.find(env.beg) != docstring::npos && - preamble.find(env.end) != docstring::npos) - add = true; + bool const package_cmd = dpre.empty(); + bool match_req = false; + if (package_cmd) { + std::set mreqs = it->second->requires(); + if (!mreqs.empty()) + cmd_reqs.insert(mreqs.begin(), mreqs.end()); + for (auto const & pack : cmd_reqs) { + // If a requirement of the module matches a used package + // we load the module except if we have an auto-loaded package + // which is only required generally by the module, and the module + // does not provide the [inset]layout we are looking for. + // This heuristics should + // * load modules if the provide a style we don't have in the class + // * load modules that provide a package support generally (such as fixltx2e) + // * not unnecessarily load modules just because they require a package which we + // load anyway. + if (preamble.isPackageUsed(pack) + && (found_style || !preamble.isPackageAutoLoaded(pack))) { + if (found_style) + match_req = true; + else + potential_modules.push_back(module); + break; + } + } + } + bool add = match_req; + if (preamble_def) { + if (command) { + FullCommand const & cmd = + possible_textclass_commands['\\' + name]; + if (dpre.find(cmd.def) != docstring::npos) + add = true; + } else if (theorem) { + FullCommand const & thm = + possible_textclass_theorems[name]; + if (dpre.find(thm.def) != docstring::npos) + add = true; + } else { + FullEnvironment const & env = + possible_textclass_environments[name]; + if (dpre.find(env.beg) != docstring::npos && + dpre.find(env.end) != docstring::npos) + add = true; + } } if (add) { - FileName layout_file = libFileSearch("layouts", module, "module"); + found_module = module; + break; + } + } + if (found_module.empty()) { + // take one of the second row + if (!potential_modules.empty()) + found_module = potential_modules.front(); + } + + if (!found_module.empty()) { + vector v; + LayoutModuleList mods; + // addModule is necessary in order to catch required modules + // as well (see #11156) + if (!addModule(found_module, baseClass, mods, v)) + return false; + for (auto const & mod : mods) { + if (!used_modules.moduleCanBeAdded(mod, &baseClass)) + return false; + FileName layout_file = libFileSearch("layouts", mod, "module"); if (textclass.read(layout_file, TextClass::MODULE)) { - used_modules.push_back(module); + used_modules.push_back(mod); // speed up further searches: // the module does not need to be checked anymore. - modules.erase(it); + ModuleMap::iterator const it = modules.find(mod); + if (it != modules.end()) + modules.erase(it); return true; } } @@ -482,13 +552,13 @@ void read_environment(Parser & p, string const & begin, * has almost all of them listed. For the same reason the reLyX-specific * reLyXre environment is ignored. */ -void read_syntaxfile(FileName const & file_name) +bool read_syntaxfile(FileName const & file_name) { ifdocstream is(file_name.toFilesystemEncoding().c_str()); if (!is.good()) { cerr << "Could not open syntax file \"" << file_name << "\" for reading." << endl; - exit(2); + return false; } // We can use our TeX parser, since the syntax of the layout file is // modeled after TeX. @@ -514,6 +584,7 @@ void read_syntaxfile(FileName const & file_name) } } } + return true; } @@ -530,9 +601,47 @@ int error_code = 0; typedef int (*cmd_helper)(string const &, string const &); +class StopException : public exception +{ + public: + StopException(int status) : status_(status) {} + int status() const { return status_; } + private: + int status_; +}; + + +/// The main application class +class TeX2LyXApp : public ConsoleApplication +{ +public: + TeX2LyXApp(int & argc, char * argv[]) + : ConsoleApplication("tex2lyx" PROGRAM_SUFFIX, argc, argv), + argc_(argc), argv_(argv) + { + } + void doExec() + { + try { + int const exit_status = run(); + exit(exit_status); + } + catch (StopException & e) { + exit(e.status()); + } + } +private: + void easyParse(); + /// Do the real work + int run(); + int & argc_; + char ** argv_; +}; + + int parse_help(string const &, string const &) { - cerr << "Usage: tex2lyx [options] infile.tex [outfile.lyx]\n" + cout << "Usage: tex2lyx [options] infile.tex [outfile.lyx]\n" "Options:\n" "\t-c textclass Declare the textclass.\n" "\t-m mod1[,mod2...] Load the given modules.\n" @@ -557,25 +666,24 @@ int parse_help(string const &, string const &) "\tand \"SYSDIR/layouts\" are searched for layout and module files.\n" "Check the tex2lyx man page for more details." << endl; - exit(error_code); + throw StopException(error_code); } int parse_version(string const &, string const &) { - lyxerr << "tex2lyx " << lyx_version - << " (" << lyx_release_date << ")" << endl; - lyxerr << "Built on " << __DATE__ << ", " << __TIME__ << endl; + cout << "tex2lyx " << lyx_version + << " (" << lyx_release_date << ")" << endl; - lyxerr << lyx_version_info << endl; - exit(error_code); + cout << lyx_version_info << endl; + throw StopException(error_code); } void error_message(string const & message) { cerr << "tex2lyx: " << message << "\n\n"; - error_code = 1; + error_code = EXIT_FAILURE; parse_help(string(), string()); } @@ -685,7 +793,7 @@ int parse_copyfiles(string const &, string const &) } -void easyParse(int & argc, char * argv[]) +void TeX2LyXApp::easyParse() { map cmdmap; @@ -708,29 +816,29 @@ void easyParse(int & argc, char * argv[]) cmdmap["-roundtrip"] = parse_roundtrip; cmdmap["-copyfiles"] = parse_copyfiles; - for (int i = 1; i < argc; ++i) { + for (int i = 1; i < argc_; ++i) { map::const_iterator it - = cmdmap.find(argv[i]); + = cmdmap.find(argv_[i]); // don't complain if not found - may be parsed later if (it == cmdmap.end()) { - if (argv[i][0] == '-') - error_message(string("Unknown option `") + argv[i] + "'."); + if (argv_[i][0] == '-') + error_message(string("Unknown option `") + argv_[i] + "'."); else continue; } - string arg = (i + 1 < argc) ? os::utf8_argv(i + 1) : string(); - string arg2 = (i + 2 < argc) ? os::utf8_argv(i + 2) : string(); + string arg = (i + 1 < argc_) ? os::utf8_argv(i + 1) : string(); + string arg2 = (i + 2 < argc_) ? os::utf8_argv(i + 2) : string(); int const remove = 1 + it->second(arg, arg2); // Now, remove used arguments by shifting // the following ones remove places down. os::remove_internal_args(i, remove); - argc -= remove; - for (int j = i; j < argc; ++j) - argv[j] = argv[j + remove]; + argc_ -= remove; + for (int j = i; j < argc_; ++j) + argv_[j] = argv_[j + remove]; --i; } } @@ -788,14 +896,6 @@ bool roundtripMode() } -string fixedEncoding() -{ - if (fixed_encoding) - return default_encoding; - return ""; -} - - namespace { /*! @@ -807,23 +907,9 @@ namespace { * You must ensure that \p parentFilePathTeX is properly set before calling * this function! */ -bool tex2lyx(idocstream & is, ostream & os, string encoding) +bool tex2lyx(idocstream & is, ostream & os, string const & encoding, + string const & outfiledir) { - // Set a sensible default encoding. - // This is used until an encoding command is found. - // For child documents use the encoding of the master, else ISO8859-1, - // (formerly known by its latex name latin1), since ISO8859-1 does not - // cause an iconv error if the actual encoding is different (bug 7509). - if (encoding.empty()) { - if (preamble.inputencoding() == "auto") - encoding = "ISO8859-1"; - else { - Encoding const * const enc = encodings.fromLyXName( - preamble.inputencoding(), true); - encoding = enc->iconvName(); - } - } - Parser p(is, fixed_encoding ? default_encoding : string()); p.setEncoding(encoding); //p.dump(); @@ -859,6 +945,8 @@ bool tex2lyx(idocstream & is, ostream & os, string encoding) context.font.language = preamble.defaultLanguage(); // parse the main text parse_text(p, ss, FLAG_END, true, context); + // check if we need a commented bibtex inset (biblatex) + check_comment_bib(ss, context); if (Context::empty) // Empty document body. LyX needs at least one paragraph. context.check_layout(ss); @@ -873,7 +961,7 @@ bool tex2lyx(idocstream & is, ostream & os, string encoding) for (; it != end; ++it) preamble.addModule(*it); } - if (!preamble.writeLyXHeader(os, !active_environments.empty())) { + if (!preamble.writeLyXHeader(os, !active_environments.empty(), outfiledir)) { cerr << "Could not write LyX file header." << endl; return false; } @@ -892,11 +980,47 @@ bool tex2lyx(idocstream & is, ostream & os, string encoding) /// convert TeX from \p infilename to LyX and write it to \p os -bool tex2lyx(FileName const & infilename, ostream & os, string const & encoding) +bool tex2lyx(FileName const & infilename, ostream & os, string encoding, + string const & outfiledir) { - ifdocstream is; + // Set a sensible default encoding. + // This is used until an encoding command is found. + // For child documents use the encoding of the master, else try to + // detect it from the preamble, since setting an encoding of an open + // fstream does currently not work on OS X. + // Always start with ISO-8859-1, (formerly known by its latex name + // latin1), since ISO-8859-1 does not cause an iconv error if the + // actual encoding is different (bug 7509). + if (encoding.empty()) { + Encoding const * enc = 0; + if (preamble.inputencoding() == "auto-legacy") { + ifdocstream is(setEncoding("ISO-8859-1")); + // forbid buffering on this stream + is.rdbuf()->pubsetbuf(0, 0); + is.open(infilename.toFilesystemEncoding().c_str()); + if (is.good()) { + Parser ep(is, string()); + ep.setEncoding("ISO-8859-1"); + Preamble encodingpreamble; + string const e = encodingpreamble + .parseEncoding(ep, documentclass); + if (!e.empty()) + enc = encodings.fromLyXName(e, true); + } + } else + enc = encodings.fromLyXName( + preamble.inputencoding(), true); + if (enc) + encoding = enc->iconvName(); + else + encoding = "ISO-8859-1"; + // store + preamble.docencoding = encoding; + } + + ifdocstream is(setEncoding(encoding)); // forbid buffering on this stream - is.rdbuf()->pubsetbuf(0,0); + is.rdbuf()->pubsetbuf(0, 0); is.open(infilename.toFilesystemEncoding().c_str()); if (!is.good()) { cerr << "Could not open input file \"" << infilename @@ -905,7 +1029,7 @@ bool tex2lyx(FileName const & infilename, ostream & os, string const & encoding) } string const oldParentFilePath = parentFilePathTeX; parentFilePathTeX = onlyPath(infilename.absFileName()); - bool retval = tex2lyx(is, os, encoding); + bool retval = tex2lyx(is, os, encoding, outfiledir); parentFilePathTeX = oldParentFilePath; return retval; } @@ -938,7 +1062,8 @@ bool tex2lyx(string const & infilename, FileName const & outfilename, cerr << "Input file: " << infilename << "\n"; cerr << "Output file: " << outfilename << "\n"; #endif - return tex2lyx(FileName(infilename), os, encoding); + return tex2lyx(FileName(infilename), os, encoding, + outfilename.onlyPath().absFileName() + '/'); } @@ -966,18 +1091,13 @@ bool tex2tex(string const & infilename, FileName const & outfilename, return false; } -} // namespace lyx +namespace { -int main(int argc, char * argv[]) +int TeX2LyXApp::run() { - using namespace lyx; - - //setlocale(LC_CTYPE, ""); - - lyxerr.setStream(cerr); - - os::init(argc, argv); + // qt changes this, and our numeric conversions require the C locale + setlocale(LC_NUMERIC, "C"); try { init_package(internal_path(os::utf8_argv(0)), string(), string()); @@ -988,9 +1108,9 @@ int main(int argc, char * argv[]) return EXIT_FAILURE; } - easyParse(argc, argv); + easyParse(); - if (argc <= 1) + if (argc_ <= 1) error_message("Not enough arguments."); try { @@ -1003,13 +1123,29 @@ int main(int argc, char * argv[]) return EXIT_FAILURE; } + // Check that user LyX directory is ok. + FileName const sup = package().user_support(); + if (sup.exists() && sup.isDirectory()) { + string const lock_file = package().getConfigureLockName(); + int fd = fileLock(lock_file.c_str()); + if (configFileNeedsUpdate("lyxrc.defaults") || + configFileNeedsUpdate("lyxmodules.lst") || + configFileNeedsUpdate("textclass.lst") || + configFileNeedsUpdate("packages.lst") || + configFileNeedsUpdate("lyxciteengines.lst") || + configFileNeedsUpdate("xtemplates.lst")) + package().reconfigureUserLyXDir(""); + fileUnlock(fd, lock_file.c_str()); + } else + error_message("User directory does not exist."); + // Now every known option is parsed. Look for input and output // file name (the latter is optional). string infilename = internal_path(os::utf8_argv(1)); infilename = makeAbsPath(infilename).absFileName(); string outfilename; - if (argc > 2) { + if (argc_ > 2) { outfilename = internal_path(os::utf8_argv(2)); if (outfilename != "-") outfilename = makeAbsPath(outfilename).absFileName(); @@ -1040,9 +1176,11 @@ int main(int argc, char * argv[]) cerr << "Error: Could not find syntax file \"syntax.default\"." << endl; return EXIT_FAILURE; } - read_syntaxfile(system_syntaxfile); + if (!read_syntaxfile(system_syntaxfile)) + return 2; if (!syntaxfile.empty()) - read_syntaxfile(makeAbsPath(syntaxfile)); + if (!read_syntaxfile(makeAbsPath(syntaxfile))) + return 2; // Read the encodings table. FileName const symbols_path = libFileSearch(string(), "unicodesymbols"); @@ -1064,6 +1202,8 @@ int main(int argc, char * argv[]) if (!enc) error_message("Unknown LaTeX encoding `" + default_encoding + "'"); default_encoding = enc->iconvName(); + if (fixed_encoding) + preamble.setInputencoding(enc->name()); } // Load the layouts @@ -1077,7 +1217,7 @@ int main(int argc, char * argv[]) if (outfilename == "-") { // assume same directory as input file masterFilePathLyX = masterFilePathTeX; - if (tex2lyx(FileName(infilename), cout, default_encoding)) + if (tex2lyx(FileName(infilename), cout, default_encoding, masterFilePathLyX)) return EXIT_SUCCESS; } else { masterFilePathLyX = onlyPath(outfilename); @@ -1095,11 +1235,27 @@ int main(int argc, char * argv[]) if (tex2tex(infilename, FileName(outfilename), default_encoding)) return EXIT_SUCCESS; } else { - if (tex2lyx(infilename, FileName(outfilename), default_encoding)) + if (lyx::tex2lyx(infilename, FileName(outfilename), default_encoding)) return EXIT_SUCCESS; } } return EXIT_FAILURE; } +} // anonymous namespace +} // namespace lyx + + +int main(int argc, char * argv[]) +{ + //setlocale(LC_CTYPE, ""); + + lyx::lyxerr.setStream(cerr); + + os::init(argc, &argv); + + lyx::TeX2LyXApp app(argc, argv); + return app.exec(); +} + // }])