X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftex2lyx%2Ftex2lyx.cpp;h=37bcf7d038d9e76edf47d7bd90cacac9f7f5bb84;hb=dac9ec0c13f50a5b1edc01372a0f068cdb431726;hp=90a20248a4104bd34c79c8e553990d1e382f3d1d;hpb=51d70699efd6bc3cbb9b19c6d339f4322fab5900;p=lyx.git diff --git a/src/tex2lyx/tex2lyx.cpp b/src/tex2lyx/tex2lyx.cpp index 90a20248a4..37bcf7d038 100644 --- a/src/tex2lyx/tex2lyx.cpp +++ b/src/tex2lyx/tex2lyx.cpp @@ -11,12 +11,17 @@ // {[( #include +#include #include "tex2lyx.h" #include "Context.h" #include "Encoding.h" #include "Layout.h" +#include "LayoutFile.h" +#include "LayoutModuleList.h" +#include "ModuleList.h" +#include "Preamble.h" #include "TextClass.h" #include "support/convert.h" @@ -28,6 +33,7 @@ #include "support/Messages.h" #include "support/os.h" #include "support/Package.h" +#include "support/Systemcall.h" #include #include @@ -42,15 +48,43 @@ using namespace lyx::support::os; namespace lyx { +namespace frontend { +namespace Alert { + void warning(docstring const & title, docstring const & message, + bool const &) + { + LYXERR0(title); + LYXERR0(message); + } +} +} + + +// Dummy texrow support +void TexRow::newline() +{} + + +void TexRow::newlines(int) +{} + + +// Dummy LyXRC support +class LyXRC { +public: + string icon_set; +} lyxrc; + + // Dummy translation support Messages messages_; -Messages & getMessages(std::string const &) +Messages const & getMessages(std::string const &) { return messages_; } -Messages & getGuiMessages() +Messages const & getGuiMessages() { return messages_; } @@ -61,21 +95,9 @@ void lyx_exit(int) {} -string const trim(string const & a, char const * p) +string const trimSpaceAndEol(string const & a) { - // LASSERT(p, /**/); - - if (a.empty() || !*p) - return a; - - size_t r = a.find_last_not_of(p); - size_t l = a.find_first_not_of(p); - - // Is this the minimal test? (lgb) - if (r == string::npos && l == string::npos) - return string(); - - return a.substr(l, r - l + 1); + return trim(a, " \t\n\r"); } @@ -122,13 +144,19 @@ string active_environment() } +TeX2LyXDocClass textclass; CommandMap known_commands; CommandMap known_environments; CommandMap known_math_environments; +FullCommandMap possible_textclass_commands; +FullEnvironmentMap possible_textclass_environments; +int const LYX_FORMAT = LYX_FORMAT_TEX2LYX; +/// used modules +LayoutModuleList used_modules; -void add_known_command(string const & command, string const & o1, - bool o2) + +void convertArgs(string const & o1, bool o2, vector & arguments) { // We have to handle the following cases: // definition o1 o2 invocation result @@ -138,7 +166,6 @@ void add_known_command(string const & command, string const & o1, // \newcommand{\foo}[1][]{bar #1} "[1]" true \foo[x] bar x // \newcommand{\foo}[1][x]{bar #1} "[1]" true \foo[x] bar x unsigned int nargs = 0; - vector arguments; string const opt1 = rtrim(ltrim(o1, "["), "]"); if (isStrUnsignedInt(opt1)) { // The command has arguments @@ -151,11 +178,162 @@ void add_known_command(string const & command, string const & o1, } for (unsigned int i = 0; i < nargs; ++i) arguments.push_back(required); +} + + +void add_known_command(string const & command, string const & o1, + bool o2, docstring const & definition) +{ + vector arguments; + convertArgs(o1, o2, arguments); known_commands[command] = arguments; + if (!definition.empty()) + possible_textclass_commands[command] = + FullCommand(arguments, definition); +} + + +void add_known_environment(string const & environment, string const & o1, + bool o2, docstring const & beg, docstring const &end) +{ + vector arguments; + convertArgs(o1, o2, arguments); + known_environments[environment] = arguments; + if (!beg.empty() || ! end.empty()) + possible_textclass_environments[environment] = + FullEnvironment(arguments, beg, end); +} + + +Layout const * findLayoutWithoutModule(TextClass const & textclass, + string const & name, bool command) +{ + 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; + } + return 0; +} + + +InsetLayout const * findInsetLayoutWithoutModule(TextClass const & textclass, + string const & name, bool command) +{ + 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); + } + return 0; +} + + +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 + if (command) { + if (possible_textclass_commands.find('\\' + name) == possible_textclass_commands.end()) + return false; + } else { + if (possible_textclass_environments.find(name) == possible_textclass_environments.end()) + return false; + } + if (failed[command].find(name) != failed[command].end()) + return false; + + // Create list of dummy document classes if not already done. + // This is needed since a module cannot be read on its own, only as + // part of a document class. + LayoutFile const & baseClass = LayoutFileList::get()[textclass.name()]; + typedef map ModuleMap; + static ModuleMap modules; + static bool init = true; + if (init) { + baseClass.load(); + LyXModuleList::const_iterator const end = theModuleList.end(); + LyXModuleList::const_iterator it = theModuleList.begin(); + for (; it != end; ++it) { + string const module = it->getID(); + LayoutModuleList m; + // FIXME this excludes all modules that depend on another one + if (!m.moduleCanBeAdded(module, &baseClass)) + continue; + m.push_back(module); + modules[module] = getDocumentClass(baseClass, m); + } + init = false; + } + + // 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 + // command with the same name. + ModuleMap::iterator const end = modules.end(); + for (ModuleMap::iterator it = modules.begin(); it != end; ++it) { + string const module = it->first; + if (!used_modules.moduleCanBeAdded(module, &baseClass)) + continue; + if (findLayoutWithoutModule(textclass, name, command)) + continue; + if (findInsetLayoutWithoutModule(textclass, name, command)) + continue; + DocumentClassConstPtr c = it->second; + Layout const * layout = findLayoutWithoutModule(*c, name, command); + InsetLayout const * insetlayout = layout ? 0 : + findInsetLayoutWithoutModule(*c, name, command); + docstring preamble; + if (layout) + preamble = layout->preamble(); + else if (insetlayout) + preamble = insetlayout->preamble(); + if (preamble.empty()) + continue; + bool add = false; + if (command) { + FullCommand const & cmd = + possible_textclass_commands['\\' + name]; + if (preamble.find(cmd.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; + } + if (add) { + FileName layout_file = libFileSearch("layouts", module, "module"); + if (textclass.read(layout_file, TextClass::MODULE)) { + used_modules.push_back(module); + // speed up further searches: + // the module does not need to be checked anymore. + modules.erase(it); + return true; + } + } + } + failed[command].insert(name); + return false; } bool noweb_mode = false; +bool pdflatex = false; +bool xetex = false; +bool have_CJK = false; +bool roundtrip = false; namespace { @@ -177,11 +355,20 @@ void read_command(Parser & p, string command, CommandMap & commands) string const arg = p.getArg('{', '}'); if (arg == "translate") arguments.push_back(required); + else if (arg == "group") + arguments.push_back(req_group); + else if (arg == "item") + arguments.push_back(item); + else if (arg == "displaymath") + arguments.push_back(displaymath); else arguments.push_back(verbatim); } else { - p.getArg('[', ']'); - arguments.push_back(optional); + string const arg = p.getArg('[', ']'); + if (arg == "group") + arguments.push_back(opt_group); + else + arguments.push_back(optional); } } commands[command] = arguments; @@ -274,14 +461,35 @@ int parse_help(string const &, string const &) "\t-f Force overwrite of .lyx files.\n" "\t-help Print this message and quit.\n" "\t-n translate a noweb (aka literate programming) file.\n" - "\t-s syntaxfile read additional syntax file.\n" - "\t-sysdir dir Set system directory to DIR.\n" - "\t-userdir DIR Set user directory to DIR." + "\t-roundtrip re-export created .lyx file infile.lyx.lyx to infile.lyx.tex.\n" + "\t-s syntaxfile read additional syntax file.\n" + "\t-sysdir SYSDIR Set system directory to SYSDIR.\n" + "\t Default: " << package().system_support() << "\n" + "\t-userdir USERDIR Set user directory to USERDIR.\n" + "\t Default: " << package().user_support() << "\n" + "\t-version Summarize version and build info.\n" + "Paths:\n" + "\tThe program searches for the files \"encodings\", \"lyxmodules.lst\",\n" + "\t\"textclass.lst\", \"syntax.default\", and \"unicodesymbols\", first in\n" + "\t\"USERDIR\", then in \"SYSDIR\". The subdirectories \"USERDIR/layouts\"\n" + "\tand \"SYSDIR/layouts\" are searched for layout and module files.\n" + "Check the tex2lyx man page for more details." << endl; exit(error_code); } +int parse_version(string const &, string const &) +{ + lyxerr << "tex2lyx " << lyx_version + << " (" << lyx_release_date << ")" << endl; + lyxerr << "Built on " << __DATE__ << ", " << __TIME__ << endl; + + lyxerr << lyx_version_info << endl; + exit(error_code); +} + + void error_message(string const & message) { cerr << "tex2lyx: " << message << "\n\n"; @@ -355,19 +563,31 @@ int parse_noweb(string const &, string const &) } +int parse_roundtrip(string const &, string const &) +{ + roundtrip = true; + return 0; +} + + void easyParse(int & argc, char * argv[]) { map cmdmap; + cmdmap["-h"] = parse_help; + cmdmap["-help"] = parse_help; + cmdmap["--help"] = parse_help; + cmdmap["-v"] = parse_version; + cmdmap["-version"] = parse_version; + cmdmap["--version"] = parse_version; cmdmap["-c"] = parse_class; cmdmap["-e"] = parse_encoding; cmdmap["-f"] = parse_force; cmdmap["-s"] = parse_syntaxfile; - cmdmap["-help"] = parse_help; - cmdmap["--help"] = parse_help; cmdmap["-n"] = parse_noweb; cmdmap["-sysdir"] = parse_sysdir; cmdmap["-userdir"] = parse_userdir; + cmdmap["-roundtrip"] = parse_roundtrip; for (int i = 1; i < argc; ++i) { map::const_iterator it @@ -381,13 +601,14 @@ void easyParse(int & argc, char * argv[]) continue; } - string arg(to_utf8(from_local8bit((i + 1 < argc) ? argv[i + 1] : ""))); - string arg2(to_utf8(from_local8bit((i + 2 < argc) ? argv[i + 2] : ""))); + 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]; @@ -426,19 +647,29 @@ namespace { * You must ensure that \p parentFilePath is properly set before calling * this function! */ -void tex2lyx(idocstream & is, ostream & os, string const & encoding) +bool tex2lyx(idocstream & is, ostream & os, string encoding) { + // Set a sensible default encoding. + // This is used until an encoding command is found. + // For child documents use the encoding of the master, else latin1, + // since latin1 does not cause an iconv error if the actual encoding + // is different (bug 7509). + if (encoding.empty()) { + if (preamble.inputencoding() == "auto") + encoding = "latin1"; + else + encoding = preamble.inputencoding(); + } + Parser p(is); - if (!encoding.empty()) - p.setEncoding(encoding); + p.setEncoding(encoding); //p.dump(); - stringstream ss; - TeX2LyXDocClass textclass; - parse_preamble(p, ss, documentclass, textclass); + preamble.parse(p, documentclass, textclass); active_environments.push_back("document"); Context context(true, textclass); + stringstream ss; parse_text(p, ss, FLAG_END, true, context); if (Context::empty) // Empty document body. LyX needs at least one paragraph. @@ -446,6 +677,19 @@ void tex2lyx(idocstream & is, ostream & os, string const & encoding) context.check_end_layout(ss); ss << "\n\\end_body\n\\end_document\n"; active_environments.pop_back(); + + // We know the used modules only after parsing the full text + if (!used_modules.empty()) { + LayoutModuleList::const_iterator const end = used_modules.end(); + LayoutModuleList::const_iterator it = used_modules.begin(); + for (; it != end; ++it) + preamble.addModule(*it); + } + if (!preamble.writeLyXHeader(os, !active_environments.empty())) { + cerr << "Could write LyX file header." << endl; + return false; + } + ss.seekg(0); os << ss.str(); #ifdef TEST_PARSER @@ -455,6 +699,7 @@ void tex2lyx(idocstream & is, ostream & os, string const & encoding) parsertest << p.get_token().asInput(); // and parsertest.tex should now have identical content #endif + return true; } @@ -471,10 +716,10 @@ bool tex2lyx(FileName const & infilename, ostream & os, string const & encoding) return false; } string const oldParentFilePath = parentFilePath; - parentFilePath = onlyPath(infilename.absFilename()); - tex2lyx(is, os, encoding); + parentFilePath = onlyPath(infilename.absFileName()); + bool retval = tex2lyx(is, os, encoding); parentFilePath = oldParentFilePath; - return true; + return retval; } } // anonymous namespace @@ -508,6 +753,29 @@ bool tex2lyx(string const & infilename, FileName const & outfilename, return tex2lyx(FileName(infilename), os, encoding); } + +bool tex2tex(string const & infilename, FileName const & outfilename, + string const & encoding) +{ + if (!tex2lyx(infilename, outfilename, encoding)) + return false; + string command = quoteName(package().lyx_binary().toFilesystemEncoding()); + if (overwrite_files) + command += " -f main"; + else + command += " -f none"; + if (pdflatex) + command += " -e pdflatex "; + else + command += " -e latex "; + command += quoteName(outfilename.toFilesystemEncoding()); + Systemcall one; + if (one.startscript(Systemcall::Wait, command) == 0) + return true; + cerr << "Error: Running '" << command << "' failed." << endl; + return false; +} + } // namespace lyx @@ -519,33 +787,52 @@ int main(int argc, char * argv[]) lyxerr.setStream(cerr); + os::init(argc, argv); + + try { + init_package(internal_path(os::utf8_argv(0)), string(), string()); + } catch (ExceptionMessage const & message) { + cerr << to_utf8(message.title_) << ":\n" + << to_utf8(message.details_) << endl; + if (message.type_ == ErrorException) + return EXIT_FAILURE; + } + easyParse(argc, argv); if (argc <= 1) error_message("Not enough arguments."); - os::init(argc, argv); try { - init_package(internal_path(to_utf8(from_local8bit(argv[0]))), - cl_system_support, cl_user_support, - top_build_dir_is_two_levels_up); + init_package(internal_path(os::utf8_argv(0)), + cl_system_support, cl_user_support); } catch (ExceptionMessage const & message) { cerr << to_utf8(message.title_) << ":\n" << to_utf8(message.details_) << endl; if (message.type_ == ErrorException) - exit(1); + return EXIT_FAILURE; } // Now every known option is parsed. Look for input and output // file name (the latter is optional). - string infilename = internal_path(to_utf8(from_local8bit(argv[1]))); - infilename = makeAbsPath(infilename).absFilename(); + string infilename = internal_path(os::utf8_argv(1)); + infilename = makeAbsPath(infilename).absFileName(); string outfilename; - if (argc > 2) { - outfilename = internal_path(to_utf8(from_local8bit(argv[2]))); + if (roundtrip) { + if (argc > 2) { + // Do not allow a user supplied output filename + // (otherwise it could easily happen that LyX would + // overwrite the original .tex file) + cerr << "Error: output filename must not be given in roundtrip mode." + << endl; + return EXIT_FAILURE; + } + outfilename = changeExtension(infilename, ".lyx.lyx"); + } else if (argc > 2) { + outfilename = internal_path(os::utf8_argv(2)); if (outfilename != "-") - outfilename = makeAbsPath(outfilename).absFilename(); + outfilename = makeAbsPath(outfilename).absFileName(); } else outfilename = changeExtension(infilename, ".lyx"); @@ -553,7 +840,7 @@ int main(int argc, char * argv[]) FileName const system_syntaxfile = libFileSearch("", "syntax.default"); if (system_syntaxfile.empty()) { cerr << "Error: Could not find syntax file \"syntax.default\"." << endl; - exit(1); + return EXIT_FAILURE; } read_syntaxfile(system_syntaxfile); if (!syntaxfile.empty()) @@ -564,32 +851,37 @@ int main(int argc, char * argv[]) if (symbols_path.empty()) { cerr << "Error: Could not find file \"unicodesymbols\"." << endl; - exit(1); + return EXIT_FAILURE; } FileName const enc_path = libFileSearch(string(), "encodings"); if (enc_path.empty()) { cerr << "Error: Could not find file \"encodings\"." << endl; - exit(1); + return EXIT_FAILURE; } encodings.read(enc_path, symbols_path); if (!default_encoding.empty() && !encodings.fromLaTeXName(default_encoding)) error_message("Unknown LaTeX encoding `" + default_encoding + "'"); + // Load the layouts + LayoutFileList::get().read(); + //...and the modules + theModuleList.read(); + // The real work now. masterFilePath = onlyPath(infilename); parentFilePath = masterFilePath; if (outfilename == "-") { if (tex2lyx(FileName(infilename), cout, default_encoding)) return EXIT_SUCCESS; - else - return EXIT_FAILURE; + } else if (roundtrip) { + if (tex2tex(infilename, FileName(outfilename), default_encoding)) + return EXIT_SUCCESS; } else { if (tex2lyx(infilename, FileName(outfilename), default_encoding)) return EXIT_SUCCESS; - else - return EXIT_FAILURE; } + return EXIT_FAILURE; } // }])