mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-11-09 18:31:04 +00:00
re-structure the beast
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@6829 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
André Pönitz
parent
b1bf0d92b3
commit
b580294d0b
@ -1,3 +1,15 @@
|
||||
|
||||
2003-04-17 André Pönitz <poenitz@gmx.net>
|
||||
|
||||
* math.C:
|
||||
preamble.C:
|
||||
table.C:
|
||||
text.C: new files
|
||||
|
||||
* table.C: better table handling
|
||||
|
||||
* tex2lyx.C: lots of small changes
|
||||
|
||||
2003-02-25 Angus Leeming <leeming@lyx.org>
|
||||
|
||||
* .cvsignore: ignore *.lo and libtexparser.la.
|
||||
|
||||
@ -2,17 +2,22 @@ include $(top_srcdir)/config/common.am
|
||||
|
||||
INCLUDES = -I$(srcdir)/../ $(BOOST_INCLUDES)
|
||||
|
||||
noinst_LTLIBRARIES = libtexparser.la
|
||||
|
||||
libtexparser_la_SOURCES = \
|
||||
texparser.C \
|
||||
texparser.h
|
||||
|
||||
tex2lyx_LDADD = libtexparser.la
|
||||
#noinst_LTLIBRARIES = libtexparser.la
|
||||
#
|
||||
#libtexparser_la_SOURCES = \
|
||||
# texparser.C \
|
||||
# texparser.h
|
||||
#
|
||||
#tex2lyx_LDADD = libtexparser.la
|
||||
|
||||
bin_PROGRAMS = tex2lyx
|
||||
|
||||
tex2lyx_SOURCES = \
|
||||
tex2lyx.C
|
||||
texparser.C \
|
||||
texparser.h
|
||||
texparser.h \
|
||||
tex2lyx.C \
|
||||
tex2lyx.h \
|
||||
preamble.C \
|
||||
math.C \
|
||||
table.C \
|
||||
text.C
|
||||
|
||||
225
src/tex2lyx/math.C
Normal file
225
src/tex2lyx/math.C
Normal file
@ -0,0 +1,225 @@
|
||||
/** The .tex to .lyx converter
|
||||
\author André Pönitz (2003)
|
||||
*/
|
||||
|
||||
// {[(
|
||||
|
||||
#include <config.h>
|
||||
|
||||
#include "Lsstream.h"
|
||||
#include "tex2lyx.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
using std::cerr;
|
||||
using std::endl;
|
||||
using std::ostream;
|
||||
using std::string;
|
||||
using std::vector;
|
||||
|
||||
|
||||
bool is_math_env(string const & name)
|
||||
{
|
||||
static char const * known_math_envs[] = { "equation", "equation*",
|
||||
"eqnarray", "eqnarray*", "align", "align*", 0};
|
||||
|
||||
for (char const ** what = known_math_envs; *what; ++what)
|
||||
if (*what == name)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
void parse_math(Parser & p, ostream & os, unsigned flags, const mode_type mode)
|
||||
{
|
||||
while (p.good()) {
|
||||
Token const & t = p.getToken();
|
||||
|
||||
#ifdef FILEDEBUG
|
||||
cerr << "t: " << t << " flags: " << flags << "\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;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// cat codes
|
||||
//
|
||||
if (t.cat() == catMath) {
|
||||
if (mode == MATHTEXT_MODE) {
|
||||
// we are inside some text mode thingy, so opening new math is allowed
|
||||
Token const & n = p.getToken();
|
||||
if (n.cat() == catMath) {
|
||||
// TeX's $$...$$ syntax for displayed math
|
||||
os << "\\[";
|
||||
parse_math(p, os, FLAG_SIMPLE, MATH_MODE);
|
||||
os << "\\]";
|
||||
p.getToken(); // skip the second '$' token
|
||||
} else {
|
||||
// simple $...$ stuff
|
||||
p.putback();
|
||||
os << '$';
|
||||
parse_math(p, os, FLAG_SIMPLE, MATH_MODE);
|
||||
os << '$';
|
||||
}
|
||||
}
|
||||
|
||||
else if (flags & FLAG_SIMPLE) {
|
||||
// this is the end of the formula
|
||||
return;
|
||||
}
|
||||
|
||||
else {
|
||||
cerr << "\nmode: " << mode << endl;
|
||||
p.error("something strange in the parser\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
else if (t.cat() == catLetter ||
|
||||
t.cat() == catSpace ||
|
||||
t.cat() == catSuper ||
|
||||
t.cat() == catSub ||
|
||||
t.cat() == catOther ||
|
||||
t.cat() == catAlign ||
|
||||
t.cat() == catActive ||
|
||||
t.cat() == catParameter)
|
||||
os << t.character();
|
||||
|
||||
else if (t.cat() == catNewline) {
|
||||
//if (p.nextToken().cat() == catNewline) {
|
||||
// p.getToken();
|
||||
// handle_par(os);
|
||||
//} else {
|
||||
os << "\n "; // note the space
|
||||
//}
|
||||
}
|
||||
|
||||
else if (t.cat() == catBegin) {
|
||||
os << '{';
|
||||
parse_math(p, os, FLAG_BRACE_LAST, mode);
|
||||
os << '}';
|
||||
}
|
||||
|
||||
else if (t.cat() == catEnd) {
|
||||
if (flags & FLAG_BRACE_LAST)
|
||||
return;
|
||||
os << "unexpected '}' in math\n";
|
||||
}
|
||||
|
||||
else if (t.cat() == catComment)
|
||||
handle_comment(p);
|
||||
|
||||
//
|
||||
// control sequences
|
||||
//
|
||||
|
||||
else if (t.cs() == "(") {
|
||||
os << "\\(";
|
||||
parse_math(p, os, FLAG_SIMPLE2, MATH_MODE);
|
||||
os << "\\)";
|
||||
}
|
||||
|
||||
else if (t.cs() == "[") {
|
||||
os << "\\[";
|
||||
parse_math(p, os, FLAG_EQUATION, MATH_MODE);
|
||||
os << "\\]";
|
||||
}
|
||||
|
||||
else if (t.cs() == "protect")
|
||||
// ignore \\protect, will hopefully be re-added during output
|
||||
;
|
||||
|
||||
else if (t.cs() == "begin") {
|
||||
string const name = p.getArg('{', '}');
|
||||
active_environments_push(name);
|
||||
os << "\\begin{" << name << "}";
|
||||
if (name == "tabular")
|
||||
parse_math(p, os, FLAG_END, MATHTEXT_MODE);
|
||||
else
|
||||
parse_math(p, os, FLAG_END, mode);
|
||||
os << "\\end{" << name << "}";
|
||||
}
|
||||
|
||||
else if (t.cs() == "end") {
|
||||
if (flags & FLAG_END) {
|
||||
// eat environment name
|
||||
string const name = p.getArg('{', '}');
|
||||
if (name != curr_env())
|
||||
p.error("\\end{" + name + "} does not match \\begin{"
|
||||
+ curr_env() + "}");
|
||||
active_environments_pop();
|
||||
return;
|
||||
}
|
||||
p.error("found 'end' unexpectedly");
|
||||
}
|
||||
|
||||
else if (t.cs() == ")") {
|
||||
if (flags & FLAG_SIMPLE2)
|
||||
return;
|
||||
p.error("found '\\)' unexpectedly");
|
||||
}
|
||||
|
||||
else if (t.cs() == "]") {
|
||||
if (flags & FLAG_EQUATION)
|
||||
return;
|
||||
p.error("found '\\]' unexpectedly");
|
||||
}
|
||||
|
||||
else if (t.cs() == "textrm" || t.cs() == "textsf" || t.cs() == "textbf"
|
||||
|| t.cs() == "texttt" || t.cs() == "textsc") {
|
||||
os << '\\' << t.cs() << '{';
|
||||
parse_math(p, os, FLAG_ITEM, MATHTEXT_MODE);
|
||||
os << '}';
|
||||
}
|
||||
|
||||
else if (t.cs() == "mbox") {
|
||||
os << "\\mbox{";
|
||||
parse_math(p, os, FLAG_ITEM, MATHTEXT_MODE);
|
||||
os << '}';
|
||||
}
|
||||
|
||||
else if (t.cs() == "\"") {
|
||||
string const name = p.verbatimItem();
|
||||
if (name == "a") os << 'ä';
|
||||
else if (name == "o") os << 'ö';
|
||||
else if (name == "u") os << 'ü';
|
||||
else if (name == "A") os << 'Ä';
|
||||
else if (name == "O") os << 'Ö';
|
||||
else if (name == "U") os << 'Ü';
|
||||
else os << "\"{" << name << "}";
|
||||
}
|
||||
|
||||
else if (t.cs() == "ss")
|
||||
os << "ß";
|
||||
|
||||
else
|
||||
os << t.asInput();
|
||||
|
||||
if (flags & FLAG_LEAVE) {
|
||||
flags &= ~FLAG_LEAVE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
// }])
|
||||
477
src/tex2lyx/table.C
Normal file
477
src/tex2lyx/table.C
Normal file
@ -0,0 +1,477 @@
|
||||
/** The .tex to .lyx converter
|
||||
\author André Pönitz (2003)
|
||||
*/
|
||||
|
||||
// {[(
|
||||
|
||||
#include <config.h>
|
||||
|
||||
#include "Lsstream.h"
|
||||
#include "tex2lyx.h"
|
||||
|
||||
#include <cctype>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
using std::cerr;
|
||||
using std::endl;
|
||||
using std::istringstream;
|
||||
using std::ostream;
|
||||
using std::ostringstream;
|
||||
using std::string;
|
||||
using std::vector;
|
||||
|
||||
|
||||
namespace {
|
||||
|
||||
struct ColInfo
|
||||
{
|
||||
ColInfo() : rightline(false) {}
|
||||
string align; // column alignment
|
||||
string width; // column width
|
||||
bool rightline; // a line on the right?
|
||||
};
|
||||
|
||||
|
||||
struct RowInfo
|
||||
{
|
||||
RowInfo() : topline(false), bottomline(false) {}
|
||||
bool topline; // horizontal line above
|
||||
bool bottomline; // horizontal line below
|
||||
};
|
||||
|
||||
|
||||
struct CellInfo
|
||||
{
|
||||
CellInfo()
|
||||
: multi(0), leftline(false), rightline(false),
|
||||
topline(false), bottomline(false)
|
||||
{}
|
||||
|
||||
string content; // cell content
|
||||
int multi; // multicolumn flag
|
||||
string align; // cell alignment
|
||||
bool leftline; // do we have a line on the left?
|
||||
bool rightline; // do we have a line on the right?
|
||||
bool topline; // do we have a line above?
|
||||
bool bottomline; // do we have a line below?
|
||||
};
|
||||
|
||||
|
||||
int string2int(string const & s, int deflt = 0)
|
||||
{
|
||||
istringstream is(s);
|
||||
int i = deflt;
|
||||
is >> i;
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
string read_hlines(Parser & p)
|
||||
{
|
||||
ostringstream os;
|
||||
p.skipSpaces();
|
||||
while (p.good()) {
|
||||
if (p.nextToken().cs() == "hline") {
|
||||
p.getToken();
|
||||
os << "\\hline";
|
||||
} else if (p.nextToken().cs() == "cline") {
|
||||
p.getToken();
|
||||
os << "\\cline{" << p.verbatimItem() << "}";
|
||||
} else
|
||||
break;
|
||||
p.skipSpaces();
|
||||
};
|
||||
//cerr << "read_hlines(), read: '" << os.str() << "'\n";
|
||||
//cerr << "read_hlines(), next token: " << p.nextToken() << "\n";
|
||||
return os.str();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* rather brutish way to code table structure in a string:
|
||||
|
||||
\begin{tabular}{ccc}
|
||||
1 & 2 & 3\\ \hline
|
||||
\multicolumn{2}{c}{4} & 5 //
|
||||
6 & 7 \\
|
||||
\end{tabular}
|
||||
|
||||
gets "translated" to:
|
||||
|
||||
1 TAB 2 TAB 3 LINE
|
||||
\hline HLINE TAB 5 LINE
|
||||
5 TAB 7 LINE
|
||||
*/
|
||||
|
||||
char const TAB = '\001';
|
||||
char const LINE = '\002';
|
||||
char const HLINE = '\004';
|
||||
|
||||
|
||||
bool handle_colalign(Parser & p, vector<ColInfo> & colinfo)
|
||||
{
|
||||
if (p.getToken().cat() != catBegin)
|
||||
cerr << "wrong syntax for table column alignment. '{' expected\n";
|
||||
|
||||
string nextalign = "block";
|
||||
bool leftline = false;
|
||||
for (Token t = p.getToken(); p.good() && t.cat() != catEnd; t = p.getToken()){
|
||||
#ifdef FILEDEBUG
|
||||
cerr << "t: " << t << " c: '" << t.character() << "'\n";
|
||||
#endif
|
||||
|
||||
switch (t.character()) {
|
||||
case 'c':
|
||||
colinfo.push_back(ColInfo());
|
||||
colinfo.back().align = "center";
|
||||
break;
|
||||
case 'l':
|
||||
colinfo.push_back(ColInfo());
|
||||
colinfo.back().align = "left";
|
||||
break;
|
||||
case 'r':
|
||||
colinfo.push_back(ColInfo());
|
||||
colinfo.back().align = "right";
|
||||
break;
|
||||
case 'p':
|
||||
colinfo.push_back(ColInfo());
|
||||
colinfo.back().align = nextalign;
|
||||
colinfo.back().width = p.verbatimItem();
|
||||
nextalign = "block";
|
||||
break;
|
||||
case '|':
|
||||
if (colinfo.empty())
|
||||
leftline = true;
|
||||
else
|
||||
colinfo.back().rightline = true;
|
||||
break;
|
||||
case '>': {
|
||||
string s = p.verbatimItem();
|
||||
if (s == "\\raggedleft ")
|
||||
nextalign = "left";
|
||||
else if (s == "\\raggedright ")
|
||||
nextalign = "right";
|
||||
else
|
||||
cerr << "unknown '>' column '" << s << "'\n";
|
||||
break;
|
||||
}
|
||||
default:
|
||||
cerr << "ignoring special separator '" << t << "'\n";
|
||||
break;
|
||||
}
|
||||
}
|
||||
return leftline;
|
||||
}
|
||||
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
|
||||
void parse_table(Parser & p, ostream & os, unsigned flags)
|
||||
{
|
||||
string hlines;
|
||||
|
||||
while (p.good()) {
|
||||
Token const & t = p.getToken();
|
||||
|
||||
#ifdef FILEDEBUG
|
||||
cerr << "t: " << t << " flags: " << flags << "\n";
|
||||
#endif
|
||||
|
||||
//
|
||||
// cat codes
|
||||
//
|
||||
if (t.cat() == catMath) {
|
||||
// we are inside some text mode thingy, so opening new math is allowed
|
||||
Token const & n = p.getToken();
|
||||
if (n.cat() == catMath) {
|
||||
// TeX's $$...$$ syntax for displayed math
|
||||
os << "\\[";
|
||||
parse_math(p, os, FLAG_SIMPLE, MATH_MODE);
|
||||
os << "\\]";
|
||||
p.getToken(); // skip the second '$' token
|
||||
} else {
|
||||
// simple $...$ stuff
|
||||
p.putback();
|
||||
os << '$';
|
||||
parse_math(p, os, FLAG_SIMPLE, MATH_MODE);
|
||||
os << '$';
|
||||
}
|
||||
}
|
||||
|
||||
else if (t.cat() == catLetter ||
|
||||
t.cat() == catSpace ||
|
||||
t.cat() == catSuper ||
|
||||
t.cat() == catSub ||
|
||||
t.cat() == catOther ||
|
||||
t.cat() == catActive ||
|
||||
t.cat() == catNewline ||
|
||||
t.cat() == catParameter)
|
||||
os << t.character();
|
||||
|
||||
else if (t.cat() == catBegin) {
|
||||
os << '{';
|
||||
parse_table(p, os, FLAG_BRACE_LAST);
|
||||
os << '}';
|
||||
}
|
||||
|
||||
else if (t.cat() == catEnd) {
|
||||
if (flags & FLAG_BRACE_LAST)
|
||||
return;
|
||||
cerr << "unexpected '}'\n";
|
||||
}
|
||||
|
||||
else if (t.cat() == catAlign) {
|
||||
os << TAB;
|
||||
}
|
||||
|
||||
else if (t.cs() == "tabularnewline" || t.cs() == "\\") {
|
||||
// stuff before the line break
|
||||
// and look ahead for stuff after the line break
|
||||
os << HLINE << hlines << HLINE << LINE << read_hlines(p) << HLINE;
|
||||
hlines.clear();
|
||||
}
|
||||
|
||||
else if (t.cs() == "hline")
|
||||
hlines += "\\hline";
|
||||
|
||||
else if (t.cs() == "cline")
|
||||
hlines += "\\cline{" + p.verbatimItem() + '}';
|
||||
|
||||
else if (t.cat() == catComment)
|
||||
handle_comment(p);
|
||||
|
||||
else if (t.cs() == "(") {
|
||||
os << "\\(";
|
||||
parse_math(p, os, FLAG_SIMPLE2, MATH_MODE);
|
||||
os << "\\)";
|
||||
}
|
||||
|
||||
else if (t.cs() == "[") {
|
||||
os << "\\[";
|
||||
parse_math(p, os, FLAG_EQUATION, MATH_MODE);
|
||||
os << "\\]";
|
||||
}
|
||||
|
||||
else if (t.cs() == "begin") {
|
||||
string const name = p.getArg('{', '}');
|
||||
active_environments_push(name);
|
||||
parse_table(p, os, FLAG_END);
|
||||
}
|
||||
|
||||
else if (t.cs() == "end") {
|
||||
if (flags & FLAG_END) {
|
||||
// eat environment name
|
||||
string const name = p.getArg('{', '}');
|
||||
if (name != curr_env())
|
||||
p.error("\\end{" + name + "} does not match \\begin{"
|
||||
+ curr_env() + "}");
|
||||
active_environments_pop();
|
||||
return;
|
||||
}
|
||||
p.error("found 'end' unexpectedly");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void handle_tabular(Parser & p, ostream & os)
|
||||
{
|
||||
string posopts = p.getOpt();
|
||||
if (posopts.size())
|
||||
cerr << "vertical tabular positioning '" << posopts << "' ignored\n";
|
||||
|
||||
vector<ColInfo> colinfo;
|
||||
|
||||
// handle column formatting
|
||||
bool leftline = handle_colalign(p, colinfo);
|
||||
|
||||
// handle initial hlines
|
||||
|
||||
// first scan of cells
|
||||
// use table mode to keep it minimal-invasive
|
||||
// not exactly what's TeX doing...
|
||||
vector<string> lines;
|
||||
ostringstream ss;
|
||||
ss << read_hlines(p) << HLINE; // handle initial hlines
|
||||
parse_table(p, ss, FLAG_END);
|
||||
split(ss.str(), lines, LINE);
|
||||
|
||||
vector< vector<CellInfo> > cellinfo(lines.size());
|
||||
vector<RowInfo> rowinfo(lines.size());
|
||||
|
||||
// split into rows
|
||||
//cerr << "// split into rows\n";
|
||||
for (size_t row = 0; row < rowinfo.size(); ++row) {
|
||||
|
||||
// init row
|
||||
vector<CellInfo> & cellinfos = cellinfo[row];
|
||||
cellinfos.resize(colinfo.size());
|
||||
|
||||
// split row
|
||||
vector<string> dummy;
|
||||
//cerr << "\n########### LINE: " << lines[row] << "########\n";
|
||||
split(lines[row], dummy, HLINE);
|
||||
|
||||
// handle horizontal line fragments
|
||||
if (dummy.size() != 3) {
|
||||
if (dummy.size() != 1)
|
||||
cerr << "unexpected dummy size: " << dummy.size()
|
||||
<< " content: " << lines[row] << "\n";
|
||||
dummy.resize(3);
|
||||
}
|
||||
lines[row] = dummy[1];
|
||||
|
||||
//cerr << "line: " << row << " above 0: " << dummy[0] << "\n";
|
||||
//cerr << "line: " << row << " below 2: " << dummy[2] << "\n";
|
||||
//cerr << "line: " << row << " cells 1: " << dummy[1] << "\n";
|
||||
|
||||
for (int i = 0; i <= 2; i += 2) {
|
||||
//cerr << " reading from line string '" << dummy[i] << "'\n";
|
||||
Parser p1(dummy[i]);
|
||||
while (p1.good()) {
|
||||
Token t = p1.getToken();
|
||||
//cerr << "read token: " << t << "\n";
|
||||
if (t.cs() == "hline") {
|
||||
if (i == 0) {
|
||||
rowinfo[row].topline = true;
|
||||
for (size_t col = 0; col < colinfo.size(); ++col)
|
||||
cellinfos[col].topline = true;
|
||||
} else {
|
||||
rowinfo[row].bottomline = true;
|
||||
for (size_t col = 0; col < colinfo.size(); ++col)
|
||||
cellinfos[col].bottomline = true;
|
||||
}
|
||||
} else if (t.cs() == "cline") {
|
||||
string arg = p1.verbatimItem();
|
||||
//cerr << "read cline arg: '" << arg << "'\n";
|
||||
vector<string> t;
|
||||
split(arg, t, '-');
|
||||
t.resize(2);
|
||||
size_t from = string2int(t[0]);
|
||||
size_t to = string2int(t[1]);
|
||||
for (size_t col = from; col < to; ++col) {
|
||||
if (i == 0)
|
||||
cellinfos[col].topline = true;
|
||||
else
|
||||
cellinfos[col].bottomline = true;
|
||||
}
|
||||
} else {
|
||||
cerr << "unexpected line token: " << t << endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// split into cells
|
||||
vector<string> cells;
|
||||
split(lines[row], cells, TAB);
|
||||
for (size_t col = 0, cell = 0; cell < cells.size() && col < colinfo.size(); ++col, ++cell) {
|
||||
//cerr << "cell content: " << cells[cell] << "\n";
|
||||
Parser p(cells[cell]);
|
||||
p.skipSpaces();
|
||||
//cerr << "handling cell: " << p.nextToken().cs() << " '" <<
|
||||
//cells[cell] << "'\n";
|
||||
if (p.nextToken().cs() == "multicolumn") {
|
||||
// how many cells?
|
||||
p.getToken();
|
||||
size_t ncells = string2int(p.verbatimItem());
|
||||
|
||||
// special cell properties alignment
|
||||
vector<ColInfo> t;
|
||||
bool leftline = handle_colalign(p, t);
|
||||
CellInfo & ci = cellinfos[col];
|
||||
ci.multi = 1;
|
||||
ci.align = t.front().align;
|
||||
ci.content = parse_text(p, FLAG_ITEM, false);
|
||||
ci.leftline = leftline;
|
||||
ci.rightline = t.front().rightline;
|
||||
|
||||
// add dummy cells for multicol
|
||||
for (size_t i = 0; i < ncells - 1 && col < colinfo.size(); ++i) {
|
||||
++col;
|
||||
cellinfos[col].multi = 2;
|
||||
cellinfos[col].align = "center";
|
||||
}
|
||||
} else {
|
||||
cellinfos[col].content = parse_text(p, FLAG_ITEM, false);
|
||||
}
|
||||
}
|
||||
|
||||
cellinfo.push_back(cellinfos);
|
||||
|
||||
//cerr << "// handle almost empty last row what we have\n";
|
||||
// handle almost empty last row
|
||||
if (row && lines[row].empty() && row + 1 == rowinfo.size()) {
|
||||
//cerr << "remove empty last line\n";
|
||||
if (rowinfo[row].topline);
|
||||
rowinfo[row - 1].bottomline = true;
|
||||
for (size_t col = 0; col < colinfo.size(); ++col)
|
||||
if (cellinfo[row][col].topline)
|
||||
cellinfo[row - 1][col].bottomline = true;
|
||||
rowinfo.pop_back();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//cerr << "// output what we have\n";
|
||||
// output what we have
|
||||
os << "<lyxtabular version=\"3\" rows=\"" << rowinfo.size()
|
||||
<< "\" columns=\"" << colinfo.size() << "\">\n"
|
||||
<< "<features>\n";
|
||||
|
||||
//cerr << "// after header\n";
|
||||
for (size_t col = 0; col < colinfo.size(); ++col) {
|
||||
os << "<column alignment=\"" << colinfo[col].align << "\"";
|
||||
if (colinfo[col].rightline)
|
||||
os << " rightline=\"true\"";
|
||||
if (col == 0 && leftline)
|
||||
os << " leftline=\"true\"";
|
||||
os << " valignment=\"top\"";
|
||||
os << " width=\"" << colinfo[col].width << "\"";
|
||||
os << ">\n";
|
||||
}
|
||||
//cerr << "// after cols\n";
|
||||
|
||||
for (size_t row = 0; row < rowinfo.size(); ++row) {
|
||||
os << "<row";
|
||||
if (rowinfo[row].topline)
|
||||
os << " topline=\"true\"";
|
||||
if (rowinfo[row].bottomline)
|
||||
os << " bottomline=\"true\"";
|
||||
os << ">\n";
|
||||
for (size_t col = 0; col < colinfo.size(); ++col) {
|
||||
CellInfo const & cell = cellinfo[row][col];
|
||||
os << "<cell";
|
||||
if (cell.multi)
|
||||
os << " multicolumn=\"" << cell.multi << "\"";
|
||||
if (cell.leftline)
|
||||
os << " leftline=\"true\"";
|
||||
if (cell.rightline)
|
||||
os << " rightline=\"true\"";
|
||||
if (cell.topline)
|
||||
os << " topline=\"true\"";
|
||||
if (cell.bottomline)
|
||||
os << " bottomline=\"true\"";
|
||||
os << " alignment=\"" << cell.align << "\""
|
||||
<< " valignment=\"top\""
|
||||
<< " usebox=\"none\""
|
||||
<< ">"
|
||||
<< "\n\\begin_inset Text"
|
||||
<< "\n\n\\layout Standard\n\n"
|
||||
<< cell.content
|
||||
<< "\n\\end_inset\n\n"
|
||||
<< "</cell>\n";
|
||||
}
|
||||
os << "</row>\n";
|
||||
}
|
||||
|
||||
os << "</lyxtabular>\n";
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
// }])
|
||||
File diff suppressed because it is too large
Load Diff
495
src/tex2lyx/text.C
Normal file
495
src/tex2lyx/text.C
Normal file
@ -0,0 +1,495 @@
|
||||
/** The .tex to .lyx converter
|
||||
\author André Pönitz (2003)
|
||||
*/
|
||||
|
||||
// {[(
|
||||
|
||||
#include <config.h>
|
||||
|
||||
#include "Lsstream.h"
|
||||
#include "tex2lyx.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
using std::cerr;
|
||||
using std::endl;
|
||||
using std::map;
|
||||
using std::ostream;
|
||||
using std::ostringstream;
|
||||
using std::string;
|
||||
using std::vector;
|
||||
|
||||
|
||||
namespace {
|
||||
|
||||
char const * known_headings[] = { "caption", "title", "author", "date",
|
||||
"paragraph", "chapter", "section", "subsection", "subsubsection", 0 };
|
||||
|
||||
char const * known_latex_commands[] = { "ref", "cite", "label", "index",
|
||||
"printindex", "pageref", "url", 0 };
|
||||
|
||||
// LaTeX names for quotes
|
||||
char const * known_quotes[] = { "glqq", "grqq", "quotedblbase",
|
||||
"textquotedblleft", 0};
|
||||
|
||||
// the same as known_quotes with .lyx names
|
||||
char const * known_coded_quotes[] = { "gld", "grd", "gld", "grd", 0};
|
||||
|
||||
|
||||
string cap(string s)
|
||||
{
|
||||
if (s.size())
|
||||
s[0] = toupper(s[0]);
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
// splits "x=z, y=b" into a map
|
||||
map<string, string> split_map(string const & s)
|
||||
{
|
||||
map<string, string> res;
|
||||
vector<string> v;
|
||||
split(s, v);
|
||||
for (size_t i = 0; i < v.size(); ++i) {
|
||||
size_t const pos = v[i].find('=');
|
||||
string const index = v[i].substr(0, pos);
|
||||
string const value = v[i].substr(pos + 1, string::npos);
|
||||
res[trim(index)] = trim(value);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
void begin_inset(ostream & os, string const & name)
|
||||
{
|
||||
os << "\n\\begin_inset " << name;
|
||||
}
|
||||
|
||||
|
||||
void end_inset(ostream & os)
|
||||
{
|
||||
os << "\n\\end_inset\n\n";
|
||||
}
|
||||
|
||||
|
||||
void handle_ert(ostream & os, string const & s)
|
||||
{
|
||||
begin_inset(os, "ERT");
|
||||
os << "\nstatus Collapsed\n\n\\layout Standard\n\n";
|
||||
for (string::const_iterator it = s.begin(), et = s.end(); it != et; ++it) {
|
||||
if (*it == '\\')
|
||||
os << "\n\\backslash\n";
|
||||
else
|
||||
os << *it;
|
||||
}
|
||||
end_inset(os);
|
||||
}
|
||||
|
||||
|
||||
void handle_par(ostream & os)
|
||||
{
|
||||
if (active_environments_empty())
|
||||
return;
|
||||
os << "\n\\layout ";
|
||||
string s = curr_env();
|
||||
if (s == "document" || s == "table")
|
||||
os << "Standard\n\n";
|
||||
else if (s == "lyxcode")
|
||||
os << "LyX-Code\n\n";
|
||||
else if (s == "lyxlist")
|
||||
os << "List\n\n";
|
||||
else if (s == "thebibliography")
|
||||
os << "Bibliography\n\n";
|
||||
else
|
||||
os << cap(s) << "\n\n";
|
||||
}
|
||||
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
|
||||
void parse_text(Parser & p, ostream & os, unsigned flags, bool outer)
|
||||
{
|
||||
while (p.good()) {
|
||||
Token const & t = p.getToken();
|
||||
|
||||
#ifdef FILEDEBUG
|
||||
cerr << "t: " << t << " flags: " << flags << "\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;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// cat codes
|
||||
//
|
||||
if (t.cat() == catMath) {
|
||||
// we are inside some text mode thingy, so opening new math is allowed
|
||||
begin_inset(os, "Formula ");
|
||||
Token const & n = p.getToken();
|
||||
if (n.cat() == catMath && outer) {
|
||||
// TeX's $$...$$ syntax for displayed math
|
||||
os << "\\[";
|
||||
parse_math(p, os, FLAG_SIMPLE, MATH_MODE);
|
||||
os << "\\]";
|
||||
p.getToken(); // skip the second '$' token
|
||||
} else {
|
||||
// simple $...$ stuff
|
||||
p.putback();
|
||||
os << '$';
|
||||
parse_math(p, os, FLAG_SIMPLE, MATH_MODE);
|
||||
os << '$';
|
||||
}
|
||||
end_inset(os);
|
||||
}
|
||||
|
||||
else if (t.cat() == catSuper || t.cat() == catSub)
|
||||
cerr << "catcode " << t << " illegal in text mode\n";
|
||||
|
||||
else if (t.cat() == catLetter ||
|
||||
t.cat() == catSpace ||
|
||||
t.cat() == catOther ||
|
||||
t.cat() == catAlign ||
|
||||
t.cat() == catParameter)
|
||||
os << t.character();
|
||||
|
||||
else if (t.cat() == catNewline) {
|
||||
if (p.nextToken().cat() == catNewline) {
|
||||
p.getToken();
|
||||
handle_par(os);
|
||||
} else {
|
||||
os << "\n "; // note the space
|
||||
}
|
||||
}
|
||||
|
||||
else if (t.cat() == catActive) {
|
||||
if (t.character() == '~') {
|
||||
if (curr_env() == "lyxcode")
|
||||
os << ' ';
|
||||
else
|
||||
os << "\\SpecialChar ~\n";
|
||||
} else
|
||||
os << t.character();
|
||||
}
|
||||
|
||||
else if (t.cat() == catBegin) {
|
||||
handle_ert(os, "{");
|
||||
parse_text(p, os, FLAG_BRACE_LAST, outer);
|
||||
handle_ert(os, "}");
|
||||
}
|
||||
|
||||
else if (t.cat() == catEnd) {
|
||||
if (flags & FLAG_BRACE_LAST)
|
||||
return;
|
||||
cerr << "stray '}' in text\n";
|
||||
handle_ert(os, "}");
|
||||
}
|
||||
|
||||
else if (t.cat() == catOther)
|
||||
os << string(1, t.character());
|
||||
|
||||
else if (t.cat() == catComment)
|
||||
handle_comment(p);
|
||||
|
||||
//
|
||||
// control sequences
|
||||
//
|
||||
|
||||
else if (t.cs() == "ldots")
|
||||
os << "\n\\SpecialChar \\ldots{}\n";
|
||||
|
||||
else if (t.cs() == "(") {
|
||||
begin_inset(os, "Formula");
|
||||
os << " \\(";
|
||||
parse_math(p, os, FLAG_SIMPLE2, MATH_MODE);
|
||||
os << "\\)";
|
||||
end_inset(os);
|
||||
}
|
||||
|
||||
else if (t.cs() == "[") {
|
||||
begin_inset(os, "Formula");
|
||||
os << " \\[";
|
||||
parse_math(p, os, FLAG_EQUATION, MATH_MODE);
|
||||
os << "\\]";
|
||||
end_inset(os);
|
||||
}
|
||||
|
||||
else if (t.cs() == "begin") {
|
||||
string const name = p.getArg('{', '}');
|
||||
active_environments_push(name);
|
||||
if (name == "abstract") {
|
||||
handle_par(os);
|
||||
parse_text(p, os, FLAG_END, outer);
|
||||
} else if (is_math_env(name)) {
|
||||
begin_inset(os, "Formula ");
|
||||
os << "\\begin{" << name << "}";
|
||||
parse_math(p, os, FLAG_END, MATH_MODE);
|
||||
os << "\\end{" << name << "}";
|
||||
end_inset(os);
|
||||
} else if (name == "tabular") {
|
||||
begin_inset(os, "Tabular ");
|
||||
handle_tabular(p, os);
|
||||
end_inset(os);
|
||||
} else if (name == "table" || name == "figure") {
|
||||
string opts = p.getOpt();
|
||||
begin_inset(os, "Float " + name + "\n");
|
||||
if (opts.size())
|
||||
os << "placement " << opts << '\n';
|
||||
os << "wide false\n"
|
||||
<< "collapsed false\n"
|
||||
<< "\n"
|
||||
<< "\\layout Standard\n";
|
||||
parse_text(p, os, FLAG_END, outer);
|
||||
end_inset(os);
|
||||
} else if (name == "lyxlist") {
|
||||
p.verbatimItem(); // swallow next arg
|
||||
parse_text(p, os, FLAG_END, outer);
|
||||
os << "\n\\layout Bibliography\n\n";
|
||||
} else if (name == "thebibliography") {
|
||||
p.verbatimItem(); // swallow next arg
|
||||
parse_text(p, os, FLAG_END, outer);
|
||||
os << "\n\\layout Bibliography\n\n";
|
||||
} else {
|
||||
parse_text(p, os, FLAG_END, outer);
|
||||
}
|
||||
}
|
||||
|
||||
else if (t.cs() == "end") {
|
||||
if (flags & FLAG_END) {
|
||||
// eat environment name
|
||||
string const name = p.getArg('{', '}');
|
||||
if (name != curr_env())
|
||||
p.error("\\end{" + name + "} does not match \\begin{"
|
||||
+ curr_env() + "}");
|
||||
active_environments_pop();
|
||||
return;
|
||||
}
|
||||
p.error("found 'end' unexpectedly");
|
||||
}
|
||||
|
||||
else if (t.cs() == "item")
|
||||
handle_par(os);
|
||||
|
||||
else if (t.cs() == "def") {
|
||||
string name = p.getToken().cs();
|
||||
while (p.nextToken().cat() != catBegin)
|
||||
name += p.getToken().asString();
|
||||
handle_ert(os, "\\def\\" + name + '{' + p.verbatimItem() + '}');
|
||||
}
|
||||
|
||||
else if (t.cs() == "par")
|
||||
handle_par(os);
|
||||
|
||||
else if (is_known(t.cs(), known_headings)) {
|
||||
string name = t.cs();
|
||||
if (p.nextToken().asInput() == "*") {
|
||||
p.getToken();
|
||||
name += "*";
|
||||
}
|
||||
os << "\n\n\\layout " << cap(name) << "\n\n";
|
||||
string opt = p.getOpt();
|
||||
if (opt.size()) {
|
||||
begin_inset(os, "OptArg\n");
|
||||
os << "collapsed true\n\n\\layout Standard\n\n" << opt;
|
||||
end_inset(os);
|
||||
}
|
||||
parse_text(p, os, FLAG_ITEM, outer);
|
||||
os << "\n\n\\layout Standard\n\n";
|
||||
}
|
||||
|
||||
else if (t.cs() == "includegraphics") {
|
||||
map<string, string> opts = split_map(p.getArg('[', ']'));
|
||||
string name = p.verbatimItem();
|
||||
begin_inset(os, "Graphics ");
|
||||
os << "\n\tfilename " << name << '\n';
|
||||
if (opts.find("width") != opts.end())
|
||||
os << "\twidth " << opts["width"] << '\n';
|
||||
if (opts.find("height") != opts.end())
|
||||
os << "\theight " << opts["height"] << '\n';
|
||||
end_inset(os);
|
||||
}
|
||||
|
||||
else if (t.cs() == "footnote") {
|
||||
begin_inset(os, "Foot\n");
|
||||
os << "collapsed true\n\n\\layout Standard\n\n";
|
||||
parse_text(p, os, FLAG_ITEM, false);
|
||||
end_inset(os);
|
||||
}
|
||||
|
||||
else if (t.cs() == "makeindex" || t.cs() == "maketitle")
|
||||
; // swallow this
|
||||
|
||||
else if (t.cs() == "tableofcontents")
|
||||
p.verbatimItem(); // swallow this
|
||||
|
||||
else if (t.cs() == "tiny" || t.cs() == "scriptsize")
|
||||
os << "\n\\size " << t.cs() << "\n";
|
||||
|
||||
else if (t.cs() == "Large")
|
||||
os << "\n\\size larger\n";
|
||||
|
||||
else if (t.cs() == "textrm") {
|
||||
os << "\n\\family roman\n";
|
||||
parse_text(p, os, FLAG_ITEM, outer);
|
||||
os << "\n\\family default\n";
|
||||
}
|
||||
|
||||
else if (t.cs() == "textsf") {
|
||||
os << "\n\\family sans\n";
|
||||
parse_text(p, os, FLAG_ITEM, outer);
|
||||
os << "\n\\family default\n";
|
||||
}
|
||||
|
||||
else if (t.cs() == "texttt") {
|
||||
os << "\n\\family typewriter\n";
|
||||
parse_text(p, os, FLAG_ITEM, outer);
|
||||
os << "\n\\family default\n";
|
||||
}
|
||||
|
||||
else if (t.cs() == "textsc") {
|
||||
os << "\n\\noun on\n";
|
||||
parse_text(p, os, FLAG_ITEM, outer);
|
||||
os << "\n\\noun default\n";
|
||||
}
|
||||
|
||||
else if (t.cs() == "textbf") {
|
||||
os << "\n\\series bold\n";
|
||||
parse_text(p, os, FLAG_ITEM, outer);
|
||||
os << "\n\\series default\n";
|
||||
}
|
||||
|
||||
else if (t.cs() == "underbar") {
|
||||
os << "\n\\bar under\n";
|
||||
parse_text(p, os, FLAG_ITEM, outer);
|
||||
os << "\n\\bar default\n";
|
||||
}
|
||||
|
||||
else if (t.cs() == "emph" || t.cs() == "noun") {
|
||||
os << "\n\\" << t.cs() << " on\n";
|
||||
parse_text(p, os, FLAG_ITEM, outer);
|
||||
os << "\n\\" << t.cs() << " default\n";
|
||||
}
|
||||
|
||||
else if (t.cs() == "bibitem") {
|
||||
os << "\n\\layout Bibliography\n\\bibitem ";
|
||||
os << p.getOpt();
|
||||
os << '{' << p.verbatimItem() << '}' << "\n\n";
|
||||
}
|
||||
|
||||
else if (is_known(t.cs(), known_latex_commands)) {
|
||||
begin_inset(os, "LatexCommand ");
|
||||
os << '\\' << t.cs();
|
||||
os << p.getOpt();
|
||||
os << p.getOpt();
|
||||
os << '{' << p.verbatimItem() << '}';
|
||||
end_inset(os);
|
||||
}
|
||||
|
||||
else if (is_known(t.cs(), known_quotes)) {
|
||||
char const ** where = is_known(t.cs(), known_quotes);
|
||||
begin_inset(os, "Quotes ");
|
||||
os << known_coded_quotes[where - known_quotes];
|
||||
end_inset(os);
|
||||
}
|
||||
|
||||
else if (t.cs() == "LyX" || t.cs() == "TeX"
|
||||
|| t.cs() == "LaTeX" || t.cs() == "LaTeXe") {
|
||||
p.verbatimItem(); // eat {}
|
||||
os << "LyX";
|
||||
}
|
||||
|
||||
else if (t.cs() == "lyxarrow") {
|
||||
p.verbatimItem();
|
||||
os << "\\SpecialChar \\menuseparator\n";
|
||||
}
|
||||
|
||||
else if (t.cs() == "ldots") {
|
||||
p.verbatimItem();
|
||||
os << "\\SpecialChar \\ldots{}\n";
|
||||
}
|
||||
|
||||
else if (t.cs() == "@")
|
||||
os << "\\SpecialChar \\@";
|
||||
|
||||
else if (t.cs() == "textasciitilde")
|
||||
os << '~';
|
||||
|
||||
else if (t.cs() == "_" || t.cs() == "&" || t.cs() == "#")
|
||||
os << t.cs();
|
||||
|
||||
else if (t.cs() == "\"") {
|
||||
string const name = p.verbatimItem();
|
||||
if (name == "a") os << 'ä';
|
||||
else if (name == "o") os << 'ö';
|
||||
else if (name == "u") os << 'ü';
|
||||
else if (name == "A") os << 'Ä';
|
||||
else if (name == "O") os << 'Ö';
|
||||
else if (name == "U") os << 'Ü';
|
||||
else handle_ert(os, "\"{" + name + "}");
|
||||
}
|
||||
|
||||
else if (t.cs() == "ss")
|
||||
os << "ß";
|
||||
|
||||
else if (t.cs() == "input")
|
||||
handle_ert(os, "\\input{" + p.verbatimItem() + "}\n");
|
||||
|
||||
else if (t.cs() == "fancyhead") {
|
||||
ostringstream ss;
|
||||
ss << "\\fancyhead";
|
||||
ss << p.getOpt();
|
||||
ss << '{' << p.verbatimItem() << "}\n";
|
||||
handle_ert(os, ss.str());
|
||||
}
|
||||
|
||||
else {
|
||||
//cerr << "#: " << t << " mode: " << mode << endl;
|
||||
// heuristic: read up to next non-nested space
|
||||
/*
|
||||
string s = t.asInput();
|
||||
string z = p.verbatimItem();
|
||||
while (p.good() && z != " " && z.size()) {
|
||||
//cerr << "read: " << z << endl;
|
||||
s += z;
|
||||
z = p.verbatimItem();
|
||||
}
|
||||
cerr << "found ERT: " << s << endl;
|
||||
handle_ert(os, s + ' ');
|
||||
*/
|
||||
handle_ert(os, t.asInput() + ' ');
|
||||
}
|
||||
|
||||
if (flags & FLAG_LEAVE) {
|
||||
flags &= ~FLAG_LEAVE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
string parse_text(Parser & p, unsigned flags, const bool outer)
|
||||
{
|
||||
ostringstream os;
|
||||
parse_text(p, os, flags, outer);
|
||||
return os.str();
|
||||
}
|
||||
|
||||
|
||||
// }])
|
||||
Loading…
Reference in New Issue
Block a user