// remove dummy empty par
paragraphs().clear();
- Lexer lex(0, 0);
+ Lexer lex;
istringstream is(s);
lex.setStream(is);
FileName const name = FileName::tempName();
// remove dummy empty par
paragraphs().clear();
- Lexer lex(0, 0);
+ Lexer lex;
lex.setFile(fname);
if (readFile(lex, fname) != success)
return false;
BN_DEFINE
};
-keyword_item cmdDefTags[] = {
+LexerKeyword cmdDefTags[] = {
{ "\\def_file", BN_DEFFILE },
{ "\\define", BN_DEFINE }
};
bool CmdDef::read(string const & def_file)
{
- const int cmdDefCount = sizeof(cmdDefTags) / sizeof(keyword_item);
-
- Lexer lexrc(cmdDefTags, cmdDefCount);
+ Lexer lexrc(cmdDefTags);
if (lyxerr.debugging(Debug::PARSER))
lexrc.printTable(lyxerr);
time_t const now = current_time();
FileName const index(addName(cache_dir.absFilename(), "index"));
ifstream is(index.toFilesystemEncoding().c_str());
- Lexer lex(0, 0);
+ Lexer lex;
lex.setStream(is);
while (lex.isOK()) {
if (!lex.next(true))
{
// We must read the symbolsfile first, because the Encoding
// constructor depends on it.
- Lexer symbolslex(0, 0);
+ Lexer symbolslex;
symbolslex.setFile(symbolsfile);
while (symbolslex.isOK()) {
char_type symbol;
enum Encodingtags {
et_encoding = 1,
et_end,
- et_last
};
- struct keyword_item encodingtags[et_last - 1] = {
+ struct LexerKeyword encodingtags[] = {
{ "encoding", et_encoding },
{ "end", et_end }
};
- Lexer lex(encodingtags, et_last - 1);
+ Lexer lex(encodingtags);
lex.setFile(encfile);
while (lex.isOK()) {
switch (lex.lex()) {
bool Font::fromString(string const & data, bool & toggle)
{
istringstream is(data);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(is);
int nset = 0;
BN_UNBIND,
};
-keyword_item bindTags[] = {
+LexerKeyword bindTags[] = {
{ "\\bind", BN_BIND },
{ "\\bind_file", BN_BINDFILE },
{ "\\unbind", BN_UNBIND },
bool KeyMap::read(string const & bind_file, KeyMap * unbind_map)
{
- const int bindCount = sizeof(bindTags) / sizeof(keyword_item);
-
- Lexer lexrc(bindTags, bindCount);
+ Lexer lexrc(bindTags);
if (lyxerr.debugging(Debug::PARSER))
lexrc.printTable(lyxerr);
void LaTeXFeatures::getAvailable()
{
- Lexer lex(0, 0);
+ Lexer lex;
support::FileName const real_file = libFileSearch("", "packages.lst");
if (real_file.empty())
encodings.fromLyXName("iso8859-1"),
"latex", "");
- Lexer lex(0, 0);
+ Lexer lex;
lex.setFile(filename);
while (lex.isOK()) {
string lang;
bool Layout::read(Lexer & lexrc, TextClass const & tclass)
{
// This table is sorted alphabetically [asierra 30March96]
- keyword_item layoutTags[] = {
+ LexerKeyword layoutTags[] = {
{ "align", LT_ALIGN },
{ "alignpossible", LT_ALIGNPOSSIBLE },
{ "bottomsep", LT_BOTTOMSEP },
bool error = false;
bool finished = false;
- lexrc.pushTable(layoutTags, LT_INTITLE);
+ lexrc.pushTable(layoutTags);
// parse style section
while (!finished && lexrc.isOK() && !error) {
int le = lexrc.lex();
void Layout::readAlign(Lexer & lexrc)
{
- keyword_item alignTags[] = {
+ LexerKeyword alignTags[] = {
{ "block", AT_BLOCK },
{ "center", AT_CENTER },
{ "layout", AT_LAYOUT },
void Layout::readAlignPossible(Lexer & lexrc)
{
- keyword_item alignTags[] = {
+ LexerKeyword alignTags[] = {
{ "block", AT_BLOCK },
{ "center", AT_CENTER },
{ "layout", AT_LAYOUT },
{ "right", AT_RIGHT }
};
- lexrc.pushTable(alignTags, AT_LAYOUT);
+ lexrc.pushTable(alignTags);
alignpossible = LYX_ALIGN_NONE | LYX_ALIGN_LAYOUT;
- int lineno = lexrc.getLineNo();
+ int lineno = lexrc.lineNumber();
do {
int le = lexrc.lex();
switch (le) {
alignpossible |= LYX_ALIGN_LAYOUT;
break;
}
- } while (lineno == lexrc.getLineNo());
+ } while (lineno == lexrc.lineNumber());
lexrc.popTable();
}
void Layout::readLabelType(Lexer & lexrc)
{
- keyword_item labelTypeTags[] = {
+ LexerKeyword labelTypeTags[] = {
{ "bibliography", LA_BIBLIO },
{ "centered_top_environment", LA_CENTERED_TOP_ENVIRONMENT },
{ "counter", LA_COUNTER },
}
-static keyword_item endlabelTypeTags[] =
+static LexerKeyword endlabelTypeTags[] =
{
{ "box", END_LABEL_BOX },
{ "filled_box", END_LABEL_FILLED_BOX },
void Layout::readMargin(Lexer & lexrc)
{
- keyword_item marginTags[] = {
+ LexerKeyword marginTags[] = {
{ "dynamic", MARGIN_DYNAMIC },
{ "first_dynamic", MARGIN_FIRST_DYNAMIC },
{ "manual", MARGIN_MANUAL },
void Layout::readLatexType(Lexer & lexrc)
{
- keyword_item latexTypeTags[] = {
+ LexerKeyword latexTypeTags[] = {
{ "bib_environment", LATEX_BIB_ENVIRONMENT },
{ "command", LATEX_COMMAND },
{ "environment", LATEX_ENVIRONMENT },
void Layout::readSpacing(Lexer & lexrc)
{
- keyword_item spacingTags[] = {
+ LexerKeyword spacingTags[] = {
{"double", ST_SPACING_DOUBLE },
{"onehalf", ST_SPACING_ONEHALF },
{"other", ST_OTHER },
// Reads LyX textclass definitions according to textclass config file
bool LayoutFileList::read()
{
- Lexer lex(0, 0);
+ Lexer lex;
FileName const real_file = libFileSearch("", "textclass.lst");
LYXERR(Debug::TCLASS, "Reading textclasses from `" << real_file << '\'');
class Lexer::Pimpl {
public:
///
- Pimpl(keyword_item * tab, int num);
+ Pimpl(LexerKeyword * tab, int num);
///
string const getString() const;
///
///
void printTable(ostream & os);
///
- void pushTable(keyword_item * tab, int num);
+ void pushTable(LexerKeyword * tab, int num);
///
void popTable();
///
///
string name;
///
- keyword_item * table;
+ LexerKeyword * table;
///
int no_items;
///
PushedTable()
: table_elem(0), table_siz(0) {}
///
- PushedTable(keyword_item * ki, int siz)
+ PushedTable(LexerKeyword * ki, int siz)
: table_elem(ki), table_siz(siz) {}
///
- keyword_item * table_elem;
+ LexerKeyword * table_elem;
///
int table_siz;
};
namespace {
class CompareTags
- : public binary_function<keyword_item, keyword_item, bool> {
+ : public binary_function<LexerKeyword, LexerKeyword, bool> {
public:
// used by lower_bound, sort and sorted
- bool operator()(keyword_item const & a, keyword_item const & b) const
+ bool operator()(LexerKeyword const & a, LexerKeyword const & b) const
{
// we use the ascii version, because in turkish, 'i'
// is not the lowercase version of 'I', and thus
} // end of anon namespace
-Lexer::Pimpl::Pimpl(keyword_item * tab, int num)
+Lexer::Pimpl::Pimpl(LexerKeyword * tab, int num)
: is(&fb_), table(tab), no_items(num),
status(0), lineno(0), commentChar('#')
{
}
-void Lexer::Pimpl::pushTable(keyword_item * tab, int num)
+void Lexer::Pimpl::pushTable(LexerKeyword * tab, int num)
{
PushedTable tmppu(table, no_items);
pushed.push(tmppu);
int Lexer::Pimpl::search_kw(char const * const tag) const
{
- keyword_item search_tag = { tag, 0 };
- keyword_item * res =
+ LexerKeyword search_tag = { tag, 0 };
+ LexerKeyword * res =
lower_bound(table, table + no_items,
search_tag, CompareTags());
// use the compare_ascii_no_case instead of compare_no_case,
//
//////////////////////////////////////////////////////////////////////
-Lexer::Lexer(keyword_item * tab, int num)
- : pimpl_(new Pimpl(tab, num))
+Lexer::Lexer()
+ : pimpl_(new Pimpl(0, 0))
{}
+void Lexer::init(LexerKeyword * tab, int num)
+{
+ pimpl_ = new Pimpl(tab, num);
+}
+
+
Lexer::~Lexer()
{
delete pimpl_;
}
-void Lexer::setLineNo(int l)
+void Lexer::setLineNumber(int l)
{
pimpl_->lineno = l;
}
-int Lexer::getLineNo() const
+int Lexer::lineNumber() const
{
return pimpl_->lineno;
}
}
-void Lexer::pushTable(keyword_item * tab, int num)
+void Lexer::pushTable(LexerKeyword * tab, int num)
{
pimpl_->pushTable(tab, num);
}
namespace support { class FileName; }
-///
-struct keyword_item {
- ///
+class PushPopHelper;
+
+/** A helper structure to describe a keyword for the Lexer.
+ Usually used bundled in C style arrays and passed to the
+ Lexer using a LexerKeywordTable object.
+*/
+struct LexerKeyword
+{
+ /// the string to be recognized
char const * tag;
- ///
+ /// a corresponding numerical id
int code;
};
+
/** Generalized simple lexical analizer.
Use the method isOK() to check if there is still data available
for lexing. Use one of the the operators void* or ! to test if
@see LyXRC.cpp for an example of usage.
*/
-class Lexer {
+class Lexer
+{
public:
- ///
- Lexer(keyword_item *, int);
+ /// initialize Lexer with no special keywords.
+ Lexer();
+ /// initialize Lexer with a bunch of keywords
+ template<int N> Lexer(LexerKeyword (&table)[N])
+ : pimpl_(0) { init(table, N); }
+
///
~Lexer();
};
/// stream is open and end of stream is not reached
- /// FIXME: test also if pushTok is not empty
+ /// FIXME: test also if pushToken is not empty
/// FIXME: the method should be renamed to something like
/// dataAvailable(), in order to reflect the real behavior
bool isOK() const;
///
std::istream & getStream();
/// Danger! Don't use it unless you know what you are doing.
- void setLineNo(int l);
+ void setLineNumber(int l);
/// Change the character that begins a comment. Default is '#'
void setCommentChar(char c);
/// Push a token, that next token got from lyxlex.
void pushToken(std::string const &);
- ///
- int getLineNo() const;
+ /// return the current line number
+ int lineNumber() const;
///
int getInteger() const;
bool eatLine();
/// Pushes a token list on a stack and replaces it with a new one.
- void pushTable(keyword_item *, int);
+ template<int N> void pushTable(LexerKeyword (&table)[N])
+ { pushTable(table, N); }
/** Pops a token list into void and replaces it with the one now
on top of the stack.
static std::string const quoteString(std::string const &);
private:
- /// noncopiable
+ /// noncopyable
Lexer(Lexer const &);
void operator=(Lexer const &);
+ ///
+ friend class PushPopHelper;
+
+ ///
+ void init(LexerKeyword *, int);
+ void pushTable(LexerKeyword *, int);
+
///
class Pimpl;
///
exceptions.
@author Lgb
*/
-class PushPopHelper {
+class PushPopHelper
+{
public:
///
- PushPopHelper(Lexer & lexrc, keyword_item * i, int s) : lex(lexrc) {
+ PushPopHelper(Lexer & lexrc, LexerKeyword * i, int s)
+ : lex(lexrc)
+ {
lex.pushTable(i, s);
}
///
- ~PushPopHelper() {
+ ~PushPopHelper()
+ {
lex.popTable();
}
///
// Read the ui file `name'
bool LyX::readUIFile(string const & name, bool include)
{
- enum Uitags {
+ enum {
ui_menuset = 1,
ui_toolbars,
ui_toolbarset,
ui_last
};
- struct keyword_item uitags[ui_last - 1] = {
+ struct LexerKeyword uitags[] = {
{ "include", ui_include },
{ "menuset", ui_menuset },
{ "toolbars", ui_toolbars },
uifiles.push_back(name);
LYXERR(Debug::INIT, "Found " << name << " in " << ui_path);
- Lexer lex(uitags, ui_last - 1);
+ Lexer lex(uitags);
lex.setFile(ui_path);
if (!lex.isOK()) {
lyxerr << "Unable to set LyXLeX for ui file: " << ui_path
Buffer defaults(fname);
istringstream ss(argument);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(ss);
int const unknown_tokens = defaults.readHeader(lex);
cur.recordUndoFullDocument();
istringstream ss(argument);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(ss);
int const unknown_tokens = buffer->readHeader(lex);
namespace {
// when adding something to this array keep it sorted!
-keyword_item lyxrcTags[] = {
+LexerKeyword lyxrcTags[] = {
{ "\\accept_compound", LyXRC::RC_ACCEPT_COMPOUND },
{ "\\allow_geometry_session", LyXRC::RC_GEOMETRY_SESSION },
{ "\\alternate_language", LyXRC::RC_ALT_LANG },
{ "\\visual_cursor" ,LyXRC::RC_VISUAL_CURSOR}
};
-const int lyxrcCount = sizeof(lyxrcTags) / sizeof(keyword_item);
+const int lyxrcCount = sizeof(lyxrcTags) / sizeof(lyxrcTags[0]);
} // namespace anon
int LyXRC::read(FileName const & filename)
{
- Lexer lexrc(lyxrcTags, lyxrcCount);
+ Lexer lexrc(lyxrcTags);
if (lyxerr.debugging(Debug::PARSER))
lexrc.printTable(lyxerr);
int LyXRC::read(istream & is)
{
- Lexer lexrc(lyxrcTags, lyxrcCount);
+ Lexer lexrc(lyxrcTags);
if (lyxerr.debugging(Debug::PARSER))
lexrc.printTable(lyxerr);
AM_CPPFLAGS += $(PCH_FLAGS) -I$(top_srcdir)/src $(BOOST_INCLUDES)
-SUBDIRS = support frontends tex2lyx client .
+SUBDIRS = support frontends tex2lyx client lyxled .
EXTRA_DIST = config.h.in \
Section.h \
return false;
}
- Lexer lex(0, 0);
+ Lexer lex;
if (!lex.setFile(real_file)) {
lyxerr << "ModuleList::load():"
"lyxlex was not able to set file: "
void ParagraphParameters::read(string str, bool merge)
{
istringstream is(str);
- Lexer lex(0, 0);
+ Lexer lex;
lex.setStream(is);
read(lex, merge);
}
par.params().read(lex);
} else if (token == "\\end_layout") {
- LYXERR0("Solitary \\end_layout in line " << lex.getLineNo() << "\n"
+ LYXERR0("Solitary \\end_layout in line " << lex.lineNumber() << "\n"
<< "Missing \\begin_layout ?");
} else if (token == "\\end_inset") {
- LYXERR0("Solitary \\end_inset in line " << lex.getLineNo() << "\n"
+ LYXERR0("Solitary \\end_inset in line " << lex.lineNumber() << "\n"
<< "Missing \\begin_inset ?");
} else if (token == "\\begin_inset") {
Inset * inset = readInset(lex, buf);
|| token == "\\end_deeper") {
lex.pushToken(token);
lyxerr << "Paragraph ended in line "
- << lex.getLineNo() << "\n"
+ << lex.lineNumber() << "\n"
<< "Missing \\end_layout.\n";
break;
}
{
InsetMathHull * formula = new InsetMathHull;
istringstream is(to_utf8(sel));
- Lexer lex(0, 0);
+ Lexer lex;
lex.setStream(is);
formula->read(lex);
if (formula->getType() == hullNone)
namespace {
- keyword_item textClassTags[] = {
+ LexerKeyword textClassTags[] = {
{ "addtopreamble", TC_ADDTOPREAMBLE },
{ "classoptions", TC_CLASSOPTIONS },
{ "columns", TC_COLUMNS },
"LabelType No_Label\n"
"End";
istringstream ss(s);
- Lexer lex(textClassTags, sizeof(textClassTags) / sizeof(textClassTags[0]));
+ Lexer lex(textClassTags);
lex.setStream(ss);
Layout lay;
lay.setName(emptylayout_);
};
layoutlist_.push_back(lay);
}
- Lexer lexrc(textClassTags,
- sizeof(textClassTags) / sizeof(textClassTags[0]));
+ Lexer lexrc(textClassTags);
lexrc.setFile(filename);
ReturnValues retval = read(lexrc, rt);
bool TextClass::read(std::string const & str, ReadType rt)
{
- Lexer lexrc(textClassTags,
- sizeof(textClassTags) / sizeof(textClassTags[0]));
+ Lexer lexrc(textClassTags);
istringstream is(str);
lexrc.setStream(is);
ReturnValues retval = read(lexrc, rt);
void TextClass::readTitleType(Lexer & lexrc)
{
- keyword_item titleTypeTags[] = {
+ LexerKeyword titleTypeTags[] = {
{ "commandafter", TITLE_COMMAND_AFTER },
{ "environment", TITLE_ENVIRONMENT }
};
void TextClass::readOutputType(Lexer & lexrc)
{
- keyword_item outputTypeTags[] = {
+ LexerKeyword outputTypeTags[] = {
{ "docbook", DOCBOOK },
{ "latex", LATEX },
{ "literate", LITERATE }
void TextClass::readClassOptions(Lexer & lexrc)
{
- keyword_item classOptionsTags[] = {
+ LexerKeyword classOptionsTags[] = {
{"end", CO_END },
{"fontsize", CO_FONTSIZE },
{"header", CO_HEADER },
{"pagestyle", CO_PAGESTYLE }
};
- lexrc.pushTable(classOptionsTags, CO_END);
+ lexrc.pushTable(classOptionsTags);
bool getout = false;
while (!getout && lexrc.isOK()) {
int le = lexrc.lex();
void TextClass::readFloat(Lexer & lexrc)
{
- keyword_item floatTags[] = {
+ LexerKeyword floatTags[] = {
{ "end", FT_END },
{ "extension", FT_EXT },
{ "guiname", FT_NAME },
{ "type", FT_TYPE }
};
- lexrc.pushTable(floatTags, FT_END);
+ lexrc.pushTable(floatTags);
string type;
string placement;
void TextClass::readCounter(Lexer & lexrc)
{
- keyword_item counterTags[] = {
+ LexerKeyword counterTags[] = {
{ "end", CT_END },
{ "labelstring", CT_LABELSTRING },
{ "labelstringappendix", CT_LABELSTRING_APPENDIX },
{ "within", CT_WITHIN }
};
- lexrc.pushTable(counterTags, CT_END);
+ lexrc.pushTable(counterTags);
docstring name;
docstring within;
ToolbarBackend toolbarbackend;
+/////////////////////////////////////////////////////////////////////////
+//
+// ToolbarItem
+//
+/////////////////////////////////////////////////////////////////////////
+
ToolbarItem::ToolbarItem(Type type, FuncRequest const & func, docstring const & label)
: type_(type), func_(func), label_(label)
{
ToolbarInfo & ToolbarInfo::read(Lexer & lex)
{
- enum tooltags {
+ enum {
TO_COMMAND = 1,
TO_ENDTOOLBAR,
TO_SEPARATOR,
TO_TABLEINSERT,
TO_POPUPMENU,
TO_ICONPALETTE,
- TO_LAST
};
- struct keyword_item toolTags[TO_LAST - 1] = {
+ struct LexerKeyword toolTags[] = {
{ "end", TO_ENDTOOLBAR },
{ "iconpalette", TO_ICONPALETTE },
{ "item", TO_COMMAND },
bool quit = false;
- lex.pushTable(toolTags, TO_LAST - 1);
+ lex.pushTable(toolTags);
if (lyxerr.debugging(Debug::PARSER))
lex.printTable(lyxerr);
+/////////////////////////////////////////////////////////////////////////
+//
+// ToolbarBackend
+//
+/////////////////////////////////////////////////////////////////////////
+
ToolbarBackend::ToolbarBackend()
{
void ToolbarBackend::readToolbars(Lexer & lex)
{
- enum tooltags {
+ enum {
TO_TOOLBAR = 1,
TO_ENDTOOLBARSET,
- TO_LAST
};
- struct keyword_item toolTags[TO_LAST - 1] = {
+ struct LexerKeyword toolTags[] = {
{ "end", TO_ENDTOOLBARSET },
{ "toolbar", TO_TOOLBAR }
};
<< lex.getString() << '\'');
}
- lex.pushTable(toolTags, TO_LAST - 1);
+ lex.pushTable(toolTags);
if (lyxerr.debugging(Debug::PARSER))
lex.printTable(lyxerr);
}
-enum kmaptags_ {
+enum {
KCOMB = 1,
KMOD,
KMAP,
KXMOD,
- K_LAST
-};
-
-
-struct keyword_item kmapTags[K_LAST - 1] = {
- {"\\kcomb", KCOMB },
- { "\\kmap", KMAP },
- { "\\kmod", KMOD },
- { "\\kxmod", KXMOD }
};
int Trans::load(string const & language)
{
+ struct LexerKeyword kmapTags[] = {
+ {"\\kcomb", KCOMB },
+ { "\\kmap", KMAP },
+ { "\\kmod", KMOD },
+ { "\\kxmod", KXMOD }
+ };
+
FileName const filename = libFileSearch("kbd", language, "kmap");
if (filename.empty())
return -1;
freeKeymap();
- Lexer lex(kmapTags, K_LAST - 1);
+ Lexer lex(kmapTags);
lex.setFile(filename);
int const res = load(lex);
bool GuiLog::initialiseParams(string const & data)
{
istringstream is(data);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(is);
string logtype, logfile;
md_floatlistinsert,
md_floatinsert,
md_pasterecent,
- md_toolbars,
- md_last
+ md_toolbars
};
- struct keyword_item menutags[md_last - 1] = {
+ struct LexerKeyword menutags[] = {
{ "bookmarks", md_bookmarks },
{ "branches", md_branches },
{ "charstyles", md_charstyles },
{ "viewformats", md_viewformats }
};
- lex.pushTable(menutags, md_last - 1);
+ lex.pushTable(menutags);
if (lyxerr.debugging(Debug::PARSER))
lex.printTable(lyxerr);
}
-void Menus::Impl::expand(MenuDefinition const & frommenu, MenuDefinition & tomenu,
- Buffer const * buf) const
+void Menus::Impl::expand(MenuDefinition const & frommenu,
+ MenuDefinition & tomenu, Buffer const * buf) const
{
if (!tomenu.empty())
tomenu.clear();
return (*it);
}
+
/////////////////////////////////////////////////////////////////////
-// Menus implementation
+//
+// Menus
+//
/////////////////////////////////////////////////////////////////////
-Menus::Menus(): d(new Impl) {}
+Menus::Menus() : d(new Impl) {}
void Menus::read(Lexer & lex)
{
enum Menutags {
- md_menu = 1,
+ md_menu,
md_menubar,
md_endmenuset,
- md_last
};
- struct keyword_item menutags[md_last - 1] = {
+ struct LexerKeyword menutags[] = {
{ "end", md_endmenuset },
{ "menu", md_menu },
{ "menubar", md_menubar }
<< lex.getString() << '\'' << endl;
}
- lex.pushTable(menutags, md_last - 1);
+ lex.pushTable(menutags);
if (lyxerr.debugging(Debug::PARSER))
lex.printTable(lyxerr);
{
PathChanger p(path);
- enum TemplateTags {
+ enum {
TM_PREAMBLEDEF = 1,
TM_PREAMBLEDEF_END,
TM_TEMPLATE,
TM_TEMPLATE_END
};
- keyword_item templatetags[] = {
+ LexerKeyword templatetags[] = {
{ "preambledef", TM_PREAMBLEDEF },
{ "preambledefend", TM_PREAMBLEDEF_END },
{ "template", TM_TEMPLATE },
{ "templateend", TM_TEMPLATE_END }
};
- Lexer lex(templatetags, TM_TEMPLATE_END);
+ Lexer lex(templatetags);
FileName const filename = libFileSearch("", "external_templates");
if (filename.empty() || !lex.setFile(filename)) {
void Template::readTemplate(Lexer & lex)
{
- enum TemplateOptionTags {
+ enum {
TO_GUINAME = 1,
TO_HELPTEXT,
TO_INPUTFORMAT,
TO_END
};
- keyword_item templateoptiontags[] = {
+ LexerKeyword templateoptiontags[] = {
{ "automaticproduction", TO_AUTOMATIC },
{ "filefilter", TO_FILTER },
{ "format", TO_FORMAT },
FO_END
};
- keyword_item formattags[] = {
+ LexerKeyword formattags[] = {
{ "formatend", FO_END },
{ "option", FO_OPTION },
{ "preamble", FO_PREAMBLE },
return;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
return;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
return false;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string n;
return status;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
EX_END
};
- keyword_item external_tags[] = {
+ LexerKeyword external_tags[] = {
{ "\\end_inset", EX_END },
{ "boundingBox", EX_BOUNDINGBOX },
{ "clip", EX_CLIP },
return;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
return;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
return;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
enum InsetLayoutTags {
- IL_FONT = 1,
+ IL_FONT,
IL_BGCOLOR,
IL_DECORATION,
IL_FREESPACING,
{
name_ = support::subst(lexrc.getDocString(), '_', ' ');
- keyword_item elementTags[] = {
+ LexerKeyword elementTags[] = {
{ "bgcolor", IL_BGCOLOR },
{ "decoration", IL_DECORATION },
{ "end", IL_END },
{ "requires", IL_REQUIRES }
};
- lexrc.pushTable(elementTags, IL_END);
+ lexrc.pushTable(elementTags);
FontInfo font = inherit_font;
labelfont_ = inherit_font;
if (in.empty())
return;
istringstream data(in);
- Lexer lex(0, 0);
+ Lexer lex;
lex.setStream(data);
// discard "listings", which is only used to determine inset
lex.next();
return;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
return;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
return;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
return;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
void InsetTabular::string2params(string const & in, InsetTabular & inset)
{
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
if (in.empty())
return;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
return;
istringstream data(in);
- Lexer lex(0,0);
+ Lexer lex;
lex.setStream(data);
string name;
--- /dev/null
+
+#include "LayoutEditor.h"
+
+#include "ui_MainWindowUi.h"
+
+#include <QDebug>
+#include <QFile>
+#include <QList>
+#include <QStandardItem>
+#include <QStandardItemModel>
+#include <QString>
+#include <QTreeView>
+
+
+namespace lyx {
+
+/////////////////////////////////////////////////////////////////////////
+//
+// LayoutTree
+//
+/////////////////////////////////////////////////////////////////////////
+
+LayoutTree::LayoutTree(QWidget * parent)
+ : QTreeView(parent)
+{}
+
+
+/////////////////////////////////////////////////////////////////////////
+//
+// LayoutEditor
+//
+/////////////////////////////////////////////////////////////////////////
+
+LayoutEditor::LayoutEditor(QWidget * parent)
+ : QWidget(parent)
+{}
+
+
+/////////////////////////////////////////////////////////////////////////
+//
+// MainWindow
+//
+/////////////////////////////////////////////////////////////////////////
+
+MainWindow::MainWindow()
+{
+ ui_ = new Ui::MainWindow;
+ ui_->setupUi(this);
+
+ model_ = new QStandardItemModel(this);
+ view_ = new LayoutTree(this);
+ view_->setModel(model_);
+ //setCentralWidget(view_);
+
+ ui_->dockLayoutTree->setWidget(view_);
+}
+
+
+MainWindow::~MainWindow()
+{
+ delete ui_;
+}
+
+static bool isInsensitivelyEqual(QString const & s1, QString const & s2)
+{
+ return s1.compare(s2, Qt::CaseInsensitive) == 0;
+}
+
+void MainWindow::loadLayoutFile(QString const & fileName)
+{
+ loadLayoutFile(fileName, model_->invisibleRootItem());
+ view_->expandAll();
+}
+
+
+void MainWindow::loadLayoutFile(QString const & fileName,
+ QStandardItem * parent)
+{
+ QFile file(fileName);
+#if 0
+ file.open(QIODevice::ReadOnly);
+ QString contents = file.readAll();
+ file.close();
+ qDebug() << "contents: " << contents;
+#endif
+
+ file.open(QIODevice::ReadOnly);
+
+ QTextStream ts(&file);
+ while (!ts.atEnd()) {
+ QList<QStandardItem *> row;
+ QString code;
+ ts >> code;
+ //qDebug() << "CODE: " << code;
+ if (code.startsWith('#')) {
+ QString line = code + ' ' + ts.readLine();
+ //row.append(new QStandardItem("Comment"));
+ //row.append(new QStandardItem(code + ' ' + ts.readLine()));
+ //parent->appendRow(row);
+ } else if (isInsensitivelyEqual(code, "Input")) {
+ QString inputFile;
+ ts >> inputFile;
+ QStandardItem * item = new QStandardItem(inputFile);
+ row.append(item);
+ parent->appendRow(row);
+ inputFile = fileName.left(fileName.lastIndexOf('/')) + '/' + inputFile;
+ qDebug() << "INPUT: " << inputFile;
+ loadLayoutFile(inputFile, item);
+ } else if (isInsensitivelyEqual(code, "Style")) {
+ QString style;
+ ts >> style;
+ //while (!ts.atEnd() && !isInsensitivelyEqual(code, "EndStyle"))
+ // ts >> code;
+ QStandardItem * item = new QStandardItem(style);
+ row.append(item);
+ parent->appendRow(row);
+ } else {
+ //row.append(new QStandardItem(code));
+ //parent->appendRow(row);
+ }
+ }
+
+ file.close();
+}
+
+} // namespace lyx
--- /dev/null
+#ifndef LAYOUTEDITOR_H
+#define LAYOUTEDITOR_H
+
+#include <QMainWindow>
+#include <QObject>
+#include <QTreeView>
+#include <QWidget>
+
+class QStandardItem;
+class QStandardItemModel;
+
+namespace Ui { class MainWindow; }
+
+namespace lyx {
+
+class LayoutTree;
+class LayoutEditor;
+
+/////////////////////////////////////////////////////////////////////////
+//
+// LayoutTree
+//
+/////////////////////////////////////////////////////////////////////////
+
+class LayoutTree : public QTreeView
+{
+ Q_OBJECT
+
+public:
+ LayoutTree(QWidget * parent);
+};
+
+
+/////////////////////////////////////////////////////////////////////////
+//
+// LayoutTree
+//
+/////////////////////////////////////////////////////////////////////////
+
+class LayoutEditor : public QWidget
+{
+ Q_OBJECT
+
+public:
+ LayoutEditor(QWidget * parent);
+};
+
+
+/////////////////////////////////////////////////////////////////////////
+//
+// MainWindow
+//
+/////////////////////////////////////////////////////////////////////////
+
+class MainWindow : public QMainWindow
+{
+ Q_OBJECT
+
+public:
+ MainWindow();
+ ~MainWindow();
+
+ void loadLayoutFile(QString const & file);
+
+public:
+ void loadLayoutFile(QString const & file, QStandardItem * parent);
+
+ Ui::MainWindow * ui_;
+ LayoutTree * view_;
+ QStandardItemModel * model_;
+};
+
+} // namespace lyx
+
+#endif // LAYOUTEDITOR_H
--- /dev/null
+include $(top_srcdir)/config/common.am
+
+BUILT_SOURCES = $(MOCEDFILES)
+#BUILT_SOURCES = $(UIFILES:%.ui=ui_%.h)
+#BUILT_SOURCES += Resources.cpp Resources.qrc
+
+CLEANFILES += $(BUILT_SOURCES)
+
+######################### Qt stuff #############################
+# Use _() for localization instead of tr() or trUtf8()
+UIC4FLAGS=-tr lyx::qt_
+
+ui_%.h: ui/%.ui
+ $(UIC4) $(UIC4FLAGS) $< -o $@
+
+MOCEDFILES = $(MOCHEADER:%.h=%_moc.cpp)
+
+%_moc.cpp: %.h
+ $(MOC4) -o $@ $<
+
+#Resources.qrc: Makefile
+# echo "<!DOCTYPE RCC><RCC version='1.0'><qresource>" > $@
+# find $(top_srcdir)/lib/images -name '*.png' \
+# | sed -e 's:$(top_srcdir)/lib/\(.*\):<file alias="\1">&</file>:' \
+# >> $@
+# echo "</qresource></RCC>" >> $@
+#
+#Resources.cpp: Resources.qrc
+# $(RCC4) $< -name Resources -o $@
+
+
+######################### LIBRARIES #############################
+
+bin_PROGRAMS = lyxled
+
+lyxled_LDADD = $(QT4_LIB)
+lyxled_DEPENDENCIES = $(MOCEDFILES)
+
+AM_CPPFLAGS += \
+ $(QT4_CPPFLAGS) \
+ -UQT_NO_KEYWORDS \
+ -I$(top_srcdir)/src \
+ $(QT4_INCLUDES)
+
+SOURCEFILES = \
+ main.cpp \
+ LayoutEditor.cpp \
+ LayoutEditor_moc.cpp
+
+NOMOCHEADER =
+
+MOCHEADER = \
+ LayoutEditor.h
+
+UIFILES =
+
+lyxled_SOURCES = \
+ $(SOURCEFILES) \
+ $(MOCEDFILES) \
+ $(MOCHEADER) \
+ $(NOMOCHEADER)
+
+EXTRA_DIST = ui/compile_uic.sh $(UIFILES:%=ui/%)
+#EXTRA_DIST = pch.h ui/compile_uic.sh $(UIFILES:%=ui/%)
+#BUILT_SOURCES += $(PCH_FILE)
+#AM_CPPFLAGS += $(PCH_FLAGS)
--- /dev/null
+######################################################################
+# Automatically generated by qmake (2.01a) Tue Apr 1 00:17:55 2008
+######################################################################
+
+TEMPLATE = app
+TARGET = lyxled
+DEPENDPATH += .
+INCLUDEPATH += .
+
+HEADERS += LayoutEditor.h
+
+SOURCES += \
+ LayoutEditor.cpp \
+ main.cpp
+
+FORMS += ui/MainWindowUi.ui
--- /dev/null
+
+#include "LayoutEditor.h"
+
+#include <QApplication>
+
+int main(int argc, char *argv[])
+{
+ QApplication app(argc, argv);
+ lyx::MainWindow led;
+ QStringList args = app.arguments();
+ args.append("/data/lyx/trunk/lib/layouts/amsart.layout");
+ for (int i = 1; i != args.size(); ++i) {
+ led.loadLayoutFile(args[i]);
+ }
+ led.show();
+ return app.exec();
+}
+
--- /dev/null
+<ui version="4.0" >
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow" >
+ <property name="geometry" >
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>800</width>
+ <height>600</height>
+ </rect>
+ </property>
+ <property name="windowTitle" >
+ <string>MainWindow</string>
+ </property>
+ <widget class="QWidget" name="centralwidget" />
+ <widget class="QMenuBar" name="menubar" >
+ <property name="geometry" >
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>800</width>
+ <height>31</height>
+ </rect>
+ </property>
+ <widget class="QMenu" name="menuFile" >
+ <property name="title" >
+ <string>File</string>
+ </property>
+ <addaction name="actionNew_Layout" />
+ <addaction name="actionOpen_Layout" />
+ <addaction name="actionRecent_Layouts" />
+ <addaction name="separator" />
+ <addaction name="actionSave_Layout" />
+ <addaction name="actionSave_As" />
+ <addaction name="separator" />
+ <addaction name="actionQuit" />
+ </widget>
+ <addaction name="menuFile" />
+ </widget>
+ <widget class="QStatusBar" name="statusbar" />
+ <widget class="QDockWidget" name="dockLayoutTree" >
+ <attribute name="dockWidgetArea" >
+ <number>1</number>
+ </attribute>
+ <widget class="QWidget" name="dockWidgetContents" />
+ </widget>
+ <action name="actionNew_Layout" >
+ <property name="text" >
+ <string>New Layout</string>
+ </property>
+ </action>
+ <action name="actionOpen_Layout" >
+ <property name="text" >
+ <string>Open Layout</string>
+ </property>
+ </action>
+ <action name="actionRecent_Layouts" >
+ <property name="text" >
+ <string>Recent Layouts</string>
+ </property>
+ </action>
+ <action name="actionSave_Layout" >
+ <property name="text" >
+ <string>Save Layout</string>
+ </property>
+ </action>
+ <action name="actionSave_As" >
+ <property name="text" >
+ <string>Save As</string>
+ </property>
+ </action>
+ <action name="actionQuit" >
+ <property name="text" >
+ <string>Quit</string>
+ </property>
+ </action>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
Parser::Parser(Lexer & lexer)
- : lineno_(lexer.getLineNo()), pos_(0)
+ : lineno_(lexer.lineNumber()), pos_(0)
{
tokenize(lexer.getStream());
lexer.eatLine();
projects / features.git / commitdiff