2003-08-19 10:04:35 +00:00
|
|
|
|
/**
|
2007-04-26 04:53:06 +00:00
|
|
|
|
* \file tex2lyx.cpp
|
2003-08-19 10:04:35 +00:00
|
|
|
|
* This file is part of LyX, the document processor.
|
|
|
|
|
* Licence details can be found in the file COPYING.
|
|
|
|
|
*
|
2008-11-14 15:58:50 +00:00
|
|
|
|
* \author André Pönitz
|
2003-08-19 10:04:35 +00:00
|
|
|
|
*
|
2003-08-23 00:17:00 +00:00
|
|
|
|
* Full author contact details are available in file CREDITS.
|
2003-02-11 12:37:27 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2003-02-12 11:09:22 +00:00
|
|
|
|
// {[(
|
|
|
|
|
|
2003-08-23 00:17:00 +00:00
|
|
|
|
#include <config.h>
|
2011-10-03 17:47:37 +00:00
|
|
|
|
#include <version.h>
|
2003-08-23 00:17:00 +00:00
|
|
|
|
|
2003-04-17 09:47:21 +00:00
|
|
|
|
#include "tex2lyx.h"
|
|
|
|
|
|
2008-04-10 21:49:34 +00:00
|
|
|
|
#include "Context.h"
|
2008-11-16 21:51:18 +00:00
|
|
|
|
#include "Encoding.h"
|
2007-09-29 21:06:50 +00:00
|
|
|
|
#include "Layout.h"
|
2011-01-23 21:10:20 +00:00
|
|
|
|
#include "LayoutFile.h"
|
|
|
|
|
#include "LayoutModuleList.h"
|
|
|
|
|
#include "ModuleList.h"
|
2011-10-30 12:47:45 +00:00
|
|
|
|
#include "Preamble.h"
|
2005-01-27 21:05:44 +00:00
|
|
|
|
|
2015-01-11 13:06:17 +00:00
|
|
|
|
#include "support/ConsoleApplication.h"
|
2005-01-27 21:05:44 +00:00
|
|
|
|
#include "support/convert.h"
|
2020-11-22 22:23:39 +00:00
|
|
|
|
#include "support/debug.h"
|
2007-11-29 07:04:28 +00:00
|
|
|
|
#include "support/ExceptionMessage.h"
|
2003-10-23 11:46:33 +00:00
|
|
|
|
#include "support/filetools.h"
|
2008-11-16 17:02:00 +00:00
|
|
|
|
#include "support/lassert.h"
|
2005-01-06 13:22:20 +00:00
|
|
|
|
#include "support/lstrings.h"
|
2003-07-27 19:26:36 +00:00
|
|
|
|
#include "support/os.h"
|
Rename files in src/support, step one.
src/support/package.h src/support/Package.h Package
src/support/package.C.in src/support/Package.C.in Package
src/support/path.h src/support/Path.h Path
src/support/fs_extras.h src/support/fs_extras.h NOCLASSES
src/support/RandomAccessList.h src/support/RandomAccessList.h RandomAccessList
src/support/lyxmanip.h src/support/lyxmanip.h NOCLASSES
src/support/rename.C src/support/rename.cpp NOCLASSES
src/support/abort.C src/support/abort.cpp NOCLASSES
src/support/lyxlib.h src/support/lyxlib.h NOCLASSES
src/support/ExceptionMessage.h src/support/ExceptionMessage.h ExceptionMessage
src/support/copy.C src/support/copy.cpp NOCLASSES
src/support/limited_stack.h src/support/limited_stack.h limited_stack
src/support/filefilterlist.C src/support/FileFilterList.cpp ['FileFilterList', 'Filter']
src/support/cow_ptr.h src/support/cow_ptr.h cow_ptr
src/support/os_unix.C src/support/os_unix.cpp NOCLASSES
src/support/socktools.h src/support/socktools.h NOCLASSES
src/support/forkedcontr.h src/support/ForkedcallsController.h ForkedcallsController
src/support/os.h src/support/os.h NOCLASSES
src/support/FileMonitor.h src/support/FileMonitor.h FileMonitor
src/support/copied_ptr.h src/support/copied_ptr.h copied_ptr
src/support/translator.h src/support/Translator.h Translator
src/support/filetools.C src/support/filetools.cpp NOCLASSES
src/support/unlink.C src/support/unlink.cpp NOCLASSES
src/support/os_win32.C src/support/os_win32.cpp GetFolderPath
src/support/lstrings.C src/support/lstrings.cpp NOCLASSES
src/support/qstring_helpers.C src/support/qstring_helpers.cpp NOCLASSES
src/support/getcwd.C src/support/getcwd.cpp NOCLASSES
src/support/systemcall.C src/support/Systemcall.cpp Systemcall
src/support/lyxalgo.h src/support/lyxalgo.h NOCLASSES
src/support/filefilterlist.h src/support/FileFilterList.h ['FileFilterList', 'Filter']
src/support/unicode.C src/support/unicode.cpp IconvProcessor
src/support/userinfo.C src/support/userinfo.cpp NOCLASSES
src/support/lyxtime.C src/support/lyxtime.cpp NOCLASSES
src/support/kill.C src/support/kill.cpp NOCLASSES
src/support/docstring.C src/support/docstring.cpp to_local8bit_failure
src/support/os_cygwin.C src/support/os_cygwin.cpp NOCLASSES
src/support/lyxsum.C src/support/lyxsum.cpp NOCLASSES
src/support/environment.C src/support/environment.cpp NOCLASSES
src/support/filetools.h src/support/filetools.h NOCLASSES
src/support/textutils.C src/support/textutils.cpp NOCLASSES
src/support/mkdir.C src/support/mkdir.cpp NOCLASSES
src/support/forkedcall.C src/support/Forkedcall.cpp ['ForkedProcess', 'Forkedcall']
src/support/tempname.C src/support/tempname.cpp NOCLASSES
src/support/os_win32.h src/support/os_win32.h GetFolderPath
src/support/types.h src/support/types.h NOCLASSES
src/support/lstrings.h src/support/lstrings.h NOCLASSES
src/support/forkedcallqueue.C src/support/ForkedCallQueue.cpp ForkedCallQueue
src/support/qstring_helpers.h src/support/qstring_helpers.h NOCLASSES
src/support/convert.C src/support/convert.cpp NOCLASSES
src/support/filename.C src/support/FileName.cpp ['FileName', 'DocFileName']
src/support/tests/convert.C src/support/tests/convert.cpp NOCLASSES
src/support/tests/filetools.C src/support/tests/filetools.cpp NOCLASSES
src/support/tests/lstrings.C src/support/tests/lstrings.cpp NOCLASSES
src/support/tests/boost.C src/support/tests/boost.cpp NOCLASSES
src/support/docstream.C src/support/docstream.cpp ['iconv_codecvt_facet_exception', 'idocfstream', 'odocfstream']
src/support/std_istream.h src/support/std_istream.h NOCLASSES
src/support/systemcall.h src/support/Systemcall.h Systemcall
src/support/chdir.C src/support/chdir.cpp NOCLASSES
src/support/std_ostream.h src/support/std_ostream.h NOCLASSES
src/support/unicode.h src/support/unicode.h IconvProcessor
src/support/path.C src/support/Path.cpp Path
src/support/fs_extras.C src/support/fs_extras.cpp NOCLASSES
src/support/userinfo.h src/support/userinfo.h NOCLASSES
src/support/lyxtime.h src/support/lyxtime.h NOCLASSES
src/support/docstring.h src/support/docstring.h to_local8bit_failure
src/support/debugstream.h src/support/debugstream.h basic_debugstream
src/support/environment.h src/support/environment.h NOCLASSES
src/support/textutils.h src/support/textutils.h NOCLASSES
src/support/forkedcall.h src/support/Forkedcall.h ['ForkedProcess', 'Forkedcall']
src/support/socktools.C src/support/socktools.cpp NOCLASSES
src/support/forkedcallqueue.h src/support/ForkedCallQueue.h ForkedCallQueue
src/support/forkedcontr.C src/support/ForkedcallsController.cpp ForkedcallsController
src/support/os.C src/support/os.cpp NOCLASSES
src/support/convert.h src/support/convert.h NOCLASSES
src/support/filename.h src/support/FileName.h ['FileName', 'DocFileName']
src/support/docstream.h src/support/docstream.h ['iconv_codecvt_facet_exception', 'idocfstream', 'odocfstream']
src/support/FileMonitor.C src/support/FileMonitor.cpp FileMonitor
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@18024 a592a061-630c-0410-9148-cb99ea01b6c8
2007-04-26 05:12:52 +00:00
|
|
|
|
#include "support/Package.h"
|
2010-12-30 20:29:33 +00:00
|
|
|
|
#include "support/Systemcall.h"
|
2003-07-26 00:15:38 +00:00
|
|
|
|
|
2008-03-21 11:26:20 +00:00
|
|
|
|
#include <cstdlib>
|
2012-10-26 20:23:16 +00:00
|
|
|
|
#include <algorithm>
|
2015-01-11 13:06:17 +00:00
|
|
|
|
#include <exception>
|
2003-02-11 12:37:27 +00:00
|
|
|
|
#include <iostream>
|
|
|
|
|
#include <string>
|
2003-06-30 11:36:08 +00:00
|
|
|
|
#include <sstream>
|
2003-02-11 12:37:27 +00:00
|
|
|
|
#include <vector>
|
2003-10-23 11:46:33 +00:00
|
|
|
|
#include <map>
|
2003-02-11 12:37:27 +00:00
|
|
|
|
|
2022-12-29 08:37:00 +00:00
|
|
|
|
// comment out to enable debug_messages
|
|
|
|
|
//#define FILEDEBUG
|
|
|
|
|
|
2007-12-12 10:16:00 +00:00
|
|
|
|
using namespace std;
|
2007-12-12 18:57:56 +00:00
|
|
|
|
using namespace lyx::support;
|
|
|
|
|
using namespace lyx::support::os;
|
2006-10-21 00:16:43 +00:00
|
|
|
|
|
|
|
|
|
namespace lyx {
|
|
|
|
|
|
2011-10-16 08:22:20 +00:00
|
|
|
|
string const trimSpaceAndEol(string const & a)
|
2003-02-11 15:57:08 +00:00
|
|
|
|
{
|
2011-10-16 08:22:20 +00:00
|
|
|
|
return trim(a, " \t\n\r");
|
2003-02-11 15:57:08 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-04-17 09:47:21 +00:00
|
|
|
|
void split(string const & s, vector<string> & result, char delim)
|
2007-11-25 17:55:27 +00:00
|
|
|
|
{
|
2022-12-28 15:29:38 +00:00
|
|
|
|
//warning_message("split 1: '" + s + "'");
|
2003-06-30 11:36:08 +00:00
|
|
|
|
istringstream is(s);
|
2003-02-11 12:37:27 +00:00
|
|
|
|
string t;
|
|
|
|
|
while (getline(is, t, delim))
|
|
|
|
|
result.push_back(t);
|
2022-12-28 15:29:38 +00:00
|
|
|
|
//warning_message("split 2");
|
2003-02-11 12:37:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-03-06 10:39:54 +00:00
|
|
|
|
string join(vector<string> const & input, char const * delim)
|
2003-02-11 12:37:27 +00:00
|
|
|
|
{
|
|
|
|
|
ostringstream os;
|
2007-11-29 07:04:28 +00:00
|
|
|
|
for (size_t i = 0; i != input.size(); ++i) {
|
2003-02-11 12:37:27 +00:00
|
|
|
|
if (i)
|
2003-03-17 16:25:00 +00:00
|
|
|
|
os << delim;
|
|
|
|
|
os << input[i];
|
2003-02-11 12:37:27 +00:00
|
|
|
|
}
|
2003-06-30 11:36:08 +00:00
|
|
|
|
return os.str();
|
2003-02-11 12:37:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-06-28 06:53:12 +00:00
|
|
|
|
char const * const * is_known(string const & str, char const * const * what)
|
2003-02-20 17:05:54 +00:00
|
|
|
|
{
|
|
|
|
|
for ( ; *what; ++what)
|
|
|
|
|
if (str == *what)
|
|
|
|
|
return what;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-02-11 15:57:08 +00:00
|
|
|
|
|
2003-04-17 09:47:21 +00:00
|
|
|
|
// current stack of nested environments
|
2003-04-23 15:14:43 +00:00
|
|
|
|
vector<string> active_environments;
|
2003-02-12 11:09:22 +00:00
|
|
|
|
|
|
|
|
|
|
2003-04-23 15:14:43 +00:00
|
|
|
|
string active_environment()
|
2003-02-11 12:37:27 +00:00
|
|
|
|
{
|
2003-04-23 15:14:43 +00:00
|
|
|
|
return active_environments.empty() ? string() : active_environments.back();
|
2003-02-11 12:37:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-01-23 21:10:20 +00:00
|
|
|
|
TeX2LyXDocClass textclass;
|
2005-07-14 15:19:01 +00:00
|
|
|
|
CommandMap known_commands;
|
|
|
|
|
CommandMap known_environments;
|
|
|
|
|
CommandMap known_math_environments;
|
2011-01-23 21:10:20 +00:00
|
|
|
|
FullCommandMap possible_textclass_commands;
|
|
|
|
|
FullEnvironmentMap possible_textclass_environments;
|
2012-10-26 20:23:16 +00:00
|
|
|
|
FullCommandMap possible_textclass_theorems;
|
2011-10-23 10:29:21 +00:00
|
|
|
|
int const LYX_FORMAT = LYX_FORMAT_TEX2LYX;
|
2003-11-19 10:35:50 +00:00
|
|
|
|
|
2011-01-23 21:10:20 +00:00
|
|
|
|
/// used modules
|
|
|
|
|
LayoutModuleList used_modules;
|
2012-10-23 18:45:21 +00:00
|
|
|
|
vector<string> preloaded_modules;
|
2003-11-19 10:35:50 +00:00
|
|
|
|
|
2011-01-23 21:10:20 +00:00
|
|
|
|
|
|
|
|
|
void convertArgs(string const & o1, bool o2, vector<ArgumentType> & arguments)
|
2005-01-06 13:22:20 +00:00
|
|
|
|
{
|
|
|
|
|
// We have to handle the following cases:
|
|
|
|
|
// definition o1 o2 invocation result
|
|
|
|
|
// \newcommand{\foo}{bar} "" false \foo bar
|
|
|
|
|
// \newcommand{\foo}[1]{bar #1} "[1]" false \foo{x} bar x
|
2005-01-12 10:30:46 +00:00
|
|
|
|
// \newcommand{\foo}[1][]{bar #1} "[1]" true \foo bar
|
2005-01-06 13:22:20 +00:00
|
|
|
|
// \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;
|
|
|
|
|
string const opt1 = rtrim(ltrim(o1, "["), "]");
|
|
|
|
|
if (isStrUnsignedInt(opt1)) {
|
|
|
|
|
// The command has arguments
|
2005-01-27 21:05:44 +00:00
|
|
|
|
nargs = convert<unsigned int>(opt1);
|
2008-04-29 18:11:46 +00:00
|
|
|
|
if (nargs > 0 && o2) {
|
|
|
|
|
// The first argument is optional
|
2005-01-06 13:22:20 +00:00
|
|
|
|
arguments.push_back(optional);
|
|
|
|
|
--nargs;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
for (unsigned int i = 0; i < nargs; ++i)
|
|
|
|
|
arguments.push_back(required);
|
2011-01-23 21:10:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void add_known_command(string const & command, string const & o1,
|
|
|
|
|
bool o2, docstring const & definition)
|
|
|
|
|
{
|
|
|
|
|
vector<ArgumentType> arguments;
|
|
|
|
|
convertArgs(o1, o2, arguments);
|
2005-01-06 13:22:20 +00:00
|
|
|
|
known_commands[command] = arguments;
|
2011-01-23 21:10:20 +00:00
|
|
|
|
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<ArgumentType> arguments;
|
|
|
|
|
convertArgs(o1, o2, arguments);
|
|
|
|
|
known_environments[environment] = arguments;
|
|
|
|
|
if (!beg.empty() || ! end.empty())
|
|
|
|
|
possible_textclass_environments[environment] =
|
|
|
|
|
FullEnvironment(arguments, beg, end);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-10-26 20:23:16 +00:00
|
|
|
|
void add_known_theorem(string const & theorem, string const & o1,
|
|
|
|
|
bool o2, docstring const & definition)
|
|
|
|
|
{
|
|
|
|
|
vector<ArgumentType> arguments;
|
|
|
|
|
convertArgs(o1, o2, arguments);
|
|
|
|
|
if (!definition.empty())
|
|
|
|
|
possible_textclass_theorems[theorem] =
|
|
|
|
|
FullCommand(arguments, definition);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2018-02-24 05:44:26 +00:00
|
|
|
|
Layout const * findLayoutWithoutModule(TextClass const & tc,
|
2018-03-16 11:56:17 +00:00
|
|
|
|
string const & name, bool command,
|
|
|
|
|
string const & latexparam)
|
2011-01-23 21:10:20 +00:00
|
|
|
|
{
|
2018-02-24 05:44:26 +00:00
|
|
|
|
for (auto const & lay : tc) {
|
|
|
|
|
if (lay.latexname() == name &&
|
2018-03-16 11:56:17 +00:00
|
|
|
|
(latexparam.empty() ||
|
|
|
|
|
(!lay.latexparam().empty() && suffixIs(latexparam, lay.latexparam()))) &&
|
2018-02-24 05:44:26 +00:00
|
|
|
|
((command && lay.isCommand()) || (!command && lay.isEnvironment())))
|
|
|
|
|
return &lay;
|
2011-01-23 21:10:20 +00:00
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2018-02-24 05:44:26 +00:00
|
|
|
|
InsetLayout const * findInsetLayoutWithoutModule(TextClass const & tc,
|
2018-03-16 11:56:17 +00:00
|
|
|
|
string const & name, bool command,
|
|
|
|
|
string const & latexparam)
|
2011-01-23 21:10:20 +00:00
|
|
|
|
{
|
2018-02-24 05:44:26 +00:00
|
|
|
|
for (auto const & ilay : tc.insetLayouts()) {
|
|
|
|
|
if (ilay.second.latexname() == name &&
|
2018-03-16 11:56:17 +00:00
|
|
|
|
(latexparam.empty() ||
|
|
|
|
|
(!ilay.second.latexparam().empty() && suffixIs(latexparam, ilay.second.latexparam()))) &&
|
2020-12-06 17:37:38 +00:00
|
|
|
|
((command && ilay.second.latextype() == InsetLaTeXType::COMMAND) ||
|
|
|
|
|
(!command && ilay.second.latextype() == InsetLaTeXType::ENVIRONMENT)))
|
2018-02-24 05:44:26 +00:00
|
|
|
|
return &(ilay.second);
|
2011-01-23 21:10:20 +00:00
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-10-23 18:45:21 +00:00
|
|
|
|
namespace {
|
2011-01-23 21:10:20 +00:00
|
|
|
|
|
2012-10-23 18:45:21 +00:00
|
|
|
|
typedef map<string, DocumentClassPtr> ModuleMap;
|
|
|
|
|
ModuleMap modules;
|
2012-10-26 20:23:16 +00:00
|
|
|
|
|
|
|
|
|
|
2014-07-05 17:13:10 +00:00
|
|
|
|
bool addModule(string const & module, LayoutFile const & baseClass, LayoutModuleList & m, vector<string> & visited)
|
2012-10-26 20:23:16 +00:00
|
|
|
|
{
|
|
|
|
|
// avoid endless loop for circular dependency
|
|
|
|
|
vector<string>::const_iterator const vb = visited.begin();
|
|
|
|
|
vector<string>::const_iterator const ve = visited.end();
|
|
|
|
|
if (find(vb, ve, module) != ve) {
|
2022-12-28 15:29:38 +00:00
|
|
|
|
warning_message("Circular dependency detected for module " + module);
|
2012-10-26 20:23:16 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
LyXModule const * const lm = theModuleList[module];
|
|
|
|
|
if (!lm) {
|
2022-12-28 15:29:38 +00:00
|
|
|
|
warning_message("Could not find module " + module + " in module list.");
|
2012-10-26 20:23:16 +00:00
|
|
|
|
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<string> const reqs = lm->getRequiredModules();
|
|
|
|
|
if (reqs.empty())
|
|
|
|
|
foundone = true;
|
|
|
|
|
else {
|
|
|
|
|
LayoutModuleList::const_iterator mit = m.begin();
|
|
|
|
|
LayoutModuleList::const_iterator men = m.end();
|
|
|
|
|
vector<string>::const_iterator rit = reqs.begin();
|
|
|
|
|
vector<string>::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) {
|
2022-12-28 15:29:38 +00:00
|
|
|
|
warning_message("Could not add required modules for " + module + ".");
|
2012-10-26 20:23:16 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
if (!m.moduleCanBeAdded(module, &baseClass))
|
|
|
|
|
return false;
|
|
|
|
|
m.push_back(module);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-10-23 18:45:21 +00:00
|
|
|
|
void initModules()
|
|
|
|
|
{
|
2011-01-23 21:10:20 +00:00
|
|
|
|
// 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()];
|
|
|
|
|
static bool init = true;
|
|
|
|
|
if (init) {
|
|
|
|
|
baseClass.load();
|
|
|
|
|
LyXModuleList::const_iterator const end = theModuleList.end();
|
|
|
|
|
LyXModuleList::const_iterator it = theModuleList.begin();
|
2012-05-28 20:41:32 +00:00
|
|
|
|
for (; it != end; ++it) {
|
2011-01-23 21:10:20 +00:00
|
|
|
|
string const module = it->getID();
|
|
|
|
|
LayoutModuleList m;
|
2012-10-26 20:23:16 +00:00
|
|
|
|
vector<string> v;
|
|
|
|
|
if (!addModule(module, baseClass, m, v))
|
2011-01-23 21:10:20 +00:00
|
|
|
|
continue;
|
2018-05-20 10:27:03 +00:00
|
|
|
|
modules[module] = getDocumentClass(baseClass, m);
|
2011-01-23 21:10:20 +00:00
|
|
|
|
}
|
|
|
|
|
init = false;
|
|
|
|
|
}
|
2012-10-23 18:45:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2017-07-23 11:11:54 +00:00
|
|
|
|
} // namespace
|
2012-10-23 18:45:21 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool checkModule(string const & name, bool command)
|
|
|
|
|
{
|
|
|
|
|
// Cache to avoid slowdown by repated searches
|
|
|
|
|
static set<string> failed[2];
|
|
|
|
|
|
2019-04-04 13:46:49 +00:00
|
|
|
|
// Record whether the command was actually defined in the LyX preamble
|
2012-10-26 20:23:16 +00:00
|
|
|
|
bool theorem = false;
|
2019-04-04 13:46:49 +00:00
|
|
|
|
bool preamble_def = true;
|
2012-10-23 18:45:21 +00:00
|
|
|
|
if (command) {
|
|
|
|
|
if (possible_textclass_commands.find('\\' + name) == possible_textclass_commands.end())
|
2019-04-04 13:46:49 +00:00
|
|
|
|
preamble_def = false;
|
2012-10-23 18:45:21 +00:00
|
|
|
|
} else {
|
2012-10-26 20:23:16 +00:00
|
|
|
|
if (possible_textclass_environments.find(name) == possible_textclass_environments.end()) {
|
|
|
|
|
if (possible_textclass_theorems.find(name) != possible_textclass_theorems.end())
|
|
|
|
|
theorem = true;
|
|
|
|
|
else
|
2019-04-04 13:46:49 +00:00
|
|
|
|
preamble_def = false;
|
2012-10-26 20:23:16 +00:00
|
|
|
|
}
|
2012-10-23 18:45:21 +00:00
|
|
|
|
}
|
|
|
|
|
if (failed[command].find(name) != failed[command].end())
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
initModules();
|
|
|
|
|
LayoutFile const & baseClass = LayoutFileList::get()[textclass.name()];
|
2011-01-23 21:10:20 +00:00
|
|
|
|
|
|
|
|
|
// Try to find a module that defines the command.
|
2019-04-04 13:46:49 +00:00
|
|
|
|
// 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
|
2011-01-23 21:10:20 +00:00
|
|
|
|
// command with the same name.
|
2019-04-04 13:46:49 +00:00
|
|
|
|
string found_module;
|
|
|
|
|
vector<string> potential_modules;
|
2011-01-23 21:10:20 +00:00
|
|
|
|
ModuleMap::iterator const end = modules.end();
|
2012-05-28 20:41:32 +00:00
|
|
|
|
for (ModuleMap::iterator it = modules.begin(); it != end; ++it) {
|
2011-01-23 21:10:20 +00:00
|
|
|
|
string const module = it->first;
|
2012-10-26 20:23:16 +00:00
|
|
|
|
if (used_modules.moduleConflicts(module, &baseClass))
|
2011-01-23 21:10:20 +00:00
|
|
|
|
continue;
|
|
|
|
|
if (findLayoutWithoutModule(textclass, name, command))
|
|
|
|
|
continue;
|
|
|
|
|
if (findInsetLayoutWithoutModule(textclass, name, command))
|
|
|
|
|
continue;
|
2012-10-23 18:45:21 +00:00
|
|
|
|
DocumentClassConstPtr c = it->second;
|
2011-01-23 21:10:20 +00:00
|
|
|
|
Layout const * layout = findLayoutWithoutModule(*c, name, command);
|
2019-04-04 13:46:49 +00:00
|
|
|
|
InsetLayout const * insetlayout = layout ? nullptr :
|
2011-01-23 21:10:20 +00:00
|
|
|
|
findInsetLayoutWithoutModule(*c, name, command);
|
2018-02-24 05:44:26 +00:00
|
|
|
|
docstring dpre;
|
2019-04-04 13:46:49 +00:00
|
|
|
|
std::set<std::string> cmd_reqs;
|
|
|
|
|
bool found_style = false;
|
|
|
|
|
if (layout) {
|
|
|
|
|
found_style = true;
|
2018-02-24 05:44:26 +00:00
|
|
|
|
dpre = layout->preamble();
|
2020-10-31 13:09:46 +00:00
|
|
|
|
std::set<std::string> const & lreqs = layout->required();
|
2019-04-04 13:46:49 +00:00
|
|
|
|
if (!lreqs.empty())
|
|
|
|
|
cmd_reqs.insert(lreqs.begin(), lreqs.end());
|
|
|
|
|
} else if (insetlayout) {
|
|
|
|
|
found_style = true;
|
2018-02-24 05:44:26 +00:00
|
|
|
|
dpre = insetlayout->preamble();
|
2020-02-28 05:26:31 +00:00
|
|
|
|
std::set<std::string> lreqs = insetlayout->required();
|
2019-04-04 13:46:49 +00:00
|
|
|
|
if (!lreqs.empty())
|
|
|
|
|
cmd_reqs.insert(lreqs.begin(), lreqs.end());
|
|
|
|
|
}
|
|
|
|
|
if (dpre.empty() && preamble_def)
|
2011-01-23 21:10:20 +00:00
|
|
|
|
continue;
|
2019-04-04 13:46:49 +00:00
|
|
|
|
bool const package_cmd = dpre.empty();
|
|
|
|
|
bool match_req = false;
|
|
|
|
|
if (package_cmd) {
|
2020-02-28 05:26:31 +00:00
|
|
|
|
std::set<std::string> mreqs = it->second->required();
|
2019-04-04 13:46:49 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
2011-01-23 21:10:20 +00:00
|
|
|
|
}
|
|
|
|
|
if (add) {
|
2019-04-04 13:46:49 +00:00
|
|
|
|
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))
|
2018-05-24 15:38:10 +00:00
|
|
|
|
return false;
|
2019-04-04 13:46:49 +00:00
|
|
|
|
FileName layout_file = libFileSearch("layouts", mod, "module");
|
|
|
|
|
if (textclass.read(layout_file, TextClass::MODULE)) {
|
|
|
|
|
used_modules.push_back(mod);
|
|
|
|
|
// speed up further searches:
|
|
|
|
|
// the module does not need to be checked anymore.
|
|
|
|
|
ModuleMap::iterator const it = modules.find(mod);
|
|
|
|
|
if (it != modules.end())
|
|
|
|
|
modules.erase(it);
|
|
|
|
|
return true;
|
2011-01-23 21:10:20 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
failed[command].insert(name);
|
|
|
|
|
return false;
|
2005-01-06 13:22:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-12-28 13:29:46 +00:00
|
|
|
|
bool isProvided(string const & name)
|
|
|
|
|
{
|
|
|
|
|
// This works only for features that are named like the LaTeX packages
|
|
|
|
|
return textclass.provides(name) || preamble.isPackageUsed(name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-08-13 09:46:28 +00:00
|
|
|
|
bool noweb_mode = false;
|
2010-12-30 20:29:33 +00:00
|
|
|
|
bool pdflatex = false;
|
2011-11-06 17:03:59 +00:00
|
|
|
|
bool xetex = false;
|
2012-06-24 16:10:36 +00:00
|
|
|
|
bool is_nonCJKJapanese = false;
|
2010-12-30 20:29:33 +00:00
|
|
|
|
bool roundtrip = false;
|
2006-08-13 09:46:28 +00:00
|
|
|
|
|
|
|
|
|
|
2003-11-19 10:35:50 +00:00
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
|
|
|
2005-07-14 15:19:01 +00:00
|
|
|
|
/*!
|
|
|
|
|
* Read one command definition from the syntax file
|
|
|
|
|
*/
|
2007-11-29 07:04:28 +00:00
|
|
|
|
void read_command(Parser & p, string command, CommandMap & commands)
|
|
|
|
|
{
|
2005-07-14 15:19:01 +00:00
|
|
|
|
if (p.next_token().asInput() == "*") {
|
|
|
|
|
p.get_token();
|
|
|
|
|
command += '*';
|
|
|
|
|
}
|
|
|
|
|
vector<ArgumentType> arguments;
|
|
|
|
|
while (p.next_token().cat() == catBegin ||
|
|
|
|
|
p.next_token().asInput() == "[") {
|
|
|
|
|
if (p.next_token().cat() == catBegin) {
|
|
|
|
|
string const arg = p.getArg('{', '}');
|
|
|
|
|
if (arg == "translate")
|
|
|
|
|
arguments.push_back(required);
|
2011-11-13 16:11:45 +00:00
|
|
|
|
else if (arg == "group")
|
|
|
|
|
arguments.push_back(req_group);
|
2010-12-27 20:15:24 +00:00
|
|
|
|
else if (arg == "item")
|
|
|
|
|
arguments.push_back(item);
|
2011-11-13 11:29:48 +00:00
|
|
|
|
else if (arg == "displaymath")
|
|
|
|
|
arguments.push_back(displaymath);
|
2005-07-14 15:19:01 +00:00
|
|
|
|
else
|
|
|
|
|
arguments.push_back(verbatim);
|
|
|
|
|
} else {
|
2011-11-13 16:11:45 +00:00
|
|
|
|
string const arg = p.getArg('[', ']');
|
|
|
|
|
if (arg == "group")
|
|
|
|
|
arguments.push_back(opt_group);
|
|
|
|
|
else
|
|
|
|
|
arguments.push_back(optional);
|
2005-07-14 15:19:01 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
commands[command] = arguments;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Read a class of environments from the syntax file
|
|
|
|
|
*/
|
|
|
|
|
void read_environment(Parser & p, string const & begin,
|
2006-04-05 23:56:29 +00:00
|
|
|
|
CommandMap & environments)
|
2005-07-14 15:19:01 +00:00
|
|
|
|
{
|
|
|
|
|
string environment;
|
|
|
|
|
while (p.good()) {
|
|
|
|
|
Token const & t = p.get_token();
|
|
|
|
|
if (t.cat() == catLetter)
|
|
|
|
|
environment += t.asInput();
|
|
|
|
|
else if (!environment.empty()) {
|
|
|
|
|
p.putback();
|
|
|
|
|
read_command(p, environment, environments);
|
|
|
|
|
environment.erase();
|
|
|
|
|
}
|
|
|
|
|
if (t.cat() == catEscape && t.asInput() == "\\end") {
|
|
|
|
|
string const end = p.getArg('{', '}');
|
|
|
|
|
if (end == begin)
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-11-19 10:35:50 +00:00
|
|
|
|
/*!
|
|
|
|
|
* Read a list of TeX commands from a reLyX compatible syntax file.
|
|
|
|
|
* Since this list is used after all commands that have a LyX counterpart
|
2005-07-16 15:18:14 +00:00
|
|
|
|
* are handled, it does not matter that the "syntax.default" file
|
2003-11-19 10:35:50 +00:00
|
|
|
|
* has almost all of them listed. For the same reason the reLyX-specific
|
|
|
|
|
* reLyXre environment is ignored.
|
|
|
|
|
*/
|
2015-01-09 20:43:45 +00:00
|
|
|
|
bool read_syntaxfile(FileName const & file_name)
|
2003-11-19 10:35:50 +00:00
|
|
|
|
{
|
2008-11-16 17:02:00 +00:00
|
|
|
|
ifdocstream is(file_name.toFilesystemEncoding().c_str());
|
2005-03-27 18:37:42 +00:00
|
|
|
|
if (!is.good()) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Could not open syntax file \""
|
|
|
|
|
+ file_name.absFileName() + "\" for reading.");
|
2015-01-09 20:43:45 +00:00
|
|
|
|
return false;
|
2003-11-19 10:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
// We can use our TeX parser, since the syntax of the layout file is
|
|
|
|
|
// modeled after TeX.
|
|
|
|
|
// Unknown tokens are just silently ignored, this helps us to skip some
|
|
|
|
|
// reLyX specific things.
|
2013-11-11 20:52:14 +00:00
|
|
|
|
Parser p(is, string());
|
2003-11-19 10:35:50 +00:00
|
|
|
|
while (p.good()) {
|
|
|
|
|
Token const & t = p.get_token();
|
|
|
|
|
if (t.cat() == catEscape) {
|
2005-07-14 15:19:01 +00:00
|
|
|
|
string const command = t.asInput();
|
|
|
|
|
if (command == "\\begin") {
|
|
|
|
|
string const name = p.getArg('{', '}');
|
|
|
|
|
if (name == "environments" || name == "reLyXre")
|
|
|
|
|
// We understand "reLyXre", but it is
|
|
|
|
|
// not as powerful as "environments".
|
2006-04-05 23:56:29 +00:00
|
|
|
|
read_environment(p, name,
|
2005-07-14 15:19:01 +00:00
|
|
|
|
known_environments);
|
|
|
|
|
else if (name == "mathenvironments")
|
|
|
|
|
read_environment(p, name,
|
|
|
|
|
known_math_environments);
|
|
|
|
|
} else {
|
|
|
|
|
read_command(p, command, known_commands);
|
2003-11-19 10:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-01-09 20:43:45 +00:00
|
|
|
|
return true;
|
2003-11-19 10:35:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-10-23 11:46:33 +00:00
|
|
|
|
string documentclass;
|
2009-01-30 14:47:06 +00:00
|
|
|
|
string default_encoding;
|
2013-11-11 20:52:14 +00:00
|
|
|
|
bool fixed_encoding = false;
|
2003-11-19 10:35:50 +00:00
|
|
|
|
string syntaxfile;
|
2012-10-03 11:23:27 +00:00
|
|
|
|
bool copy_files = false;
|
2003-10-23 11:46:33 +00:00
|
|
|
|
bool overwrite_files = false;
|
2022-12-28 15:29:38 +00:00
|
|
|
|
bool no_warnings = false;
|
2012-10-18 20:01:32 +00:00
|
|
|
|
bool skip_children = false;
|
2009-04-19 22:13:43 +00:00
|
|
|
|
int error_code = 0;
|
2003-10-23 11:46:33 +00:00
|
|
|
|
|
|
|
|
|
/// return the number of arguments consumed
|
2007-11-27 20:30:22 +00:00
|
|
|
|
typedef int (*cmd_helper)(string const &, string const &);
|
2003-10-23 11:46:33 +00:00
|
|
|
|
|
|
|
|
|
|
2015-01-11 13:06:17 +00:00
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
}
|
2020-10-01 07:42:11 +00:00
|
|
|
|
void doExec() override
|
2015-01-11 13:06:17 +00:00
|
|
|
|
{
|
|
|
|
|
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_;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2003-10-23 11:46:33 +00:00
|
|
|
|
int parse_help(string const &, string const &)
|
2003-02-11 12:37:27 +00:00
|
|
|
|
{
|
2014-11-25 17:41:33 +00:00
|
|
|
|
cout << "Usage: tex2lyx [options] infile.tex [outfile.lyx]\n"
|
2009-04-19 22:13:43 +00:00
|
|
|
|
"Options:\n"
|
|
|
|
|
"\t-c textclass Declare the textclass.\n"
|
2012-10-23 18:45:21 +00:00
|
|
|
|
"\t-m mod1[,mod2...] Load the given modules.\n"
|
2012-10-03 11:23:27 +00:00
|
|
|
|
"\t-copyfiles Copy all included files to the directory of outfile.lyx.\n"
|
2009-04-19 22:13:43 +00:00
|
|
|
|
"\t-e encoding Set the default encoding (latex name).\n"
|
2013-11-11 20:52:14 +00:00
|
|
|
|
"\t-fixedenc encoding Like -e, but ignore encoding changing commands while parsing.\n"
|
2009-04-19 22:13:43 +00:00
|
|
|
|
"\t-f Force overwrite of .lyx files.\n"
|
|
|
|
|
"\t-help Print this message and quit.\n"
|
2022-12-28 15:29:38 +00:00
|
|
|
|
"\t-n Translate literate programming (noweb, sweave,... ) file.\n"
|
|
|
|
|
"\t-q Omit warnings.\n"
|
|
|
|
|
"\t-roundtrip Re-export created .lyx file infile.lyx.lyx to infile.lyx.tex.\n"
|
2012-10-18 20:01:32 +00:00
|
|
|
|
"\t-skipchildren Do not translate included child documents.\n"
|
2022-12-28 15:29:38 +00:00
|
|
|
|
"\t-s syntaxfile Read additional syntax file.\n"
|
2011-10-03 17:47:37 +00:00
|
|
|
|
"\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."
|
2009-04-19 22:13:43 +00:00
|
|
|
|
<< endl;
|
2015-01-11 13:06:17 +00:00
|
|
|
|
throw StopException(error_code);
|
2009-04-19 22:13:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-10-03 17:47:37 +00:00
|
|
|
|
int parse_version(string const &, string const &)
|
|
|
|
|
{
|
2014-11-25 17:41:33 +00:00
|
|
|
|
cout << "tex2lyx " << lyx_version
|
|
|
|
|
<< " (" << lyx_release_date << ")" << endl;
|
2011-10-03 17:47:37 +00:00
|
|
|
|
|
2014-11-25 17:41:33 +00:00
|
|
|
|
cout << lyx_version_info << endl;
|
2015-01-11 13:06:17 +00:00
|
|
|
|
throw StopException(error_code);
|
2011-10-03 17:47:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-12-29 08:37:00 +00:00
|
|
|
|
void error_with_message(string const & message)
|
2009-04-19 22:13:43 +00:00
|
|
|
|
{
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message(message);
|
2015-01-11 13:06:17 +00:00
|
|
|
|
error_code = EXIT_FAILURE;
|
2009-04-19 22:13:43 +00:00
|
|
|
|
parse_help(string(), string());
|
2003-10-23 11:46:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int parse_class(string const & arg, string const &)
|
|
|
|
|
{
|
2009-04-19 22:13:43 +00:00
|
|
|
|
if (arg.empty())
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_with_message("Missing textclass string after -c switch");
|
2003-10-23 11:46:33 +00:00
|
|
|
|
documentclass = arg;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2003-02-11 12:37:27 +00:00
|
|
|
|
|
2003-07-27 19:26:36 +00:00
|
|
|
|
|
2012-10-23 18:45:21 +00:00
|
|
|
|
int parse_module(string const & arg, string const &)
|
|
|
|
|
{
|
|
|
|
|
split(arg, preloaded_modules, ',');
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2009-01-30 14:47:06 +00:00
|
|
|
|
int parse_encoding(string const & arg, string const &)
|
|
|
|
|
{
|
2009-04-19 22:13:43 +00:00
|
|
|
|
if (arg.empty())
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_with_message("Missing encoding string after -e switch");
|
2009-01-30 14:47:06 +00:00
|
|
|
|
default_encoding = arg;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-11-11 20:52:14 +00:00
|
|
|
|
int parse_fixed_encoding(string const & arg, string const &)
|
|
|
|
|
{
|
|
|
|
|
if (arg.empty())
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_with_message("Missing encoding string after -fixedenc switch");
|
2013-11-11 20:52:14 +00:00
|
|
|
|
default_encoding = arg;
|
|
|
|
|
fixed_encoding = true;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-11-19 10:35:50 +00:00
|
|
|
|
int parse_syntaxfile(string const & arg, string const &)
|
|
|
|
|
{
|
2009-04-19 22:13:43 +00:00
|
|
|
|
if (arg.empty())
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_with_message("Missing syntaxfile string after -s switch");
|
2007-07-01 15:16:08 +00:00
|
|
|
|
syntaxfile = internal_path(arg);
|
2003-11-19 10:35:50 +00:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-01-10 19:17:43 +00:00
|
|
|
|
// Filled with the command line arguments "foo" of "-sysdir foo" or
|
|
|
|
|
// "-userdir foo".
|
|
|
|
|
string cl_system_support;
|
|
|
|
|
string cl_user_support;
|
|
|
|
|
|
|
|
|
|
|
2003-10-23 11:46:33 +00:00
|
|
|
|
int parse_sysdir(string const & arg, string const &)
|
|
|
|
|
{
|
2009-04-19 22:13:43 +00:00
|
|
|
|
if (arg.empty())
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_with_message("Missing directory for -sysdir switch");
|
2007-07-01 15:16:08 +00:00
|
|
|
|
cl_system_support = internal_path(arg);
|
2003-10-23 11:46:33 +00:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int parse_userdir(string const & arg, string const &)
|
|
|
|
|
{
|
2009-04-19 22:13:43 +00:00
|
|
|
|
if (arg.empty())
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_with_message("Missing directory for -userdir switch");
|
2007-07-01 15:16:08 +00:00
|
|
|
|
cl_user_support = internal_path(arg);
|
2003-10-23 11:46:33 +00:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int parse_force(string const &, string const &)
|
|
|
|
|
{
|
|
|
|
|
overwrite_files = true;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-12-28 15:29:38 +00:00
|
|
|
|
int parse_quite(string const &, string const &)
|
|
|
|
|
{
|
|
|
|
|
no_warnings = true;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-08-13 09:46:28 +00:00
|
|
|
|
int parse_noweb(string const &, string const &)
|
|
|
|
|
{
|
|
|
|
|
noweb_mode = true;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-10-18 20:01:32 +00:00
|
|
|
|
int parse_skipchildren(string const &, string const &)
|
|
|
|
|
{
|
|
|
|
|
skip_children = true;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-12-30 20:29:33 +00:00
|
|
|
|
int parse_roundtrip(string const &, string const &)
|
|
|
|
|
{
|
|
|
|
|
roundtrip = true;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-10-03 11:23:27 +00:00
|
|
|
|
int parse_copyfiles(string const &, string const &)
|
|
|
|
|
{
|
|
|
|
|
copy_files = true;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-01-11 13:06:17 +00:00
|
|
|
|
void TeX2LyXApp::easyParse()
|
2003-10-23 11:46:33 +00:00
|
|
|
|
{
|
2003-11-19 10:35:50 +00:00
|
|
|
|
map<string, cmd_helper> cmdmap;
|
2003-10-23 11:46:33 +00:00
|
|
|
|
|
2011-10-06 16:21:58 +00:00
|
|
|
|
cmdmap["-h"] = parse_help;
|
2011-10-03 17:47:37 +00:00
|
|
|
|
cmdmap["-help"] = parse_help;
|
|
|
|
|
cmdmap["--help"] = parse_help;
|
2011-10-06 16:21:58 +00:00
|
|
|
|
cmdmap["-v"] = parse_version;
|
2011-10-03 17:47:37 +00:00
|
|
|
|
cmdmap["-version"] = parse_version;
|
|
|
|
|
cmdmap["--version"] = parse_version;
|
2003-10-23 11:46:33 +00:00
|
|
|
|
cmdmap["-c"] = parse_class;
|
2012-10-23 18:45:21 +00:00
|
|
|
|
cmdmap["-m"] = parse_module;
|
2009-01-30 14:47:06 +00:00
|
|
|
|
cmdmap["-e"] = parse_encoding;
|
2013-11-11 20:52:14 +00:00
|
|
|
|
cmdmap["-fixedenc"] = parse_fixed_encoding;
|
2003-10-23 11:46:33 +00:00
|
|
|
|
cmdmap["-f"] = parse_force;
|
2003-11-19 10:35:50 +00:00
|
|
|
|
cmdmap["-s"] = parse_syntaxfile;
|
2006-08-13 09:46:28 +00:00
|
|
|
|
cmdmap["-n"] = parse_noweb;
|
2012-10-18 20:01:32 +00:00
|
|
|
|
cmdmap["-skipchildren"] = parse_skipchildren;
|
2003-10-23 11:46:33 +00:00
|
|
|
|
cmdmap["-sysdir"] = parse_sysdir;
|
|
|
|
|
cmdmap["-userdir"] = parse_userdir;
|
2022-12-28 15:29:38 +00:00
|
|
|
|
cmdmap["-q"] = parse_quite;
|
2010-12-30 20:29:33 +00:00
|
|
|
|
cmdmap["-roundtrip"] = parse_roundtrip;
|
2012-10-03 11:23:27 +00:00
|
|
|
|
cmdmap["-copyfiles"] = parse_copyfiles;
|
2003-10-23 11:46:33 +00:00
|
|
|
|
|
2015-01-11 13:06:17 +00:00
|
|
|
|
for (int i = 1; i < argc_; ++i) {
|
2007-12-12 19:28:07 +00:00
|
|
|
|
map<string, cmd_helper>::const_iterator it
|
2015-01-11 13:06:17 +00:00
|
|
|
|
= cmdmap.find(argv_[i]);
|
2003-10-23 11:46:33 +00:00
|
|
|
|
|
|
|
|
|
// don't complain if not found - may be parsed later
|
2009-04-19 22:13:43 +00:00
|
|
|
|
if (it == cmdmap.end()) {
|
2015-01-11 13:06:17 +00:00
|
|
|
|
if (argv_[i][0] == '-')
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_with_message(string("Unknown option `") + argv_[i] + "'.");
|
2009-04-19 22:13:43 +00:00
|
|
|
|
else
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2003-10-23 11:46:33 +00:00
|
|
|
|
|
2015-01-11 13:06:17 +00:00
|
|
|
|
string arg = (i + 1 < argc_) ? os::utf8_argv(i + 1) : string();
|
|
|
|
|
string arg2 = (i + 2 < argc_) ? os::utf8_argv(i + 2) : string();
|
2003-10-23 11:46:33 +00:00
|
|
|
|
|
|
|
|
|
int const remove = 1 + it->second(arg, arg2);
|
|
|
|
|
|
|
|
|
|
// Now, remove used arguments by shifting
|
|
|
|
|
// the following ones remove places down.
|
2010-03-12 01:18:39 +00:00
|
|
|
|
os::remove_internal_args(i, remove);
|
2015-01-11 13:06:17 +00:00
|
|
|
|
argc_ -= remove;
|
|
|
|
|
for (int j = i; j < argc_; ++j)
|
|
|
|
|
argv_[j] = argv_[j + remove];
|
2003-10-23 11:46:33 +00:00
|
|
|
|
--i;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-07-29 17:03:37 +00:00
|
|
|
|
|
2005-05-25 16:01:19 +00:00
|
|
|
|
// path of the first parsed file
|
2012-10-03 11:23:27 +00:00
|
|
|
|
string masterFilePathLyX;
|
|
|
|
|
string masterFilePathTeX;
|
2005-05-25 16:01:19 +00:00
|
|
|
|
// path of the currently parsed file
|
2012-10-03 11:23:27 +00:00
|
|
|
|
string parentFilePathTeX;
|
2004-07-29 17:03:37 +00:00
|
|
|
|
|
2003-11-19 10:35:50 +00:00
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
2003-10-23 11:46:33 +00:00
|
|
|
|
|
2012-10-03 11:23:27 +00:00
|
|
|
|
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()
|
2004-07-29 17:03:37 +00:00
|
|
|
|
{
|
2012-10-03 11:23:27 +00:00
|
|
|
|
return copy_files;
|
2004-07-29 17:03:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-10-03 11:23:27 +00:00
|
|
|
|
|
|
|
|
|
bool overwriteFiles()
|
2005-05-25 16:01:19 +00:00
|
|
|
|
{
|
2012-10-03 11:23:27 +00:00
|
|
|
|
return overwrite_files;
|
2005-05-25 16:01:19 +00:00
|
|
|
|
}
|
2004-07-29 17:03:37 +00:00
|
|
|
|
|
2005-05-25 16:01:19 +00:00
|
|
|
|
|
2012-10-18 20:01:32 +00:00
|
|
|
|
bool skipChildren()
|
|
|
|
|
{
|
|
|
|
|
return skip_children;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-05-26 14:06:11 +00:00
|
|
|
|
bool roundtripMode()
|
|
|
|
|
{
|
|
|
|
|
return roundtrip;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-05-25 16:01:19 +00:00
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Reads tex input from \a is and writes lyx output to \a os.
|
|
|
|
|
* Uses some common settings for the preamble, so this should only
|
|
|
|
|
* be used more than once for included documents.
|
|
|
|
|
* Caution: Overwrites the existing preamble settings if the new document
|
|
|
|
|
* contains a preamble.
|
2012-10-03 11:23:27 +00:00
|
|
|
|
* You must ensure that \p parentFilePathTeX is properly set before calling
|
2005-05-25 16:01:19 +00:00
|
|
|
|
* this function!
|
|
|
|
|
*/
|
2016-01-31 11:54:59 +00:00
|
|
|
|
bool tex2lyx(idocstream & is, ostream & os, string const & encoding,
|
2015-05-13 23:02:37 +00:00
|
|
|
|
string const & outfiledir)
|
2003-10-23 11:46:33 +00:00
|
|
|
|
{
|
2013-11-11 20:52:14 +00:00
|
|
|
|
Parser p(is, fixed_encoding ? default_encoding : string());
|
2011-05-08 08:23:42 +00:00
|
|
|
|
p.setEncoding(encoding);
|
2003-04-23 15:14:43 +00:00
|
|
|
|
//p.dump();
|
|
|
|
|
|
2011-10-30 13:21:06 +00:00
|
|
|
|
preamble.parse(p, documentclass, textclass);
|
2012-10-26 20:23:16 +00:00
|
|
|
|
list<string> removed_modules;
|
|
|
|
|
LayoutFile const & baseClass = LayoutFileList::get()[textclass.name()];
|
|
|
|
|
if (!used_modules.adaptToBaseClass(&baseClass, removed_modules)) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Could not load default modules for text class.");
|
2012-10-26 20:23:16 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
2003-10-23 11:46:33 +00:00
|
|
|
|
|
2012-10-23 18:45:21 +00:00
|
|
|
|
// Load preloaded modules.
|
|
|
|
|
// This needs to be done after the preamble is parsed, since the text
|
2022-10-27 15:26:53 +00:00
|
|
|
|
// class may not be known before. It needs to be done before parsing
|
2012-10-23 18:45:21 +00:00
|
|
|
|
// body, since otherwise the commands/environments provided by the
|
|
|
|
|
// modules would be parsed as ERT.
|
2022-10-27 15:26:53 +00:00
|
|
|
|
// Empty module names are silently skipped.
|
2020-10-09 06:04:20 +00:00
|
|
|
|
for (auto const & module : preloaded_modules) {
|
2022-10-27 15:26:53 +00:00
|
|
|
|
if (!module.empty() && !addModule(module)) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Error: Could not load module \""
|
|
|
|
|
+ module + "\".");
|
2012-10-23 18:45:21 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// Ensure that the modules are not loaded again for included files
|
|
|
|
|
preloaded_modules.clear();
|
|
|
|
|
|
2003-04-23 15:14:43 +00:00
|
|
|
|
active_environments.push_back("document");
|
2003-08-04 10:26:10 +00:00
|
|
|
|
Context context(true, textclass);
|
2011-01-23 21:10:20 +00:00
|
|
|
|
stringstream ss;
|
2012-06-24 16:24:28 +00:00
|
|
|
|
// store the document language in the context to be able to handle the
|
|
|
|
|
// commands like \foreignlanguage and \textenglish etc.
|
2012-10-06 07:38:14 +00:00
|
|
|
|
context.font.language = preamble.defaultLanguage();
|
2012-06-24 16:24:28 +00:00
|
|
|
|
// parse the main text
|
2003-08-04 10:26:10 +00:00
|
|
|
|
parse_text(p, ss, FLAG_END, true, context);
|
2018-03-04 15:46:31 +00:00
|
|
|
|
// check if we need a commented bibtex inset (biblatex)
|
|
|
|
|
check_comment_bib(ss, context);
|
2006-07-16 13:04:59 +00:00
|
|
|
|
if (Context::empty)
|
|
|
|
|
// Empty document body. LyX needs at least one paragraph.
|
|
|
|
|
context.check_layout(ss);
|
2003-08-04 10:26:10 +00:00
|
|
|
|
context.check_end_layout(ss);
|
2004-08-29 09:44:40 +00:00
|
|
|
|
ss << "\n\\end_body\n\\end_document\n";
|
2003-10-23 11:46:33 +00:00
|
|
|
|
active_environments.pop_back();
|
2011-01-23 21:10:20 +00:00
|
|
|
|
|
|
|
|
|
// 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();
|
2012-05-28 20:41:32 +00:00
|
|
|
|
for (; it != end; ++it)
|
2011-10-30 13:44:00 +00:00
|
|
|
|
preamble.addModule(*it);
|
2011-01-23 21:10:20 +00:00
|
|
|
|
}
|
2015-05-13 23:02:37 +00:00
|
|
|
|
if (!preamble.writeLyXHeader(os, !active_environments.empty(), outfiledir)) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message( "Could not write LyX file header.");
|
2011-10-30 18:12:49 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
2011-01-23 21:10:20 +00:00
|
|
|
|
|
2003-04-23 15:14:43 +00:00
|
|
|
|
ss.seekg(0);
|
2003-10-23 11:46:33 +00:00
|
|
|
|
os << ss.str();
|
2003-11-05 10:14:13 +00:00
|
|
|
|
#ifdef TEST_PARSER
|
|
|
|
|
p.reset();
|
2008-11-16 17:02:00 +00:00
|
|
|
|
ofdocstream parsertest("parsertest.tex");
|
2003-11-05 10:14:13 +00:00
|
|
|
|
while (p.good())
|
|
|
|
|
parsertest << p.get_token().asInput();
|
|
|
|
|
// <origfile> and parsertest.tex should now have identical content
|
|
|
|
|
#endif
|
2011-10-30 18:12:49 +00:00
|
|
|
|
return true;
|
2003-10-23 11:46:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-05-25 16:01:19 +00:00
|
|
|
|
/// convert TeX from \p infilename to LyX and write it to \p os
|
2022-12-28 13:05:23 +00:00
|
|
|
|
bool tex2lyx(FileName const & infilename, ostream & os, string encoding,
|
2015-05-13 23:02:37 +00:00
|
|
|
|
string const & outfiledir)
|
2003-10-23 11:46:33 +00:00
|
|
|
|
{
|
2016-01-31 11:54:59 +00:00
|
|
|
|
// 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;
|
2019-04-16 18:17:32 +00:00
|
|
|
|
if (preamble.inputencoding() == "auto-legacy") {
|
2016-01-31 11:54:59 +00:00
|
|
|
|
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";
|
2018-08-21 06:19:24 +00:00
|
|
|
|
// store
|
|
|
|
|
preamble.docencoding = encoding;
|
2016-01-31 11:54:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ifdocstream is(setEncoding(encoding));
|
2008-11-16 21:51:18 +00:00
|
|
|
|
// forbid buffering on this stream
|
2016-01-31 11:54:59 +00:00
|
|
|
|
is.rdbuf()->pubsetbuf(0, 0);
|
2008-11-16 21:51:18 +00:00
|
|
|
|
is.open(infilename.toFilesystemEncoding().c_str());
|
2005-03-27 18:37:42 +00:00
|
|
|
|
if (!is.good()) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Could not open input file \""
|
|
|
|
|
+ infilename.absFileName() + "\" for reading.");
|
2003-10-23 11:46:33 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
2012-10-03 11:23:27 +00:00
|
|
|
|
string const oldParentFilePath = parentFilePathTeX;
|
|
|
|
|
parentFilePathTeX = onlyPath(infilename.absFileName());
|
2015-05-13 23:02:37 +00:00
|
|
|
|
bool retval = tex2lyx(is, os, encoding, outfiledir);
|
2012-10-03 11:23:27 +00:00
|
|
|
|
parentFilePathTeX = oldParentFilePath;
|
2011-10-30 18:12:49 +00:00
|
|
|
|
return retval;
|
2005-05-25 16:01:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
|
|
|
2012-12-14 11:30:08 +00:00
|
|
|
|
bool tex2lyx(string const & infilename, FileName const & outfilename,
|
2009-01-30 14:47:06 +00:00
|
|
|
|
string const & encoding)
|
2005-05-25 16:01:19 +00:00
|
|
|
|
{
|
2022-12-28 13:05:23 +00:00
|
|
|
|
FileName ifname = FileName(infilename);
|
|
|
|
|
// Like TeX, we consider files without extensions as *.tex files
|
|
|
|
|
// and append the extension if the file without ext does not exist
|
|
|
|
|
// (#12340)
|
|
|
|
|
if (!ifname.exists() && ifname.extension().empty()) {
|
|
|
|
|
ifname.changeExtension("tex");
|
|
|
|
|
if (!ifname.exists()) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Could not open input file \""
|
|
|
|
|
+ infilename + "\" for reading.");
|
2022-12-28 13:05:23 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
2007-11-25 11:18:16 +00:00
|
|
|
|
if (outfilename.isReadableFile()) {
|
2005-06-01 14:01:18 +00:00
|
|
|
|
if (overwrite_files) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
warning_message("Overwriting existing file "
|
|
|
|
|
+ outfilename.absFileName());
|
2005-06-01 14:01:18 +00:00
|
|
|
|
} else {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Not overwriting existing file "
|
|
|
|
|
+ outfilename.absFileName());
|
2005-06-01 14:01:18 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
2022-12-28 15:29:38 +00:00
|
|
|
|
warning_message("Creating file " + outfilename.absFileName());
|
2003-10-23 11:46:33 +00:00
|
|
|
|
}
|
2006-11-26 21:30:39 +00:00
|
|
|
|
ofstream os(outfilename.toFilesystemEncoding().c_str());
|
2005-05-25 16:01:19 +00:00
|
|
|
|
if (!os.good()) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Could not open output file \""
|
|
|
|
|
+ outfilename.absFileName() + "\" for writing.");
|
2005-05-25 16:01:19 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
2022-12-29 08:37:00 +00:00
|
|
|
|
|
|
|
|
|
debug_message("Input file: " + ifname.absFileName());
|
|
|
|
|
debug_message("Output file: " + outfilename.absFileName());
|
|
|
|
|
|
2022-12-28 13:05:23 +00:00
|
|
|
|
return tex2lyx(ifname, os, encoding,
|
2015-05-13 23:02:37 +00:00
|
|
|
|
outfilename.onlyPath().absFileName() + '/');
|
2003-10-23 11:46:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-12-30 20:29:33 +00:00
|
|
|
|
|
|
|
|
|
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 ";
|
2012-07-08 19:33:55 +00:00
|
|
|
|
else if (xetex)
|
|
|
|
|
command += " -e xetex ";
|
2010-12-30 20:29:33 +00:00
|
|
|
|
else
|
|
|
|
|
command += " -e latex ";
|
|
|
|
|
command += quoteName(outfilename.toFilesystemEncoding());
|
|
|
|
|
Systemcall one;
|
|
|
|
|
if (one.startscript(Systemcall::Wait, command) == 0)
|
|
|
|
|
return true;
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Running '" + command + "' failed.");
|
2010-12-30 20:29:33 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
|
2022-12-28 15:29:38 +00:00
|
|
|
|
void warning_message(string const & message)
|
|
|
|
|
{
|
|
|
|
|
if (!no_warnings)
|
|
|
|
|
cerr << "tex2lyx warning: " << message << endl;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-12-29 08:37:00 +00:00
|
|
|
|
void error_message(string const & message)
|
|
|
|
|
{
|
|
|
|
|
cerr << "tex2lyx error: " << message << endl;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef FILEDEBUG
|
|
|
|
|
void debug_message(string const & message)
|
|
|
|
|
{
|
|
|
|
|
cerr << "tex2lyx debug info: " << message << endl;
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
void debug_message(string const &){}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
2015-01-11 13:06:17 +00:00
|
|
|
|
namespace {
|
2003-10-23 11:46:33 +00:00
|
|
|
|
|
2015-01-11 13:06:17 +00:00
|
|
|
|
int TeX2LyXApp::run()
|
2003-10-23 11:46:33 +00:00
|
|
|
|
{
|
2015-01-11 13:06:17 +00:00
|
|
|
|
// qt changes this, and our numeric conversions require the C locale
|
|
|
|
|
setlocale(LC_NUMERIC, "C");
|
2010-03-12 01:18:39 +00:00
|
|
|
|
|
2011-10-03 17:47:37 +00:00
|
|
|
|
try {
|
|
|
|
|
init_package(internal_path(os::utf8_argv(0)), string(), string());
|
|
|
|
|
} catch (ExceptionMessage const & message) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message(to_utf8(message.title_) + ":\n"
|
|
|
|
|
+ to_utf8(message.details_));
|
2011-10-03 17:47:37 +00:00
|
|
|
|
if (message.type_ == ErrorException)
|
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-11 13:06:17 +00:00
|
|
|
|
easyParse();
|
2003-10-23 11:46:33 +00:00
|
|
|
|
|
2015-01-11 13:06:17 +00:00
|
|
|
|
if (argc_ <= 1)
|
2009-04-19 22:13:43 +00:00
|
|
|
|
error_message("Not enough arguments.");
|
2007-01-24 15:49:20 +00:00
|
|
|
|
|
2008-11-14 15:58:50 +00:00
|
|
|
|
try {
|
2010-03-12 01:18:39 +00:00
|
|
|
|
init_package(internal_path(os::utf8_argv(0)),
|
2011-05-14 12:26:11 +00:00
|
|
|
|
cl_system_support, cl_user_support);
|
2007-12-12 19:57:42 +00:00
|
|
|
|
} catch (ExceptionMessage const & message) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message(to_utf8(message.title_) + ":\n"
|
|
|
|
|
+ to_utf8(message.details_));
|
2007-12-12 19:57:42 +00:00
|
|
|
|
if (message.type_ == ErrorException)
|
2010-12-30 20:29:33 +00:00
|
|
|
|
return EXIT_FAILURE;
|
2007-01-24 15:49:20 +00:00
|
|
|
|
}
|
2008-03-21 11:26:20 +00:00
|
|
|
|
|
2014-12-29 22:46:25 +00:00
|
|
|
|
// 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") ||
|
2017-08-08 10:23:15 +00:00
|
|
|
|
configFileNeedsUpdate("packages.lst") ||
|
|
|
|
|
configFileNeedsUpdate("lyxciteengines.lst") ||
|
|
|
|
|
configFileNeedsUpdate("xtemplates.lst"))
|
2014-12-29 22:46:25 +00:00
|
|
|
|
package().reconfigureUserLyXDir("");
|
|
|
|
|
fileUnlock(fd, lock_file.c_str());
|
|
|
|
|
} else
|
|
|
|
|
error_message("User directory does not exist.");
|
|
|
|
|
|
2005-07-25 13:49:38 +00:00
|
|
|
|
// Now every known option is parsed. Look for input and output
|
|
|
|
|
// file name (the latter is optional).
|
2010-03-12 01:18:39 +00:00
|
|
|
|
string infilename = internal_path(os::utf8_argv(1));
|
2010-04-21 01:19:09 +00:00
|
|
|
|
infilename = makeAbsPath(infilename).absFileName();
|
2008-03-21 11:26:20 +00:00
|
|
|
|
|
2005-07-25 13:49:38 +00:00
|
|
|
|
string outfilename;
|
2015-01-11 13:06:17 +00:00
|
|
|
|
if (argc_ > 2) {
|
2010-03-12 01:18:39 +00:00
|
|
|
|
outfilename = internal_path(os::utf8_argv(2));
|
2005-07-25 16:27:23 +00:00
|
|
|
|
if (outfilename != "-")
|
2010-04-21 01:19:09 +00:00
|
|
|
|
outfilename = makeAbsPath(outfilename).absFileName();
|
2012-10-03 11:23:27 +00:00
|
|
|
|
if (roundtrip) {
|
|
|
|
|
if (outfilename == "-") {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Writing to standard output is "
|
|
|
|
|
"not supported in roundtrip mode.");
|
2012-10-03 11:23:27 +00:00
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
|
}
|
|
|
|
|
string texfilename = changeExtension(outfilename, ".tex");
|
|
|
|
|
if (equivalent(FileName(infilename), FileName(texfilename))) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("The input file `" + infilename
|
|
|
|
|
+ "´ would be overwritten by the TeX file exported from `"
|
|
|
|
|
+ outfilename + "´ in roundtrip mode.");
|
2012-10-03 11:23:27 +00:00
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else if (roundtrip) {
|
|
|
|
|
// avoid overwriting the input file
|
|
|
|
|
outfilename = changeExtension(infilename, ".lyx.lyx");
|
2005-07-25 16:27:23 +00:00
|
|
|
|
} else
|
2006-04-08 22:31:11 +00:00
|
|
|
|
outfilename = changeExtension(infilename, ".lyx");
|
2005-07-25 13:49:38 +00:00
|
|
|
|
|
2008-11-16 21:51:18 +00:00
|
|
|
|
// Read the syntax tables
|
2007-12-12 19:57:42 +00:00
|
|
|
|
FileName const system_syntaxfile = libFileSearch("", "syntax.default");
|
2003-11-19 10:35:50 +00:00
|
|
|
|
if (system_syntaxfile.empty()) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Could not find syntax file \"syntax.default\".");
|
2010-12-30 20:29:33 +00:00
|
|
|
|
return EXIT_FAILURE;
|
2003-11-19 10:35:50 +00:00
|
|
|
|
}
|
2015-01-09 20:43:45 +00:00
|
|
|
|
if (!read_syntaxfile(system_syntaxfile))
|
|
|
|
|
return 2;
|
2003-11-19 10:35:50 +00:00
|
|
|
|
if (!syntaxfile.empty())
|
2015-01-09 20:43:45 +00:00
|
|
|
|
if (!read_syntaxfile(makeAbsPath(syntaxfile)))
|
|
|
|
|
return 2;
|
2003-11-19 10:35:50 +00:00
|
|
|
|
|
2008-11-16 21:51:18 +00:00
|
|
|
|
// Read the encodings table.
|
|
|
|
|
FileName const symbols_path = libFileSearch(string(), "unicodesymbols");
|
|
|
|
|
if (symbols_path.empty()) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Could not find file \"unicodesymbols\".");
|
2010-12-30 20:29:33 +00:00
|
|
|
|
return EXIT_FAILURE;
|
2008-11-16 21:51:18 +00:00
|
|
|
|
}
|
|
|
|
|
FileName const enc_path = libFileSearch(string(), "encodings");
|
|
|
|
|
if (enc_path.empty()) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Could not find file \"encodings\".");
|
2010-12-30 20:29:33 +00:00
|
|
|
|
return EXIT_FAILURE;
|
2008-11-16 21:51:18 +00:00
|
|
|
|
}
|
|
|
|
|
encodings.read(enc_path, symbols_path);
|
2013-01-19 18:47:15 +00:00
|
|
|
|
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();
|
2014-12-29 21:29:20 +00:00
|
|
|
|
if (fixed_encoding)
|
|
|
|
|
preamble.setInputencoding(enc->name());
|
2013-01-19 18:47:15 +00:00
|
|
|
|
}
|
2008-11-16 21:51:18 +00:00
|
|
|
|
|
2011-01-23 21:10:20 +00:00
|
|
|
|
// Load the layouts
|
|
|
|
|
LayoutFileList::get().read();
|
|
|
|
|
//...and the modules
|
|
|
|
|
theModuleList.read();
|
|
|
|
|
|
2008-11-16 21:51:18 +00:00
|
|
|
|
// The real work now.
|
2012-10-03 11:23:27 +00:00
|
|
|
|
masterFilePathTeX = onlyPath(infilename);
|
|
|
|
|
parentFilePathTeX = masterFilePathTeX;
|
2005-07-25 16:27:23 +00:00
|
|
|
|
if (outfilename == "-") {
|
2012-10-03 11:23:27 +00:00
|
|
|
|
// assume same directory as input file
|
|
|
|
|
masterFilePathLyX = masterFilePathTeX;
|
2015-05-13 23:02:37 +00:00
|
|
|
|
if (tex2lyx(FileName(infilename), cout, default_encoding, masterFilePathLyX))
|
2005-07-25 13:49:38 +00:00
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
|
} else {
|
2012-10-03 11:23:27 +00:00
|
|
|
|
masterFilePathLyX = onlyPath(outfilename);
|
2012-10-24 20:11:05 +00:00
|
|
|
|
if (copy_files) {
|
|
|
|
|
FileName const path(masterFilePathLyX);
|
|
|
|
|
if (!path.isDirectory()) {
|
|
|
|
|
if (!path.createPath()) {
|
2022-12-29 08:37:00 +00:00
|
|
|
|
error_message("Could not create directory for file `"
|
|
|
|
|
+ masterFilePathLyX + "´.");
|
2012-10-24 20:11:05 +00:00
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-10-03 11:23:27 +00:00
|
|
|
|
if (roundtrip) {
|
|
|
|
|
if (tex2tex(infilename, FileName(outfilename), default_encoding))
|
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
|
} else {
|
2015-01-11 13:06:17 +00:00
|
|
|
|
if (lyx::tex2lyx(infilename, FileName(outfilename), default_encoding))
|
2012-10-03 11:23:27 +00:00
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
|
}
|
2005-07-25 13:49:38 +00:00
|
|
|
|
}
|
2010-12-30 20:29:33 +00:00
|
|
|
|
return EXIT_FAILURE;
|
2003-03-17 16:25:00 +00:00
|
|
|
|
}
|
2003-02-12 11:09:22 +00:00
|
|
|
|
|
2015-01-11 13:06:17 +00:00
|
|
|
|
} // anonymous namespace
|
|
|
|
|
} // namespace lyx
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int main(int argc, char * argv[])
|
|
|
|
|
{
|
|
|
|
|
//setlocale(LC_CTYPE, "");
|
|
|
|
|
|
|
|
|
|
lyx::lyxerr.setStream(cerr);
|
|
|
|
|
|
2017-04-12 19:19:42 +00:00
|
|
|
|
os::init(argc, &argv);
|
2015-01-11 13:06:17 +00:00
|
|
|
|
|
|
|
|
|
lyx::TeX2LyXApp app(argc, argv);
|
|
|
|
|
return app.exec();
|
|
|
|
|
}
|
|
|
|
|
|
2003-02-12 11:09:22 +00:00
|
|
|
|
// }])
|