X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftex2lyx%2Ftex2lyx.cpp;h=2ef209fc42305fc03731aa0a84da5197c6637535;hb=5bfd1c22d25e992ff0519931e1fb5590fc1e9024;hp=8f373d83edb59a699e8ef5e4a22978dfcfd02f5a;hpb=d3c385de20d3204c1aa4d7f41297554f09fc1881;p=lyx.git diff --git a/src/tex2lyx/tex2lyx.cpp b/src/tex2lyx/tex2lyx.cpp index 8f373d83ed..2ef209fc42 100644 --- a/src/tex2lyx/tex2lyx.cpp +++ b/src/tex2lyx/tex2lyx.cpp @@ -11,6 +11,7 @@ // {[( #include +#include #include "tex2lyx.h" @@ -20,20 +21,20 @@ #include "LayoutFile.h" #include "LayoutModuleList.h" #include "ModuleList.h" +#include "Preamble.h" #include "TextClass.h" #include "support/convert.h" -#include "support/debug.h" #include "support/ExceptionMessage.h" #include "support/filetools.h" #include "support/lassert.h" #include "support/lstrings.h" -#include "support/Messages.h" #include "support/os.h" #include "support/Package.h" #include "support/Systemcall.h" #include +#include #include #include #include @@ -46,52 +47,9 @@ 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 translation support -Messages messages_; -Messages const & getMessages(std::string const &) -{ - return messages_; -} - - -Messages const & getGuiMessages() -{ - return messages_; -} - - -// Keep the linker happy on Windows -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"); } @@ -144,9 +102,12 @@ CommandMap known_environments; CommandMap known_math_environments; FullCommandMap possible_textclass_commands; FullEnvironmentMap possible_textclass_environments; +FullCommandMap possible_textclass_theorems; +int const LYX_FORMAT = LYX_FORMAT_TEX2LYX; /// used modules LayoutModuleList used_modules; +vector preloaded_modules; void convertArgs(string const & o1, bool o2, vector & arguments) @@ -198,6 +159,17 @@ void add_known_environment(string const & environment, string const & o1, } +void add_known_theorem(string const & theorem, string const & o1, + bool o2, docstring const & definition) +{ + vector arguments; + convertArgs(o1, o2, arguments); + if (!definition.empty()) + possible_textclass_theorems[theorem] = + FullCommand(arguments, definition); +} + + Layout const * findLayoutWithoutModule(TextClass const & textclass, string const & name, bool command) { @@ -227,45 +199,142 @@ InsetLayout const * findInsetLayoutWithoutModule(TextClass const & textclass, } -bool checkModule(string const & name, bool command) -{ - // Cache to avoid slowdown by repated searches - static set failed[2]; +namespace { - // 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; +typedef map ModuleMap; +ModuleMap modules; + + +bool addModule(string const & module, LayoutFile const & baseClass, LayoutModuleList & m, vector & visited) +{ + // avoid endless loop for circular dependency + vector::const_iterator const vb = visited.begin(); + vector::const_iterator const ve = visited.end(); + if (find(vb, ve, module) != ve) { + cerr << "Circular dependency detected for module " << module << '\n'; + return false; } - if (failed[command].find(name) != failed[command].end()) + LyXModule const * const lm = theModuleList[module]; + if (!lm) { + cerr << "Could not find module " << module << " in module list.\n"; return false; + } + bool foundone = false; + LayoutModuleList::const_iterator const exclmodstart = baseClass.excludedModules().begin(); + LayoutModuleList::const_iterator const exclmodend = baseClass.excludedModules().end(); + LayoutModuleList::const_iterator const provmodstart = baseClass.providedModules().begin(); + LayoutModuleList::const_iterator const provmodend = baseClass.providedModules().end(); + vector const reqs = lm->getRequiredModules(); + if (reqs.empty()) + foundone = true; + else { + LayoutModuleList::const_iterator mit = m.begin(); + LayoutModuleList::const_iterator men = m.end(); + vector::const_iterator rit = reqs.begin(); + vector::const_iterator ren = reqs.end(); + for (; rit != ren; ++rit) { + if (find(mit, men, *rit) != men) { + foundone = true; + break; + } + if (find(provmodstart, provmodend, *rit) != provmodend) { + foundone = true; + break; + } + } + if (!foundone) { + visited.push_back(module); + for (rit = reqs.begin(); rit != ren; ++rit) { + if (find(exclmodstart, exclmodend, *rit) == exclmodend) { + if (addModule(*rit, baseClass, m, visited)) { + foundone = true; + break; + } + } + } + visited.pop_back(); + } + } + if (!foundone) { + cerr << "Could not add required modules for " << module << ".\n"; + return false; + } + if (!m.moduleCanBeAdded(module, &baseClass)) + return false; + m.push_back(module); + return true; +} + +void initModules() +{ // 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(); - DocumentClassBundle & bundle = DocumentClassBundle::get(); LyXModuleList::const_iterator const end = theModuleList.end(); LyXModuleList::const_iterator it = theModuleList.begin(); - for (; it != end; it++) { + 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)) + vector v; + if (!addModule(module, baseClass, m, v)) continue; - m.push_back(module); - modules[module] = &bundle.makeDocumentClass(baseClass, m); + modules[module] = getDocumentClass(baseClass, m); } init = false; } +} + + +bool addModule(string const & module) +{ + initModules(); + LayoutFile const & baseClass = LayoutFileList::get()[textclass.name()]; + if (!used_modules.moduleCanBeAdded(module, &baseClass)) + return false; + 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. + ModuleMap::iterator const it = modules.find(module); + if (it != modules.end()) + modules.erase(it); + return true; + } + return false; +} + +} + + +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 + bool theorem = false; + 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()) { + if (possible_textclass_theorems.find(name) != possible_textclass_theorems.end()) + theorem = true; + else + return false; + } + } + if (failed[command].find(name) != failed[command].end()) + return false; + + initModules(); + 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 @@ -275,15 +344,15 @@ bool checkModule(string const & name, bool command) // 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++) { + for (ModuleMap::iterator it = modules.begin(); it != end; ++it) { string const module = it->first; - if (!used_modules.moduleCanBeAdded(module, &baseClass)) + if (used_modules.moduleConflicts(module, &baseClass)) continue; if (findLayoutWithoutModule(textclass, name, command)) continue; if (findInsetLayoutWithoutModule(textclass, name, command)) continue; - DocumentClass const * c = it->second; + DocumentClassConstPtr c = it->second; Layout const * layout = findLayoutWithoutModule(*c, name, command); InsetLayout const * insetlayout = layout ? 0 : findInsetLayoutWithoutModule(*c, name, command); @@ -300,6 +369,11 @@ bool checkModule(string const & name, bool command) 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]; @@ -323,8 +397,17 @@ bool checkModule(string const & name, bool command) } +bool isProvided(string const & name) +{ + // This works only for features that are named like the LaTeX packages + return textclass.provides(name) || preamble.isPackageUsed(name); +} + + bool noweb_mode = false; bool pdflatex = false; +bool xetex = false; +bool is_nonCJKJapanese = false; bool roundtrip = false; @@ -347,13 +430,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; @@ -404,7 +494,7 @@ void read_syntaxfile(FileName const & file_name) // modeled after TeX. // Unknown tokens are just silently ignored, this helps us to skip some // reLyX specific things. - Parser p(is); + Parser p(is, string()); while (p.good()) { Token const & t = p.get_token(); if (t.cat() == catEscape) { @@ -429,8 +519,11 @@ void read_syntaxfile(FileName const & file_name) string documentclass; string default_encoding; +bool fixed_encoding = false; string syntaxfile; +bool copy_files = false; bool overwrite_files = false; +bool skip_children = false; int error_code = 0; /// return the number of arguments consumed @@ -439,18 +532,43 @@ typedef int (*cmd_helper)(string const &, string const &); 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" + "\t-copyfiles Copy all included files to the directory of outfile.lyx.\n" "\t-e encoding Set the default encoding (latex name).\n" + "\t-fixedenc encoding Like -e, but ignore encoding changing commands while parsing.\n" "\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-n translate literate programming (noweb, sweave,... ) file.\n" + "\t-skipchildren Do not translate included child documents.\n" "\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 dir Set system directory to DIR.\n" - "\t-userdir DIR Set user directory to DIR." + "\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 &) +{ + cout << "tex2lyx " << lyx_version + << " (" << lyx_release_date << ")" << endl; + cout << "Built on " << lyx_build_date << ", " << lyx_build_time << endl; + + cout << lyx_version_info << endl; exit(error_code); } @@ -472,6 +590,15 @@ int parse_class(string const & arg, string const &) } +int parse_module(string const & arg, string const &) +{ + if (arg.empty()) + error_message("Missing modules string after -m switch"); + split(arg, preloaded_modules, ','); + return 1; +} + + int parse_encoding(string const & arg, string const &) { if (arg.empty()) @@ -481,6 +608,16 @@ int parse_encoding(string const & arg, string const &) } +int parse_fixed_encoding(string const & arg, string const &) +{ + if (arg.empty()) + error_message("Missing encoding string after -fixedenc switch"); + default_encoding = arg; + fixed_encoding = true; + return 1; +} + + int parse_syntaxfile(string const & arg, string const &) { if (arg.empty()) @@ -528,6 +665,13 @@ int parse_noweb(string const &, string const &) } +int parse_skipchildren(string const &, string const &) +{ + skip_children = true; + return 0; +} + + int parse_roundtrip(string const &, string const &) { roundtrip = true; @@ -535,20 +679,35 @@ int parse_roundtrip(string const &, string const &) } +int parse_copyfiles(string const &, string const &) +{ + copy_files = 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["-m"] = parse_module; cmdmap["-e"] = parse_encoding; + cmdmap["-fixedenc"] = parse_fixed_encoding; cmdmap["-f"] = parse_force; cmdmap["-s"] = parse_syntaxfile; - cmdmap["-help"] = parse_help; - cmdmap["--help"] = parse_help; cmdmap["-n"] = parse_noweb; + cmdmap["-skipchildren"] = parse_skipchildren; cmdmap["-sysdir"] = parse_sysdir; cmdmap["-userdir"] = parse_userdir; cmdmap["-roundtrip"] = parse_roundtrip; + cmdmap["-copyfiles"] = parse_copyfiles; for (int i = 1; i < argc; ++i) { map::const_iterator it @@ -579,21 +738,62 @@ void easyParse(int & argc, char * argv[]) // path of the first parsed file -string masterFilePath; +string masterFilePathLyX; +string masterFilePathTeX; // path of the currently parsed file -string parentFilePath; +string parentFilePathTeX; } // anonymous namespace -string getMasterFilePath() +string getMasterFilePath(bool input) +{ + return input ? masterFilePathTeX : masterFilePathLyX; +} + +string getParentFilePath(bool input) +{ + if (input) + return parentFilePathTeX; + string const rel = to_utf8(makeRelPath(from_utf8(masterFilePathTeX), + from_utf8(parentFilePathTeX))); + if (rel.substr(0, 3) == "../") { + // The parent is not below the master - keep the path + return parentFilePathTeX; + } + return makeAbsPath(rel, masterFilePathLyX).absFileName(); +} + + +bool copyFiles() +{ + return copy_files; +} + + +bool overwriteFiles() { - return masterFilePath; + return overwrite_files; } -string getParentFilePath() + +bool skipChildren() +{ + return skip_children; +} + + +bool roundtripMode() +{ + return roundtrip; +} + + +string fixedEncoding() { - return parentFilePath; + if (fixed_encoding) + return default_encoding; + return ""; } @@ -605,22 +805,60 @@ namespace { * be used more than once for included documents. * Caution: Overwrites the existing preamble settings if the new document * contains a preamble. - * You must ensure that \p parentFilePath is properly set before calling + * You must ensure that \p parentFilePathTeX is properly set before calling * this function! */ -void tex2lyx(idocstream & is, ostream & os, string const & encoding) +bool tex2lyx(idocstream & is, ostream & os, string encoding) { - Parser p(is); - if (!encoding.empty()) - p.setEncoding(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 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(); - ostringstream ps; - parse_preamble(p, ps, documentclass, textclass); + preamble.parse(p, documentclass, textclass); + list removed_modules; + LayoutFile const & baseClass = LayoutFileList::get()[textclass.name()]; + if (!used_modules.adaptToBaseClass(&baseClass, removed_modules)) { + cerr << "Could not load default modules for text class." << endl; + return false; + } + + // Load preloaded modules. + // This needs to be done after the preamble is parsed, since the text + // class may not be known before. It neds to be done before parsing + // body, since otherwise the commands/environments provided by the + // modules would be parsed as ERT. + for (size_t i = 0; i < preloaded_modules.size(); ++i) { + if (!addModule(preloaded_modules[i])) { + cerr << "Error: Could not load module \"" + << preloaded_modules[i] << "\"." << endl; + return false; + } + } + // Ensure that the modules are not loaded again for included files + preloaded_modules.clear(); active_environments.push_back("document"); Context context(true, textclass); stringstream ss; + // store the document language in the context to be able to handle the + // commands like \foreignlanguage and \textenglish etc. + context.font.language = preamble.defaultLanguage(); + // parse the main text parse_text(p, ss, FLAG_END, true, context); if (Context::empty) // Empty document body. LyX needs at least one paragraph. @@ -630,16 +868,16 @@ void tex2lyx(idocstream & is, ostream & os, string const & encoding) active_environments.pop_back(); // We know the used modules only after parsing the full text - ostringstream ms; if (!used_modules.empty()) { - ms << "\\begin_modules\n"; LayoutModuleList::const_iterator const end = used_modules.end(); LayoutModuleList::const_iterator it = used_modules.begin(); - for (; it != end; it++) - ms << *it << '\n'; - ms << "\\end_modules\n"; + for (; it != end; ++it) + preamble.addModule(*it); + } + if (!preamble.writeLyXHeader(os, !active_environments.empty())) { + cerr << "Could not write LyX file header." << endl; + return false; } - os << subst(ps.str(), modules_placeholder, ms.str()); ss.seekg(0); os << ss.str(); @@ -650,6 +888,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; } @@ -665,17 +904,17 @@ bool tex2lyx(FileName const & infilename, ostream & os, string const & encoding) << "\" for reading." << endl; return false; } - string const oldParentFilePath = parentFilePath; - parentFilePath = onlyPath(infilename.absFileName()); - tex2lyx(is, os, encoding); - parentFilePath = oldParentFilePath; - return true; + string const oldParentFilePath = parentFilePathTeX; + parentFilePathTeX = onlyPath(infilename.absFileName()); + bool retval = tex2lyx(is, os, encoding); + parentFilePathTeX = oldParentFilePath; + return retval; } } // anonymous namespace -bool tex2lyx(string const & infilename, FileName const & outfilename, +bool tex2lyx(string const & infilename, FileName const & outfilename, string const & encoding) { if (outfilename.isReadableFile()) { @@ -716,6 +955,8 @@ bool tex2tex(string const & infilename, FileName const & outfilename, command += " -f none"; if (pdflatex) command += " -e pdflatex "; + else if (xetex) + command += " -e xetex "; else command += " -e latex "; command += quoteName(outfilename.toFilesystemEncoding()); @@ -739,15 +980,23 @@ int main(int argc, char * argv[]) 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) + if (argc <= 1) error_message("Not enough arguments."); try { init_package(internal_path(os::utf8_argv(0)), - cl_system_support, cl_user_support, - top_build_dir_is_two_levels_up); + cl_system_support, cl_user_support); } catch (ExceptionMessage const & message) { cerr << to_utf8(message.title_) << ":\n" << to_utf8(message.details_) << endl; @@ -761,20 +1010,28 @@ int main(int argc, char * argv[]) infilename = makeAbsPath(infilename).absFileName(); string outfilename; - 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) { + if (argc > 2) { outfilename = internal_path(os::utf8_argv(2)); if (outfilename != "-") outfilename = makeAbsPath(outfilename).absFileName(); + if (roundtrip) { + if (outfilename == "-") { + cerr << "Error: Writing to standard output is " + "not supported in roundtrip mode." + << endl; + return EXIT_FAILURE; + } + string texfilename = changeExtension(outfilename, ".tex"); + if (equivalent(FileName(infilename), FileName(texfilename))) { + cerr << "Error: The input file `" << infilename + << "´ would be overwritten by the TeX file exported from `" + << outfilename << "´ in roundtrip mode." << endl; + return EXIT_FAILURE; + } + } + } else if (roundtrip) { + // avoid overwriting the input file + outfilename = changeExtension(infilename, ".lyx.lyx"); } else outfilename = changeExtension(infilename, ".lyx"); @@ -791,19 +1048,24 @@ int main(int argc, char * argv[]) // Read the encodings table. FileName const symbols_path = libFileSearch(string(), "unicodesymbols"); if (symbols_path.empty()) { - cerr << "Error: Could not find file \"unicodesymbols\"." + cerr << "Error: Could not find file \"unicodesymbols\"." << endl; return EXIT_FAILURE; } FileName const enc_path = libFileSearch(string(), "encodings"); if (enc_path.empty()) { - cerr << "Error: Could not find file \"encodings\"." + cerr << "Error: Could not find file \"encodings\"." << endl; return EXIT_FAILURE; } encodings.read(enc_path, symbols_path); - if (!default_encoding.empty() && !encodings.fromLaTeXName(default_encoding)) - error_message("Unknown LaTeX encoding `" + default_encoding + "'"); + if (!default_encoding.empty()) { + Encoding const * const enc = encodings.fromLaTeXName( + default_encoding, Encoding::any, true); + if (!enc) + error_message("Unknown LaTeX encoding `" + default_encoding + "'"); + default_encoding = enc->iconvName(); + } // Load the layouts LayoutFileList::get().read(); @@ -811,17 +1073,32 @@ int main(int argc, char * argv[]) theModuleList.read(); // The real work now. - masterFilePath = onlyPath(infilename); - parentFilePath = masterFilePath; + masterFilePathTeX = onlyPath(infilename); + parentFilePathTeX = masterFilePathTeX; if (outfilename == "-") { + // assume same directory as input file + masterFilePathLyX = masterFilePathTeX; if (tex2lyx(FileName(infilename), cout, default_encoding)) return EXIT_SUCCESS; - } else if (roundtrip) { - if (tex2tex(infilename, FileName(outfilename), default_encoding)) - return EXIT_SUCCESS; } else { - if (tex2lyx(infilename, FileName(outfilename), default_encoding)) - return EXIT_SUCCESS; + masterFilePathLyX = onlyPath(outfilename); + if (copy_files) { + FileName const path(masterFilePathLyX); + if (!path.isDirectory()) { + if (!path.createPath()) { + cerr << "Warning: Could not create directory for file `" + << masterFilePathLyX << "´." << endl; + return EXIT_FAILURE; + } + } + } + if (roundtrip) { + if (tex2tex(infilename, FileName(outfilename), default_encoding)) + return EXIT_SUCCESS; + } else { + if (tex2lyx(infilename, FileName(outfilename), default_encoding)) + return EXIT_SUCCESS; + } } return EXIT_FAILURE; }