void InsetCommandParams::read(Lexer & lex)
{
lex.setContext("InsetCommandParams::read");
lex >> insetName(insetCode_).c_str();
lex >> "LatexCommand";
lex >> cmdName_;
if (!isCompatibleCommand(insetCode_, cmdName_)) {
lex.printError("Incompatible command name " + cmdName_ + ".");
throw ExceptionMessage(WarningException, _("InsetCommandParams Error: "),
_("Incompatible command name."));
}
info_ = findInfo(insetCode_, cmdName_);
string token;
while (lex.isOK()) {
lex.next();
token = lex.getString();
if (token == "\\end_inset")
break;
if (token == "preview") {
lex.next();
preview_ = lex.getBool();
continue;
}
if (info_.hasParam(token)) {
lex.next(true);
params_[token] = lex.getDocString();
} else {
lex.printError("Unknown parameter name `$$Token' for command " + cmdName_);
throw ExceptionMessage(WarningException,
_("InsetCommandParams: ") + from_ascii(cmdName_),
_("Unknown parameter name: ") + from_utf8(token));
}
}
if (token != "\\end_inset") {
lex.printError("Missing \\end_inset at this point. "
"Read: `$$Token'");
throw ExceptionMessage(WarningException,
_("InsetCommandParams Error: "),
_("Missing \\end_inset at this point: ") + from_utf8(token));
}
}
void ParagraphParameters::read(Lexer & lex, bool merge)
{
if (!merge)
clear();
while (lex.isOK()) {
lex.nextToken();
string const token = lex.getString();
if (token.empty())
continue;
if (token[0] != '\\') {
lex.pushToken(token);
break;
}
if (token == "\\noindent") {
noindent(true);
} else if (token == "\\indent") {
//not found in LyX files but can be used with lfuns
noindent(false);
} else if (token == "\\indent-toggle") {
//not found in LyX files but can be used with lfuns
noindent(!noindent());
} else if (token == "\\leftindent") {
lex.next();
Length value(lex.getString());
leftIndent(value);
} else if (token == "\\start_of_appendix") {
startOfAppendix(true);
} else if (token == "\\paragraph_spacing") {
lex.next();
string const tmp = rtrim(lex.getString());
if (tmp == "default") {
//not found in LyX files but can be used with lfuns
spacing(Spacing(Spacing::Default));
} else if (tmp == "single") {
spacing(Spacing(Spacing::Single));
} else if (tmp == "onehalf") {
spacing(Spacing(Spacing::Onehalf));
} else if (tmp == "double") {
spacing(Spacing(Spacing::Double));
} else if (tmp == "other") {
lex.next();
spacing(Spacing(Spacing::Other,
lex.getString()));
} else {
lex.printError("Unknown spacing token: '$$Token'");
}
} else if (token == "\\align") {
lex.next();
int tmpret = findToken(string_align, lex.getString());
if (tmpret == -1)
++tmpret;
align(LyXAlignment(1 << tmpret));
} else if (token == "\\labelwidthstring") {
lex.eatLine();
labelWidthString(lex.getDocString());
} else {
lex.pushToken(token);
break;
}
}
}
void InsetLayout::readArgument(Lexer & lex)
{
Layout::latexarg arg;
arg.mandatory = false;
bool error = false;
bool finished = false;
arg.font = inherit_font;
arg.labelfont = inherit_font;
string nr;
lex >> nr;
while (!finished && lex.isOK() && !error) {
lex.next();
string const tok = support::ascii_lowercase(lex.getString());
if (tok.empty()) {
continue;
} else if (tok == "endargument") {
finished = true;
} else if (tok == "labelstring") {
lex.next();
arg.labelstring = lex.getDocString();
} else if (tok == "menustring") {
lex.next();
arg.menustring = lex.getDocString();
} else if (tok == "mandatory") {
lex.next();
arg.mandatory = lex.getBool();
} else if (tok == "leftdelim") {
lex.next();
arg.ldelim = lex.getDocString();
arg.ldelim = support::subst(arg.ldelim,
from_ascii("<br/>"), from_ascii("\n"));
} else if (tok == "rightdelim") {
lex.next();
arg.rdelim = lex.getDocString();
arg.rdelim = support::subst(arg.rdelim,
from_ascii("<br/>"), from_ascii("\n"));
} else if (tok == "presetarg") {
lex.next();
arg.presetarg = lex.getDocString();
} else if (tok == "tooltip") {
lex.next();
arg.tooltip = lex.getDocString();
} else if (tok == "requires") {
lex.next();
arg.requires = lex.getString();
} else if (tok == "decoration") {
lex.next();
arg.decoration = lex.getString();
} else if (tok == "font") {
arg.font = lyxRead(lex, arg.font);
} else if (tok == "labelfont") {
arg.labelfont = lyxRead(lex, arg.labelfont);
} else {
lex.printError("Unknown tag");
error = true;
}
}
if (arg.labelstring.empty())
LYXERR0("Incomplete Argument definition!");
else
latexargs_[nr] = arg;
}
void Layout::readArgument(Lexer & lex)
{
latexarg arg;
// writeArgument() makes use of these default values
arg.mandatory = false;
arg.autoinsert = false;
bool error = false;
bool finished = false;
arg.font = inherit_font;
arg.labelfont = inherit_font;
string id;
lex >> id;
bool const itemarg = prefixIs(id, "item:");
bool const postcmd = prefixIs(id, "post:");
while (!finished && lex.isOK() && !error) {
lex.next();
string const tok = ascii_lowercase(lex.getString());
if (tok.empty()) {
continue;
} else if (tok == "endargument") {
finished = true;
} else if (tok == "labelstring") {
lex.next();
arg.labelstring = lex.getDocString();
} else if (tok == "menustring") {
lex.next();
arg.menustring = lex.getDocString();
} else if (tok == "mandatory") {
lex.next();
arg.mandatory = lex.getBool();
} else if (tok == "autoinsert") {
lex.next();
arg.autoinsert = lex.getBool();
} else if (tok == "leftdelim") {
lex.next();
arg.ldelim = lex.getDocString();
arg.ldelim = support::subst(arg.ldelim, from_ascii("<br/>"),
from_ascii("\n"));
} else if (tok == "rightdelim") {
lex.next();
arg.rdelim = lex.getDocString();
arg.rdelim = support::subst(arg.rdelim, from_ascii("<br/>"),
from_ascii("\n"));
} else if (tok == "defaultarg") {
lex.next();
arg.defaultarg = lex.getDocString();
} else if (tok == "presetarg") {
lex.next();
arg.presetarg = lex.getDocString();
} else if (tok == "tooltip") {
lex.next();
arg.tooltip = lex.getDocString();
} else if (tok == "requires") {
lex.next();
arg.requires = lex.getString();
} else if (tok == "decoration") {
lex.next();
arg.decoration = lex.getString();
} else if (tok == "font") {
arg.font = lyxRead(lex, arg.font);
} else if (tok == "labelfont") {
arg.labelfont = lyxRead(lex, arg.labelfont);
} else {
lex.printError("Unknown tag");
error = true;
}
}
if (arg.labelstring.empty())
LYXERR0("Incomplete Argument definition!");
else if (itemarg)
itemargs_[id] = arg;
else if (postcmd)
postcommandargs_[id] = arg;
else
latexargs_[id] = arg;
}
bool Counter::read(Lexer & lex)
{
enum {
CT_WITHIN = 1,
CT_LABELSTRING,
CT_LABELSTRING_APPENDIX,
CT_PRETTYFORMAT,
CT_END
};
LexerKeyword counterTags[] = {
{ "end", CT_END },
{ "labelstring", CT_LABELSTRING },
{ "labelstringappendix", CT_LABELSTRING_APPENDIX },
{ "prettyformat", CT_PRETTYFORMAT },
{ "within", CT_WITHIN }
};
lex.pushTable(counterTags);
bool getout = false;
while (!getout && lex.isOK()) {
int le = lex.lex();
switch (le) {
case Lexer::LEX_UNDEF:
lex.printError("Unknown counter tag `$$Token'");
continue;
default:
break;
}
switch (le) {
case CT_WITHIN:
lex.next();
master_ = lex.getDocString();
if (master_ == "none")
master_.erase();
break;
case CT_PRETTYFORMAT:
lex.next();
prettyformat_ = lex.getDocString();
break;
case CT_LABELSTRING:
lex.next();
labelstring_ = lex.getDocString();
labelstringappendix_ = labelstring_;
break;
case CT_LABELSTRING_APPENDIX:
lex.next();
labelstringappendix_ = lex.getDocString();
break;
case CT_END:
getout = true;
break;
}
}
// Here if have a full counter if getout == true
if (!getout)
LYXERR0("No End tag found for counter!");
lex.popTable();
return getout;
}
void Layout::readArgument(Lexer & lex)
{
latexarg arg;
// writeArgument() makes use of these default values
arg.mandatory = false;
arg.nodelims = false;
arg.autoinsert = false;
arg.insertcotext = false;
bool error = false;
bool finished = false;
arg.font = inherit_font;
arg.labelfont = inherit_font;
arg.is_toc_caption = false;
arg.passthru = PT_INHERITED;
string id;
lex >> id;
bool const itemarg = prefixIs(id, "item:");
bool const postcmd = prefixIs(id, "post:");
bool const listpreamble = prefixIs(id, "listpreamble:");
while (!finished && lex.isOK() && !error) {
lex.next();
string const tok = ascii_lowercase(lex.getString());
if (tok.empty()) {
continue;
} else if (tok == "endargument") {
finished = true;
} else if (tok == "labelstring") {
lex.next();
arg.labelstring = lex.getDocString();
} else if (tok == "menustring") {
lex.next();
arg.menustring = lex.getDocString();
} else if (tok == "mandatory") {
lex.next();
arg.mandatory = lex.getBool();
} else if (tok == "autoinsert") {
lex.next();
arg.autoinsert = lex.getBool();
} else if (tok == "insertcotext") {
lex.next();
arg.insertcotext = lex.getBool();
} else if (tok == "leftdelim") {
lex.next();
arg.ldelim = lex.getDocString();
arg.ldelim = support::subst(arg.ldelim, from_ascii("<br/>"),
from_ascii("\n"));
} else if (tok == "rightdelim") {
lex.next();
arg.rdelim = lex.getDocString();
arg.rdelim = support::subst(arg.rdelim, from_ascii("<br/>"),
from_ascii("\n"));
} else if (tok == "defaultarg") {
lex.next();
arg.defaultarg = lex.getDocString();
} else if (tok == "presetarg") {
lex.next();
arg.presetarg = lex.getDocString();
} else if (tok == "tooltip") {
lex.next();
arg.tooltip = lex.getDocString();
} else if (tok == "requires") {
lex.next();
arg.requires = lex.getString();
} else if (tok == "decoration") {
lex.next();
arg.decoration = lex.getString();
} else if (tok == "newlinecmd") {
lex.next();
arg.newlinecmd = lex.getString();
} else if (tok == "font") {
arg.font = lyxRead(lex, arg.font);
} else if (tok == "labelfont") {
arg.labelfont = lyxRead(lex, arg.labelfont);
} else if (tok == "passthruchars") {
lex.next();
arg.pass_thru_chars = lex.getDocString();
} else if (tok == "passthru") {
lex.next();
docstring value = lex.getDocString();
if (value == "true" || value == "1")
arg.passthru = PT_TRUE;
else if (value == "false" || value == "0")
arg.passthru = PT_FALSE;
else
arg.passthru = PT_INHERITED;
} else if (tok == "istoccaption") {
lex.next();
arg.is_toc_caption = lex.getBool();
} else {
lex.printError("Unknown tag");
error = true;
}
}
if (arg.labelstring.empty())
LYXERR0("Incomplete Argument definition!");
else if (itemarg)
itemargs_[id] = arg;
else if (postcmd)
postcommandargs_[id] = arg;
else if (listpreamble) {
// list preamble has no delimiters by default
arg.nodelims = true;
listpreamble_[id] = arg;
} else
latexargs_[id] = arg;
}
// Reads a textclass structure from file.
TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt)
{
if (!lexrc.isOK())
return ERROR;
// Format of files before the 'Format' tag was introduced
int format = 1;
bool error = false;
// parsing
while (lexrc.isOK() && !error) {
int le = lexrc.lex();
switch (le) {
case Lexer::LEX_FEOF:
continue;
case Lexer::LEX_UNDEF:
lexrc.printError("Unknown TextClass tag `$$Token'");
error = true;
continue;
default:
break;
}
// used below to track whether we are in an IfStyle or IfCounter tag.
bool ifstyle = false;
bool ifcounter = false;
switch (static_cast<TextClassTags>(le)) {
case TC_FORMAT:
if (lexrc.next())
format = lexrc.getInteger();
break;
case TC_OUTPUTFORMAT:
if (lexrc.next())
outputFormat_ = lexrc.getString();
break;
case TC_OUTPUTTYPE:
readOutputType(lexrc);
switch(outputType_) {
case LATEX:
outputFormat_ = "latex";
break;
case DOCBOOK:
outputFormat_ = "docbook";
break;
case LITERATE:
outputFormat_ = "literate";
break;
}
break;
case TC_INPUT: // Include file
if (lexrc.next()) {
string const inc = lexrc.getString();
FileName tmp = libFileSearch("layouts", inc,
"layout");
if (tmp.empty()) {
lexrc.printError("Could not find input file: " + inc);
error = true;
} else if (!read(tmp, MERGE)) {
lexrc.printError("Error reading input file: " + tmp.absFileName());
error = true;
}
}
break;
case TC_DEFAULTSTYLE:
if (lexrc.next()) {
docstring const name = from_utf8(subst(lexrc.getString(),
'_', ' '));
defaultlayout_ = name;
}
break;
case TC_IFSTYLE:
ifstyle = true;
// fall through
case TC_STYLE: {
if (!lexrc.next()) {
lexrc.printError("No name given for style: `$$Token'.");
error = true;
break;
}
docstring const name = from_utf8(subst(lexrc.getString(),
'_', ' '));
if (name.empty()) {
string s = "Could not read name for style: `$$Token' "
+ lexrc.getString() + " is probably not valid UTF-8!";
lexrc.printError(s);
Layout lay;
// Since we couldn't read the name, we just scan the rest
// of the style and discard it.
error = !readStyle(lexrc, lay);
} else if (hasLayout(name)) {
Layout & lay = operator[](name);
error = !readStyle(lexrc, lay);
} else if (!ifstyle) {
Layout layout;
layout.setName(name);
error = !readStyle(lexrc, layout);
if (!error)
layoutlist_.push_back(layout);
if (defaultlayout_.empty()) {
// We do not have a default layout yet, so we choose
// the first layout we encounter.
defaultlayout_ = name;
}
}
else {
// this was an ifstyle where we didn't have the style
// scan the rest and discard it
Layout lay;
readStyle(lexrc, lay);
}
// reset flag
ifstyle = false;
break;
}
case TC_NOSTYLE:
if (lexrc.next()) {
docstring const style = from_utf8(subst(lexrc.getString(),
'_', ' '));
if (!deleteLayout(style))
lyxerr << "Cannot delete style `"
<< to_utf8(style) << '\'' << endl;
}
break;
case TC_COLUMNS:
if (lexrc.next())
columns_ = lexrc.getInteger();
break;
case TC_SIDES:
if (lexrc.next()) {
switch (lexrc.getInteger()) {
case 1: sides_ = OneSide; break;
case 2: sides_ = TwoSides; break;
default:
lyxerr << "Impossible number of page"
" sides, setting to one."
<< endl;
sides_ = OneSide;
break;
}
}
break;
case TC_PAGESTYLE:
lexrc.next();
pagestyle_ = rtrim(lexrc.getString());
break;
case TC_DEFAULTFONT:
defaultfont_ = lyxRead(lexrc);
if (!defaultfont_.resolved()) {
lexrc.printError("Warning: defaultfont should "
"be fully instantiated!");
defaultfont_.realize(sane_font);
}
break;
case TC_SECNUMDEPTH:
lexrc.next();
secnumdepth_ = lexrc.getInteger();
break;
case TC_TOCDEPTH:
lexrc.next();
tocdepth_ = lexrc.getInteger();
break;
// First step to support options
case TC_CLASSOPTIONS:
readClassOptions(lexrc);
break;
case TC_PREAMBLE:
preamble_ = from_utf8(lexrc.getLongString("EndPreamble"));
break;
case TC_HTMLPREAMBLE:
htmlpreamble_ = from_utf8(lexrc.getLongString("EndPreamble"));
break;
case TC_HTMLTOCSECTION:
html_toc_section_ = from_utf8(trim(lexrc.getString()));
break;
case TC_ADDTOPREAMBLE:
preamble_ += from_utf8(lexrc.getLongString("EndPreamble"));
break;
case TC_ADDTOHTMLPREAMBLE:
htmlpreamble_ += from_utf8(lexrc.getLongString("EndPreamble"));
break;
case TC_PROVIDES: {
lexrc.next();
string const feature = lexrc.getString();
lexrc.next();
if (lexrc.getInteger())
provides_.insert(feature);
else
provides_.erase(feature);
break;
}
case TC_REQUIRES: {
lexrc.eatLine();
vector<string> const req
= getVectorFromString(lexrc.getString());
requires_.insert(req.begin(), req.end());
break;
}
case TC_DEFAULTMODULE: {
lexrc.next();
string const module = lexrc.getString();
if (find(default_modules_.begin(), default_modules_.end(), module) == default_modules_.end())
default_modules_.push_back(module);
break;
}
case TC_PROVIDESMODULE: {
lexrc.next();
string const module = lexrc.getString();
if (find(provided_modules_.begin(), provided_modules_.end(), module) == provided_modules_.end())
provided_modules_.push_back(module);
break;
}
case TC_EXCLUDESMODULE: {
lexrc.next();
string const module = lexrc.getString();
// modules already have their own way to exclude other modules
if (rt == MODULE) {
LYXERR0("ExcludesModule tag cannot be used in a module!");
break;
}
if (find(excluded_modules_.begin(), excluded_modules_.end(), module) == excluded_modules_.end())
excluded_modules_.push_back(module);
break;
}
case TC_LEFTMARGIN: // left margin type
if (lexrc.next())
leftmargin_ = lexrc.getDocString();
break;
case TC_RIGHTMARGIN: // right margin type
if (lexrc.next())
rightmargin_ = lexrc.getDocString();
break;
case TC_INSETLAYOUT: {
if (!lexrc.next()) {
lexrc.printError("No name given for InsetLayout: `$$Token'.");
error = true;
break;
}
docstring const name = subst(lexrc.getDocString(), '_', ' ');
if (name.empty()) {
string s = "Could not read name for InsetLayout: `$$Token' "
+ lexrc.getString() + " is probably not valid UTF-8!";
lexrc.printError(s);
InsetLayout il;
// Since we couldn't read the name, we just scan the rest
// of the style and discard it.
il.read(lexrc, *this);
// Let's try to continue rather than abort.
// error = true;
} else if (hasInsetLayout(name)) {
InsetLayout & il = insetlayoutlist_[name];
error = !il.read(lexrc, *this);
} else {
InsetLayout il;
il.setName(name);
error = !il.read(lexrc, *this);
if (!error)
insetlayoutlist_[name] = il;
}
break;
}
case TC_FLOAT:
error = !readFloat(lexrc);
break;
case TC_CITEFORMAT:
readCiteFormat(lexrc);
break;
case TC_IFCOUNTER:
ifcounter = true;
case TC_COUNTER:
if (lexrc.next()) {
docstring const name = lexrc.getDocString();
if (name.empty()) {
string s = "Could not read name for counter: `$$Token' "
+ lexrc.getString() + " is probably not valid UTF-8!";
lexrc.printError(s.c_str());
Counter c;
// Since we couldn't read the name, we just scan the rest
// and discard it.
c.read(lexrc);
} else
error = !counters_.read(lexrc, name, !ifcounter);
}
else {
lexrc.printError("No name given for style: `$$Token'.");
error = true;
}
// reset flag
ifcounter = false;
break;
case TC_TITLELATEXTYPE:
readTitleType(lexrc);
break;
case TC_TITLELATEXNAME:
if (lexrc.next())
titlename_ = lexrc.getString();
break;
case TC_NOFLOAT:
if (lexrc.next()) {
string const nofloat = lexrc.getString();
floatlist_.erase(nofloat);
}
break;
} // end of switch
// Note that this is triggered the first time through the loop unless
// we hit a format tag.
if (format != LAYOUT_FORMAT)
return FORMAT_MISMATCH;
}
// at present, we abort if we encounter an error,
// so there is no point continuing.
if (error)
return ERROR;
if (rt != BASECLASS)
return (error ? ERROR : OK);
if (defaultlayout_.empty()) {
LYXERR0("Error: Textclass '" << name_
<< "' is missing a defaultstyle.");
return ERROR;
}
// Try to erase "stdinsets" from the provides_ set.
// The
// Provides stdinsets 1
// declaration simply tells us that the standard insets have been
// defined. (It's found in stdinsets.inc but could also be used in
// user-defined files.) There isn't really any such package. So we
// might as well go ahead and erase it.
// If we do not succeed, then it was not there, which means that
// the textclass did not provide the definitions of the standard
// insets. So we need to try to load them.
int erased = provides_.erase("stdinsets");
if (!erased) {
FileName tmp = libFileSearch("layouts", "stdinsets.inc");
if (tmp.empty()) {
frontend::Alert::warning(_("Missing File"),
_("Could not find stdinsets.inc! This may lead to data loss!"));
error = true;
} else if (!read(tmp, MERGE)) {
frontend::Alert::warning(_("Corrupt File"),
_("Could not read stdinsets.inc! This may lead to data loss!"));
error = true;
}
}
min_toclevel_ = Layout::NOT_IN_TOC;
max_toclevel_ = Layout::NOT_IN_TOC;
const_iterator lit = begin();
const_iterator len = end();
for (; lit != len; ++lit) {
int const toclevel = lit->toclevel;
if (toclevel != Layout::NOT_IN_TOC) {
if (min_toclevel_ == Layout::NOT_IN_TOC)
min_toclevel_ = toclevel;
else
min_toclevel_ = min(min_toclevel_, toclevel);
max_toclevel_ = max(max_toclevel_, toclevel);
}
}
LYXERR(Debug::TCLASS, "Minimum TocLevel is " << min_toclevel_
<< ", maximum is " << max_toclevel_);
return (error ? ERROR : OK);
}
void InsetCommandParams::Read(Lexer & lex, Buffer const * buffer)
{
lex.setContext("InsetCommandParams::read");
lex >> insetName(insetCode_).c_str();
lex >> "LatexCommand";
lex >> cmdName_;
if (!isCompatibleCommand(insetCode_, cmdName_)) {
lex.printError("Incompatible command name " + cmdName_ + ".");
throw ExceptionMessage(WarningException, _("InsetCommandParams Error: "),
_("Incompatible command name."));
}
info_ = findInfo(insetCode_, cmdName_);
string token;
while (lex.isOK()) {
lex.next();
token = lex.getString();
if (token == "\\end_inset")
break;
if (token == "preview") {
lex.next();
preview_ = lex.getBool();
continue;
}
if (info_.hasParam(token)) {
lex.next(true);
docstring data = lex.getDocString();
if (buffer && token == "filename") {
data = from_utf8(buffer->includedFilePath(to_utf8(data)));
} else if (buffer && token == "bibfiles") {
int i = 0;
docstring newdata;
docstring bib = support::token(data, ',', i);
while (!bib.empty()) {
bib = from_utf8(buffer->includedFilePath(to_utf8(bib), "bib"));
if (!newdata.empty())
newdata.append(1, ',');
newdata.append(bib);
bib = support::token(data, ',', ++i);
}
data = newdata;
} else if (buffer && token == "options") {
data = from_utf8(buffer->includedFilePath(to_utf8(data), "bst"));
}
params_[token] = data;
} else {
lex.printError("Unknown parameter name `$$Token' for command " + cmdName_);
throw ExceptionMessage(WarningException,
_("InsetCommandParams: ") + from_ascii(cmdName_),
_("Unknown parameter name: ") + from_utf8(token));
}
}
if (token != "\\end_inset") {
lex.printError("Missing \\end_inset at this point. "
"Read: `$$Token'");
throw ExceptionMessage(WarningException,
_("InsetCommandParams Error: "),
_("Missing \\end_inset at this point: ") + from_utf8(token));
}
}
