#include "Preamble.h"
#include "TextClass.h"
+#include "support/ConsoleApplication.h"
#include "support/convert.h"
#include "support/ExceptionMessage.h"
#include "support/filetools.h"
#include <cstdlib>
#include <algorithm>
+#include <exception>
#include <iostream>
#include <string>
#include <sstream>
}
-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;
}
return false;
}
-}
+} // namespace
bool checkModule(string const & name, bool command)
// Cache to avoid slowdown by repated searches
static set<string> 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())
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<string> potential_modules;
ModuleMap::iterator const end = modules.end();
for (ModuleMap::iterator it = modules.begin(); it != end; ++it) {
string const module = it->first;
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<std::string> cmd_reqs;
+ bool found_style = false;
+ if (layout) {
+ found_style = true;
+ dpre = layout->preamble();
+ std::set<std::string> lreqs = layout->requires();
+ if (!lreqs.empty())
+ cmd_reqs.insert(lreqs.begin(), lreqs.end());
+ } else if (insetlayout) {
+ found_style = true;
+ dpre = insetlayout->preamble();
+ std::set<std::string> 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<std::string> 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<string> 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;
}
}
* 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.
}
}
}
+ return true;
}
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"
"\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());
}
}
-void easyParse(int & argc, char * argv[])
+void TeX2LyXApp::easyParse()
{
map<string, cmd_helper> cmdmap;
cmdmap["-roundtrip"] = parse_roundtrip;
cmdmap["-copyfiles"] = parse_copyfiles;
- for (int i = 1; i < argc; ++i) {
+ for (int i = 1; i < argc_; ++i) {
map<string, cmd_helper>::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;
}
}
}
-string fixedEncoding()
-{
- if (fixed_encoding)
- return default_encoding;
- return "";
-}
-
-
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();
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);
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;
}
/// 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
}
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;
}
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() + '/');
}
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());
return EXIT_FAILURE;
}
- easyParse(argc, argv);
+ easyParse();
- if (argc <= 1)
+ if (argc_ <= 1)
error_message("Not enough arguments.");
try {
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();
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");
if (!enc)
error_message("Unknown LaTeX encoding `" + default_encoding + "'");
default_encoding = enc->iconvName();
+ if (fixed_encoding)
+ preamble.setInputencoding(enc->name());
}
// Load the layouts
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);
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();
+}
+
// }])
projects / lyx.git / blobdiff