--- /dev/null
+
+/** The .tex to .lyx converter
+ \author André Pönitz (2003)
+ */
+
+#include <config.h>
+
+#include <algorithm>
+#include <cctype>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <stack>
+#include <string>
+#include <vector>
+
+using std::atoi;
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::fill;
+using std::getline;
+using std::ios;
+using std::istream;
+using std::ostream;
+using std::vector;
+
+
+namespace {
+
+char const OPEN = '<';
+char const CLOSE = '>';
+
+const char * known_languages[] = { "austrian", "babel", "bahasa",
+"basque", "breton", "bulgarian", "catalan", "croatian", "czech", "danish",
+"dutch", "english", "esperanto", "estonian", "finnish", "francais",
+"frenchb", "galician", "germanb", "greek", "hebcal", "hebfont", "hebrew",
+"hebrew_newcode", "hebrew_oldcode", "hebrew_p", "hyphen", "icelandic",
+"irish", "italian", "latin", "lgrcmr", "lgrcmro", "lgrcmss", "lgrcmtt",
+"lgrenc", "lgrlcmss", "lgrlcmtt", "lheclas", "lhecmr", "lhecmss",
+"lhecmtt", "lhecrml", "lheenc", "lhefr", "lheredis", "lheshold",
+"lheshscr", "lheshstk", "lsorbian", "magyar", "naustrian", "ngermanb",
+"ngerman", "norsk", "polish", "portuges", "rlbabel", "romanian",
+"russianb", "samin", "scottish", "serbian", "slovak", "slovene", "spanish",
+"swedish", "turkish", "ukraineb", "usorbian", "welsh", 0};
+
+const char * known_fontsizes[] = { "10pt", "11pt", "12pt", 0 };
+
+
+// some ugly stuff
+string h_preamble;
+string h_textclass = "FIXME";
+string h_options = "FIXME";
+string h_language = "FIXME";
+string h_inputencoding = "FIXME";
+string h_fontscheme = "FIXME";
+string h_graphics = "default";
+string h_paperfontsize = "FIXME";
+string h_spacing = "single";
+string h_papersize = "FIXME";
+string h_paperpackage = "FIXME";
+string h_use_geometry = "0";
+string h_use_amsmath = "0";
+string h_use_natbib = "0";
+string h_use_numerical_citations = "0";
+string h_paperorientation = "portrait";
+string h_secnumdepth = "3";
+string h_tocdepth = "3";
+string h_paragraph_separation = "indent";
+string h_defskip = "medskip";
+string h_quotes_language = "2";
+string h_quotes_times = "1";
+string h_papercolumns = "1";
+string h_papersides = "1";
+string h_paperpagestyle = "default";
+string h_tracking_changes = "0";
+
+// indicates whether we are in the preamble
+bool in_preamble = true;
+
+// current stack of nested environments
+stack<string> active_environments;
+
+
+
+void split(string const & s, vector<string> & result, char delim)
+{
+ istringstream is(s);
+ string t;
+ while (getline(is, t, delim))
+ result.push_back(t);
+}
+
+
+string join(vector<string> const & input, char delim)
+{
+ ostringstream os;
+ for (size_t i = 0; i != input.size(); ++i) {
+ if (i)
+ os << delim;
+ os << input[i];
+ }
+ return os.str();
+}
+
+
+void handle_opt(vector<string> & opts, char const ** what, string & target)
+{
+ for ( ; what; ++what) {
+ vector<string>::iterator it = find(opts.begin(), opts.end(), *what);
+ if (it != opts.end()) {
+ //cerr << "### found option '" << *what << "'\n";
+ target = *what;
+ opts.erase(it);
+ return;
+ }
+ }
+}
+
+
+void handle_ert(ostream & os, string const & s)
+{
+ os << "\n\\begin_inset ERT\nstatus Collapsed\n\n\\layout Standard\n\n";
+ os << s;
+ os << "\n\\end_inset\n";
+}
+
+
+string wrap(string const & cmd, string const & str)
+{
+ return OPEN + cmd + ' ' + str + CLOSE;
+}
+
+
+string wrap(string const & cmd, string const & str, string const & str2)
+{
+ return OPEN + cmd + ' ' + str + ' ' + str2 + CLOSE;
+}
+
+
+enum mode_type {UNDECIDED_MODE, TEXT_MODE, MATH_MODE};
+
+mode_type asMode(mode_type oldmode, string const & str)
+{
+ if (str == "mathmode")
+ return MATH_MODE;
+ if (str == "textmode" || str == "forcetext")
+ return TEXT_MODE;
+ return oldmode;
+}
+
+
+bool stared(string const & s)
+{
+ string::size_type const n = s.size();
+ return n && s[n - 1] == '*';
+}
+
+
+// These are TeX's catcodes
+enum CatCode {
+ catEscape, // 0 backslash
+ catBegin, // 1 {
+ catEnd, // 2 }
+ cat, // 3 $
+ catAlign, // 4 &
+ catNewline, // 5 ^^M
+ catParameter, // 6 #
+ catSuper, // 7 ^
+ catSub, // 8 _
+ catIgnore, // 9
+ catSpace, // 10 space
+ catLetter, // 11 a-zA-Z
+ catOther, // 12 none of the above
+ catActive, // 13 ~
+ catComment, // 14 %
+ catInvalid // 15 <delete>
+};
+
+CatCode theCatcode[256];
+
+
+inline CatCode catcode(unsigned char c)
+{
+ return theCatcode[c];
+}
+
+
+enum {
+ FLAG_BRACE_LAST = 1 << 1, // last closing brace ends the parsing
+ FLAG_RIGHT = 1 << 2, // next \\right ends the parsing process
+ FLAG_END = 1 << 3, // next \\end ends the parsing process
+ FLAG_BRACK_LAST = 1 << 4, // next closing bracket ends the parsing
+ FLAG_TEXTMODE = 1 << 5, // we are in a box
+ FLAG_ITEM = 1 << 6, // read a (possibly braced token)
+ FLAG_LEAVE = 1 << 7, // leave the loop at the end
+ FLAG_SIMPLE = 1 << 8, // next $ leaves the loop
+ FLAG_EQUATION = 1 << 9, // next \] leaves the loop
+ FLAG_SIMPLE2 = 1 << 10, // next \) leaves the loop
+ FLAG_OPTION = 1 << 11, // read [...] style option
+ FLAG_BRACED = 1 << 12 // read {...} style argument
+};
+
+
+void catInit()
+{
+ fill(theCatcode, theCatcode + 256, catOther);
+ fill(theCatcode + 'a', theCatcode + 'z' + 1, catLetter);
+ fill(theCatcode + 'A', theCatcode + 'Z' + 1, catLetter);
+
+ theCatcode['\\'] = catEscape;
+ theCatcode['{'] = catBegin;
+ theCatcode['}'] = catEnd;
+ theCatcode['$'] = cat;
+ theCatcode['&'] = catAlign;
+ theCatcode['\n'] = catNewline;
+ theCatcode['#'] = catParameter;
+ theCatcode['^'] = catSuper;
+ theCatcode['_'] = catSub;
+ theCatcode['\7f'] = catIgnore;
+ theCatcode[' '] = catSpace;
+ theCatcode['\t'] = catSpace;
+ theCatcode['\r'] = catNewline;
+ theCatcode['~'] = catActive;
+ theCatcode['%'] = catComment;
+}
+
+
+
+//
+// Helper class for parsing
+//
+
+class Token {
+public:
+ ///
+ Token() : cs_(), char_(0), cat_(catIgnore) {}
+ ///
+ Token(char c, CatCode cat) : cs_(), char_(c), cat_(cat) {}
+ ///
+ Token(string const & cs) : cs_(cs), char_(0), cat_(catIgnore) {}
+
+ ///
+ string const & cs() const { return cs_; }
+ ///
+ CatCode cat() const { return cat_; }
+ ///
+ char character() const { return char_; }
+ ///
+ string asString() const { return cs_.size() ? cs_ : string(1, char_); }
+
+private:
+ ///
+ string cs_;
+ ///
+ char char_;
+ ///
+ CatCode cat_;
+};
+
+ostream & operator<<(ostream & os, Token const & t)
+{
+ if (t.cs().size())
+ os << '\\' << t.cs();
+ else
+ os << '[' << t.character() << ',' << t.cat() << ']';
+ return os;
+}
+
+
+class Parser {
+
+public:
+ ///
+ Parser(istream & is);
+
+ ///
+ string parse();
+ ///
+ string parse(unsigned flags, mode_type mode);
+ ///
+ int lineno() const { return lineno_; }
+ ///
+ void putback();
+ /// dump contents to screen
+ void dump() const;
+
+private:
+ ///
+ string getArg(char left, char right);
+ ///
+ char getChar();
+ ///
+ void error(string const & msg);
+ ///
+ void tokenize(istream & is);
+ ///
+ void tokenize(string const & s);
+ ///
+ void skipSpaceTokens(istream & is, char c);
+ ///
+ void push_back(Token const & t);
+ ///
+ void pop_back();
+ ///
+ Token const & prevToken() const;
+ ///
+ Token const & nextToken() const;
+ ///
+ Token const & getToken();
+ /// skips spaces if any
+ void skipSpaces();
+ ///
+ void lex(string const & s);
+ ///
+ bool good() const;
+ ///
+ string parse_verbatim_item();
+ ///
+ string parse_verbatim_option();
+
+ ///
+ int lineno_;
+ ///
+ vector<Token> tokens_;
+ ///
+ unsigned pos_;
+};
+
+
+Parser::Parser(istream & is)
+ : lineno_(0), pos_(0)
+{
+ tokenize(is);
+}
+
+
+void Parser::push_back(Token const & t)
+{
+ tokens_.push_back(t);
+}
+
+
+void Parser::pop_back()
+{
+ tokens_.pop_back();
+}
+
+
+Token const & Parser::prevToken() const
+{
+ static const Token dummy;
+ return pos_ > 0 ? tokens_[pos_ - 1] : dummy;
+}
+
+
+Token const & Parser::nextToken() const
+{
+ static const Token dummy;
+ return good() ? tokens_[pos_] : dummy;
+}
+
+
+Token const & Parser::getToken()
+{
+ static const Token dummy;
+ //cerr << "looking at token " << tokens_[pos_] << " pos: " << pos_ << '\n';
+ return good() ? tokens_[pos_++] : dummy;
+}
+
+
+void Parser::skipSpaces()
+{
+ while (nextToken().cat() == catSpace || nextToken().cat() == catNewline)
+ getToken();
+}
+
+
+void Parser::putback()
+{
+ --pos_;
+}
+
+
+bool Parser::good() const
+{
+ return pos_ < tokens_.size();
+}
+
+
+char Parser::getChar()
+{
+ if (!good())
+ error("The input stream is not well...");
+ return tokens_[pos_++].character();
+}
+
+
+string Parser::getArg(char left, char right)
+{
+ skipSpaces();
+
+ string result;
+ char c = getChar();
+
+ if (c != left)
+ putback();
+ else
+ while ((c = getChar()) != right && good())
+ result += c;
+
+ return result;
+}
+
+
+void Parser::skipSpaceTokens(istream & is, char c)
+{
+ // skip trailing spaces
+ while (catcode(c) == catSpace || catcode(c) == catNewline)
+ if (!is.get(c))
+ break;
+ //cerr << "putting back: " << c << "\n";
+ is.putback(c);
+}
+
+
+void Parser::tokenize(istream & is)
+{
+ // eat everything up to the next \end_inset or end of stream
+ // and store it in s for further tokenization
+ string s;
+ char c;
+ while (is.get(c)) {
+ s += c;
+ if (s.size() >= 10 && s.substr(s.size() - 10) == "\\end_inset") {
+ s = s.substr(0, s.size() - 10);
+ break;
+ }
+ }
+ // Remove the space after \end_inset
+ if (is.get(c) && c != ' ')
+ is.unget();
+
+ // tokenize buffer
+ tokenize(s);
+}
+
+
+void Parser::tokenize(string const & buffer)
+{
+ static bool init_done = false;
+
+ if (!init_done) {
+ catInit();
+ init_done = true;
+ }
+
+ istringstream is(buffer.c_str(), ios::in | ios::binary);
+
+ char c;
+ while (is.get(c)) {
+ //cerr << "reading c: " << c << "\n";
+
+ switch (catcode(c)) {
+ case catNewline: {
+ ++lineno_;
+ is.get(c);
+ if (catcode(c) == catNewline)
+ push_back(Token("par"));
+ else {
+ push_back(Token('\n', catNewline));
+ is.putback(c);
+ }
+ break;
+ }
+
+/*
+ case catComment: {
+ while (is.get(c) && catcode(c) != catNewline)
+ ;
+ ++lineno_;
+ break;
+ }
+*/
+
+ case catEscape: {
+ is.get(c);
+ if (!is) {
+ error("unexpected end of input");
+ } else {
+ string s(1, c);
+ if (catcode(c) == catLetter) {
+ // collect letters
+ while (is.get(c) && catcode(c) == catLetter)
+ s += c;
+ skipSpaceTokens(is, c);
+ }
+ push_back(Token(s));
+ }
+ break;
+ }
+
+ case catSuper:
+ case catSub: {
+ push_back(Token(c, catcode(c)));
+ is.get(c);
+ skipSpaceTokens(is, c);
+ break;
+ }
+
+ case catIgnore: {
+ cerr << "ignoring a char: " << int(c) << "\n";
+ break;
+ }
+
+ default:
+ push_back(Token(c, catcode(c)));
+ }
+ }
+
+#ifdef FILEDEBUG
+ dump();
+#endif
+}
+
+
+void Parser::dump() const
+{
+ cerr << "\nTokens: ";
+ for (unsigned i = 0; i < tokens_.size(); ++i) {
+ if (i == pos_)
+ cerr << " <#> ";
+ cerr << tokens_[i];
+ }
+ cerr << " pos: " << pos_ << "\n";
+}
+
+
+void Parser::error(string const & msg)
+{
+ cerr << "Line ~" << lineno_ << ": parse error: " << msg << endl;
+ dump();
+ //exit(1);
+}
+
+
+string Parser::parse()
+{
+ skipSpaces();
+ return parse(0, UNDECIDED_MODE);
+}
+
+
+string Parser::parse_verbatim_option()
+{
+ string res;
+ if (nextToken().character() == '[') {
+ Token t = getToken();
+ for (Token t = getToken(); t.character() != ']' && good(); t = getToken()) {
+ if (t.cat() == catBegin) {
+ putback();
+ res += '{' + parse_verbatim_item() + '}';
+ } else
+ res += t.asString();
+ }
+ }
+ return res;
+}
+
+
+string Parser::parse_verbatim_item()
+{
+ string res;
+ if (nextToken().cat() == catBegin) {
+ Token t = getToken();
+ for (Token t = getToken(); t.cat() != catEnd && good(); t = getToken()) {
+ if (t.cat() == catBegin) {
+ putback();
+ res += '{' + parse_verbatim_item() + '}';
+ }
+ else
+ res += t.asString();
+ }
+ }
+ return res;
+}
+
+
+string Parser::parse(unsigned flags, mode_type mode)
+{
+ //int limits = 0;
+
+ ostringstream result;
+ while (good()) {
+ Token const & t = getToken();
+
+#ifdef FILEDEBUG
+ cerr << "t: " << t << " flags: " << flags << "\n";
+ cell->dump();
+ cerr << "\n";
+#endif
+
+ if (flags & FLAG_ITEM) {
+ if (t.cat() == catSpace)
+ continue;
+
+ flags &= ~FLAG_ITEM;
+ if (t.cat() == catBegin) {
+ // skip the brace and collect everything to the next matching
+ // closing brace
+ flags |= FLAG_BRACE_LAST;
+ continue;
+ }
+
+ // handle only this single token, leave the loop if done
+ flags |= FLAG_LEAVE;
+ }
+
+
+ if (flags & FLAG_BRACED) {
+ if (t.cat() == catSpace)
+ continue;
+
+ if (t.cat() != catBegin) {
+ error("opening brace expected");
+ return result.str();
+ }
+
+ // skip the brace and collect everything to the next matching
+ // closing brace
+ flags = FLAG_BRACE_LAST;
+ }
+
+
+ if (flags & FLAG_OPTION) {
+ if (t.cat() == catOther && t.character() == '[') {
+ result << parse(FLAG_BRACK_LAST, mode);
+ } else {
+ // no option found, put back token and we are done
+ putback();
+ }
+ return result.str();
+ }
+
+ //
+ // cat codes
+ //
+ if (t.cat() == cat) {
+ if (mode != MATH_MODE) {
+ // we are inside some text mode thingy, so opening new math is allowed
+ Token const & n = getToken();
+ if (n.cat() == cat) {
+ // TeX's $$...$$ syntax for displayed math
+ result << wrap("equation", parse(FLAG_SIMPLE, MATH_MODE));
+ getToken(); // skip the second '$' token
+ } else {
+ // simple $...$ stuff
+ putback();
+ result << wrap("simple", parse(FLAG_SIMPLE, MATH_MODE));
+ }
+ }
+
+ else if (flags & FLAG_SIMPLE) {
+ // this is the end of the formula
+ return result.str();
+ }
+
+ else {
+ error("something strange in the parser\n");
+ break;
+ }
+ }
+
+ else if (t.cat() == catLetter)
+ result << t.character();
+
+ else if (t.cat() == catSpace && mode != MATH_MODE) {
+ //if (result.empty() || result[result.size() - 1] != ' ')
+ result << t.character();
+ }
+
+ else if (t.cat() == catNewline && mode != MATH_MODE)
+ result << t.character();
+
+ else if (t.cat() == catParameter) {
+ Token const & n = getToken();
+ result << wrap("macroarg", string(1, n.character()));
+ }
+
+ else if (t.cat() == catActive)
+ result << wrap("active", string(1, t.character()));
+
+ else if (t.cat() == catBegin)
+ result << wrap("braced", parse(FLAG_BRACE_LAST, mode));
+
+ else if (t.cat() == catEnd) {
+ if (flags & FLAG_BRACE_LAST)
+ return result.str();
+ error("found '}' unexpectedly");
+ //lyx::Assert(0);
+ //add(cell, '}', LM_TC_TEX);
+ }
+
+/*
+ else if (t.cat() == catAlign) {
+ ++cellcol;
+ //cerr << " column now " << cellcol << " max: " << grid.ncols() << "\n";
+ if (cellcol == grid.ncols()) {
+ //cerr << "adding column " << cellcol << "\n";
+ grid.addCol(cellcol - 1);
+ }
+ cell = &grid.cell(grid.index(cellrow, cellcol));
+ }
+*/
+
+ else if (t.character() == ']' && (flags & FLAG_BRACK_LAST)) {
+ //cerr << "finished reading option\n";
+ return result.str();
+ }
+
+ else if (t.cat() == catOther)
+ result << string(1, t.character());
+
+ else if (t.cat() == catComment) {
+ string s;
+ while (good()) {
+ Token const & t = getToken();
+ if (t.cat() == catNewline)
+ break;
+ s += t.asString();
+ }
+ //result << wrap("comment", s);
+ skipSpaces();
+ }
+
+ //
+ // control sequences
+ //
+
+ else if (t.cs() == "lyxlock") {
+ // ignored;
+ }
+
+ else if (t.cs() == "newcommand" || t.cs() == "providecommand") {
+ string const name = parse_verbatim_item();
+ string const opts = getArg('[', ']');
+ string const body = parse_verbatim_item();
+ // only non-lyxspecific stuff
+ if (name != "noun" && name != "tabularnewline") {
+ h_preamble += "\\" + t.cs() + "{" + name + "}";
+ if (opts.size())
+ h_preamble += "[" + opts + "]";
+ h_preamble += "{" + body + "}\n";
+ }
+ }
+
+ else if (t.cs() == "(")
+ result << wrap("simple", parse(FLAG_SIMPLE2, MATH_MODE));
+
+ else if (t.cs() == "[")
+ result << wrap("equation", parse(FLAG_EQUATION, MATH_MODE));
+
+ else if (t.cs() == "protect")
+ // ignore \\protect, will hopefully be re-added during output
+ ;
+
+ else if (t.cs() == "end") {
+ if (flags & FLAG_END) {
+ // eat environment name
+ string const name = getArg('{', '}');
+ if (name != active_environments.top())
+ error("\\end{" + name + "} does not match \\begin{"
+ + active_environments.top() + "}");
+ active_environments.pop();
+ return result.str();
+ }
+ error("found 'end' unexpectedly");
+ }
+
+ else if (t.cs() == ")") {
+ if (flags & FLAG_SIMPLE2)
+ return result.str();
+ error("found '\\)' unexpectedly");
+ }
+
+ else if (t.cs() == "]") {
+ if (flags & FLAG_EQUATION)
+ return result.str();
+ error("found '\\]' unexpectedly");
+ }
+
+/*
+ else if (t.cs() == "\\") {
+ grid.vcrskip(LyXLength(getArg('[', ']')), cellrow);
+ ++cellrow;
+ cellcol = 0;
+ if (cellrow == grid.nrows())
+ grid.addRow(cellrow - 1);
+ if (grid.asHullstring())
+ grid.asHullstring()->numbered(cellrow, numbered);
+ cell = &grid.cell(grid.index(cellrow, cellcol));
+ }
+*/
+ else if (t.cs() == "documentclass") {
+ vector<string> opts;
+ split(getArg('[', ']'), opts, ',');
+ handle_opt(opts, known_languages, h_language);
+ handle_opt(opts, known_fontsizes, h_paperfontsize);
+ h_options = join(opts, ',');
+ h_textclass = getArg('{', '}');
+ }
+
+ else if (t.cs() == "usepackage") {
+ string const options = getArg('[', ']');
+ string const name = getArg('{', '}');
+ if (name == "a4wide") {
+ h_papersize = "a4";
+ h_paperpackage = "widemarginsa4";
+ } else if (name == "ae")
+ h_fontscheme = "ae";
+ else if (name == "aecompl")
+ h_fontscheme = "ae";
+ else if (name == "amsmath")
+ h_use_amsmath = "1";
+ else if (name == "amssymb")
+ h_use_amsmath = "1";
+ else if (name == "babel")
+ ; // ignore this
+ else if (name == "fontenc")
+ ; // ignore this
+ else if (name == "inputenc")
+ h_inputencoding = options;
+ else if (name == "makeidx")
+ ; // ignore this
+ else if (name == "verbatim")
+ ; // ignore this
+ else {
+ if (options.size())
+ h_preamble += "\\usepackage[" + options + "]{" + name + "}\n";
+ else
+ h_preamble += "\\usepackage{" + name + "}\n";
+ }
+ }
+
+ else if (t.cs() == "newenvironment") {
+ string const name = getArg('{', '}');
+ skipSpaces();
+ string const begin = parse_verbatim_item();
+ skipSpaces();
+ string const end = parse_verbatim_item();
+ // ignore out mess
+ if (name != "lyxcode")
+ result << wrap("newenvironment", begin + end);
+ }
+
+ else if (t.cs() == "def") {
+ string const name = getToken().cs();
+ string res;
+ while (nextToken().cat() != catBegin)
+ res += getToken().asString();
+ handle_ert(result, "\\def" + res + '{' + parse_verbatim_item() + '}');
+ }
+
+ else if (t.cs() == "setcounter") {
+ string const name = getArg('{', '}');
+ string const content = getArg('{', '}');
+ if (name == "secnumdepth")
+ h_secnumdepth = content;
+ else if (name == "tocdepth")
+ h_tocdepth = content;
+ else
+ h_preamble += "\\setcounter{" + name + "}{" + content + "}\n";
+ }
+
+ else if (t.cs() == "setlength") {
+ string const name = getToken().cs();
+ string const content = getArg('{', '}');
+ if (name == "parskip")
+ h_paragraph_separation = "skip";
+ else if (name == "parindent")
+ h_paragraph_separation = "skip";
+ else
+ h_preamble += "\\setcounter{" + name + "}{" + content + "}\n";
+ }
+
+ else if (t.cs() == "par") {
+ if (!active_environments.empty())
+ result << "\n\\layout " << active_environments.top() << "\n\n";
+ }
+
+ else if (t.cs() == "title")
+ result << "\\layout Title\n\n" + parse_verbatim_item();
+
+ else if (t.cs() == "author")
+ result << "\\layout Author\n\n" + parse_verbatim_item();
+
+ else if (t.cs() == "abstract")
+ result << "\\layout Abstract\n\n" + parse_verbatim_item();
+
+ else if (t.cs() == "begin") {
+ string const name = getArg('{', '}');
+ active_environments.push(name);
+ result << parse(FLAG_END, mode);
+ }
+
+ if (flags & FLAG_LEAVE) {
+ flags &= ~FLAG_LEAVE;
+ break;
+ }
+ }
+
+ return result.str();
+}
+
+
+} // anonymous namespace
+
+
+int main(int argc, char * argv[])
+{
+ if (argc <= 1) {
+ cerr << "Usage: " << argv[0] << " <infile.tex>" << endl;
+ return 2;
+ }
+
+ string t;
+ ifstream is(argv[1]);
+ Parser p(is);
+ //p.dump();
+ string s = p.parse();
+ cout << "# tex2lyx 0.0.2 created this file\n"
+ << "\\lyxformat 222\n"
+ << "\\textclass " << h_textclass << "\n"
+ << "\\begin_preamble\n" << h_preamble << "\\end_preamble\n"
+ << "\\options " << h_options << "\n"
+ << "\\language " << h_language << "\n"
+ << "\\inputencoding " << h_inputencoding << "\n"
+ << "\\fontscheme " << h_fontscheme << "\n"
+ << "\\graphics " << h_graphics << "\n"
+ << "\\paperfontsize " << h_paperfontsize << "\n"
+ << "\\spacing " << h_spacing << "\n"
+ << "\\papersize " << h_papersize << "\n"
+ << "\\paperpackage " << h_paperpackage << "\n"
+ << "\\use_geometry " << h_use_geometry << "\n"
+ << "\\use_amsmath " << h_use_amsmath << "\n"
+ << "\\use_natbib " << h_use_natbib << "\n"
+ << "\\use_numerical_citations " << h_use_numerical_citations << "\n"
+ << "\\paperorientation " << h_paperorientation << "\n"
+ << "\\secnumdepth " << h_secnumdepth << "\n"
+ << "\\tocdepth " << h_tocdepth << "\n"
+ << "\\paragraph_separation " << h_paragraph_separation << "\n"
+ << "\\defskip " << h_defskip << "\n"
+ << "\\quotes_language " << h_quotes_language << "\n"
+ << "\\quotes_times " << h_quotes_times << "\n"
+ << "\\papercolumns " << h_papercolumns << "\n"
+ << "\\papersides " << h_papersides << "\n"
+ << "\\paperpagestyle " << h_paperpagestyle << "\n"
+ << "\\tracking_changes " << h_tracking_changes << "\n"
+ << s << "\n"
+ << "\\the_end";
+
+ return 0;
+}
projects / features.git / commitdiff