mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-11-11 13:46:43 +00:00
a42d3e670b
* src/insets/InsetListingsParams.{cpp,h}
- implement getParamValue that returns the value of a listings param
* src/insets/InsetInclude.cpp:
- (getLabelList): pass listings label to the list, if available
- doDispatch: implement changeRefsIfUnique for listing labels
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@18405 a592a061-630c-0410-9148-cb99ea01b6c8
584 lines
18 KiB
C++
584 lines
18 KiB
C++
/**
|
|
* \file InsetListingsParams.cpp
|
|
* This file is part of LyX, the document processor.
|
|
* Licence details can be found in the file COPYING.
|
|
*
|
|
* \author Bo Peng
|
|
*
|
|
* Full author contact details are available in file CREDITS.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include "Lexer.h"
|
|
#include "InsetListingsParams.h"
|
|
|
|
#include "gettext.h"
|
|
#include "Length.h"
|
|
|
|
#include <sstream>
|
|
#include <boost/assert.hpp>
|
|
|
|
#include "support/lstrings.h"
|
|
#include "support/convert.h"
|
|
|
|
using std::vector;
|
|
using std::ostream;
|
|
using std::string;
|
|
using std::exception;
|
|
using lyx::support::trim;
|
|
using lyx::support::isStrInt;
|
|
using lyx::support::prefixIs;
|
|
using lyx::support::suffixIs;
|
|
using lyx::support::getVectorFromString;
|
|
|
|
namespace lyx
|
|
{
|
|
|
|
enum param_type {
|
|
ALL, // accept all
|
|
TRUEFALSE, // accept 'true' or 'false'
|
|
INTEGER, // accept an integer
|
|
LENGTH, // accept an latex length
|
|
ONEOF, // accept one of a few values
|
|
SUBSETOF, // accept a string composed of given characters
|
|
};
|
|
|
|
|
|
/** Information about each parameter
|
|
*/
|
|
struct listings_param_info {
|
|
/// name of the parameter
|
|
char const * name;
|
|
/// default value
|
|
char const * value;
|
|
// for option with value "true", "false",
|
|
// if onoff is true,
|
|
// "true": option
|
|
// "false":
|
|
// "other": option="other"
|
|
// onoff is false,
|
|
// "true": option=true
|
|
// "false": option=false
|
|
bool onoff;
|
|
/// validator type
|
|
param_type type;
|
|
// ALL:
|
|
// TRUEFALSE:
|
|
// INTEGER:
|
|
// LENGTH:
|
|
// info is ignored.
|
|
// ONEOF
|
|
// info is a \n separated string with allowed values
|
|
// SUBSETOF
|
|
// info is a string from which par is composed of
|
|
// (e.g. floatplacement can be one or more of tbph)
|
|
char const * info;
|
|
//
|
|
char const * hint;
|
|
};
|
|
|
|
|
|
char const * allowed_languages =
|
|
"no language\nBAP\nACSL\nAda\nALGOL\nC\nC++\nCaml\nClean\nCobol\n"
|
|
"Comal 80\ncsh\nDelphi\nEiffel\nElan\nEuphoria\nFortran\nHaskell\n"
|
|
"HTML\nIDL\nJava\nLisp\nLogo\nmake\nMathematica\nMatlab\nMercury\n"
|
|
"Miranda\nML\nModula-2\nOberon-2\nOCL\nPascal\nPerl\nPHP\nPL/I\nPOV\n"
|
|
"Python\nProlog\nR\nS\nSAS\nSHELXL\nSimula\ntcl\nSQL\nTeX\nVBScript\n"
|
|
"VHDL\nXML";
|
|
|
|
char const * style_hint = "Use \\footnotessize, \\small, \\itshape, \\ttfamily or something like that";
|
|
char const * frame_hint = "none, leftline, topline, bottomline, lines, single, shadowbox or subset of trblTRBL";
|
|
char const * frameround_hint = "The foru letters (t or f) attached to top right, bottom right, bottom left and top left corner.";
|
|
char const * color_hint = "Enter something like \\color{white}";
|
|
|
|
/// options copied from page 26 of listings manual
|
|
// FIXME: add default parameters ... (which is not used now)
|
|
listings_param_info const listings_param_table[] = {
|
|
{ "float", "false", true, SUBSETOF, "tbph", "" },
|
|
{ "floatplacement", "tbp", false, SUBSETOF, "tbph", "" },
|
|
{ "aboveskip", "\\medskipamount", false, LENGTH, "", "" },
|
|
{ "belowskip", "\\medskipamount", false, LENGTH, "", "" },
|
|
{ "lineskip", "", false, LENGTH, "", "" },
|
|
{ "boxpos", "", false, SUBSETOF, "bct", "" },
|
|
{ "print", "", false, TRUEFALSE, "", "" },
|
|
{ "firstline", "", false, INTEGER, "", "" },
|
|
{ "lastline", "", false, INTEGER, "", "" },
|
|
{ "showlines", "", false, TRUEFALSE, "", "" },
|
|
{ "emptylines", "", false, ALL, "", "Expect a number with an optional * before it" },
|
|
{ "gobble", "", false, INTEGER, "", "" },
|
|
{ "style", "", false, ALL, "", "" },
|
|
{ "language", "", false, ONEOF, allowed_languages, "" },
|
|
{ "alsolanguage", "", false, ONEOF, allowed_languages, "" },
|
|
{ "defaultdialect", "", false, ONEOF, allowed_languages, "" },
|
|
{ "printpod", "", false, TRUEFALSE, "", "" },
|
|
{ "usekeywordsintag", "", false, TRUEFALSE, "", "" },
|
|
{ "tagstyle", "", false, ALL, "", style_hint },
|
|
{ "markfirstintag", "", false, ALL, "", style_hint },
|
|
{ "makemacrouse", "", false, TRUEFALSE, "", "" },
|
|
{ "basicstyle", "", false, ALL, "", style_hint },
|
|
{ "identifierstyle", "", false, ALL, "", style_hint },
|
|
{ "commentstyle", "", false, ALL, "", style_hint },
|
|
{ "stringstyle", "", false, ALL, "", style_hint },
|
|
{ "keywordstyle", "", false, ALL, "", style_hint },
|
|
{ "ndkeywordstyle", "", false, ALL, "", style_hint },
|
|
{ "classoffset", "", false, INTEGER, "", "" },
|
|
{ "texcsstyle", "", false, ALL, "", style_hint },
|
|
{ "directivestyle", "", false, ALL, "", style_hint },
|
|
{ "emph", "", false, ALL, "", "" },
|
|
{ "moreemph", "", false, ALL, "", "" },
|
|
{ "deleteemph", "", false, ALL, "", "" },
|
|
{ "emphstyle", "", false, ALL, "", "" },
|
|
{ "delim", "", false, ALL, "", "" },
|
|
{ "moredelim", "", false, ALL, "", "" },
|
|
{ "deletedelim", "", false, ALL, "", "" },
|
|
{ "extendedchars", "", false, TRUEFALSE, "", "" },
|
|
{ "inputencoding", "", false, ALL, "", "" },
|
|
{ "upquote", "", false, TRUEFALSE, "", "" },
|
|
{ "tabsize", "", false, INTEGER, "", "" },
|
|
{ "showtabs", "", false, ALL, "", "" },
|
|
{ "tab", "", false, ALL, "", "" },
|
|
{ "showspaces", "", false, TRUEFALSE, "", "" },
|
|
{ "showstringspaces", "", false, TRUEFALSE, "", "" },
|
|
{ "formfeed", "", false, ALL, "", "" },
|
|
{ "numbers", "", false, ONEOF, "none\nleft\nright", "" },
|
|
{ "stepnumber", "", false, INTEGER, "", "" },
|
|
{ "numberfirstline", "", false, TRUEFALSE, "", "" },
|
|
{ "numberstyle", "", false, ALL, "", style_hint },
|
|
{ "numbersep", "", false, LENGTH, "", "" },
|
|
{ "numberblanklines", "", false, ALL, "", "" },
|
|
{ "firstnumber", "", false, ALL, "", "auto, last or a number" },
|
|
{ "name", "", false, ALL, "", "" },
|
|
{ "thelstnumber", "", false, ALL, "", "" },
|
|
{ "title", "", false, ALL, "", "" },
|
|
// this option is not handled in the parameter box
|
|
{ "caption", "", false, ALL, "", "This parameter should not be entered here. "
|
|
"Please use caption editbox (Include dialog) or insert->caption (listings inset)" },
|
|
// this option is not handled in the parameter box
|
|
{ "label", "", false, ALL, "", "This parameter should not be entered here."
|
|
"Please use label editbox (Include dialog) or insert->caption (listings inset)"},
|
|
{ "nolol", "", false, TRUEFALSE, "", "" },
|
|
{ "captionpos", "", false, SUBSETOF, "tb", "" },
|
|
{ "abovecaptionskip", "", false, LENGTH, "", "" },
|
|
{ "belowcaptionskip", "", false, LENGTH, "", "" },
|
|
{ "linewidth", "", false, LENGTH, "", "" },
|
|
{ "xleftmargin", "", false, LENGTH, "", "" },
|
|
{ "xrightmargin", "", false, LENGTH, "", "" },
|
|
{ "resetmargins", "", false, TRUEFALSE, "", "" },
|
|
{ "breaklines", "", false, TRUEFALSE, "", "" },
|
|
{ "prebreak", "", false, ALL, "", "" },
|
|
{ "postbreak", "", false, ALL, "", "" },
|
|
{ "breakindent", "", false, LENGTH, "", "" },
|
|
{ "breakautoindent", "", false, TRUEFALSE, "", "" },
|
|
{ "frame", "", false, ALL, "", frame_hint },
|
|
{ "frameround", "", false, SUBSETOF, "tf", frameround_hint },
|
|
{ "framesep", "", false, LENGTH, "", "" },
|
|
{ "rulesep", "", false, LENGTH, "", "" },
|
|
{ "framerule", "", false, LENGTH, "", "" },
|
|
{ "framexleftmargin", "", false, LENGTH, "", "" },
|
|
{ "framexrightmargin", "", false, LENGTH, "", "" },
|
|
{ "framextopmargin", "", false, LENGTH, "", "" },
|
|
{ "framexbottommargin", "", false, LENGTH, "", "" },
|
|
{ "backgroundcolor", "", false, ALL, "", color_hint },
|
|
{ "rulecolor", "", false, ALL, "", color_hint },
|
|
{ "fillcolor", "", false, ALL, "", color_hint },
|
|
{ "rulesepcolor", "", false, ALL, "", color_hint },
|
|
{ "frameshape", "", false, ALL, "", "" },
|
|
{ "index", "", false, ALL, "", "" },
|
|
{ "moreindex", "", false, ALL, "", "" },
|
|
{ "deleteindex", "", false, ALL, "", "" },
|
|
{ "indexstyle", "", false, ALL, "", "" },
|
|
{ "columns", "", false, ALL, "", "" },
|
|
{ "flexiblecolumns", "", false, ALL, "", "" },
|
|
{ "keepspaces", "", false, TRUEFALSE, "", "" },
|
|
{ "basewidth", "", false, LENGTH, "", "" },
|
|
{ "fontadjust", "", true, TRUEFALSE, "", "" },
|
|
{ "texcl", "", false, TRUEFALSE, "", "" },
|
|
{ "mathescape", "", false, TRUEFALSE, "", "" },
|
|
{ "escapechar", "", false, ALL, "", "" },
|
|
{ "escapeinside", "", false, ALL, "", "" },
|
|
{ "escepeinside", "", false, ALL, "", "" },
|
|
{ "escepebegin", "", false, ALL, "", "" },
|
|
{ "escepeend", "", false, ALL, "", "" },
|
|
{ "fancyvrb", "", false, TRUEFALSE, "", "" },
|
|
{ "fvcmdparams", "", false, ALL, "", "" },
|
|
{ "morefvcmdparams", "", false, ALL, "", "" },
|
|
{ "keywordsprefix", "", false, ALL, "", "" },
|
|
{ "keywords", "", false, ALL, "", "" },
|
|
{ "morekeywords", "", false, ALL, "", "" },
|
|
{ "deletekeywords", "", false, ALL, "", "" },
|
|
{ "ndkeywords", "", false, ALL, "", "" },
|
|
{ "morendkeywords", "", false, ALL, "", "" },
|
|
{ "deletendkeywords", "", false, ALL, "", "" },
|
|
{ "texcs", "", false, ALL, "", "" },
|
|
{ "moretexcs", "", false, ALL, "", "" },
|
|
{ "deletetexcs", "", false, ALL, "", "" },
|
|
{ "directives", "", false, ALL, "", "" },
|
|
{ "moredirectives", "", false, ALL, "", "" },
|
|
{ "deletedirectives", "", false, ALL, "", "" },
|
|
{ "sensitive", "", false, ALL, "", "" },
|
|
{ "alsoletter", "", false, ALL, "", "" },
|
|
{ "alsodigit", "", false, ALL, "", "" },
|
|
{ "alsoother", "", false, ALL, "", "" },
|
|
{ "otherkeywords", "", false, ALL, "", "" },
|
|
{ "tag", "", false, ALL, "", "" },
|
|
{ "string", "", false, ALL, "", "" },
|
|
{ "morestring", "", false, ALL, "", "" },
|
|
{ "deletestring", "", false, ALL, "", "" },
|
|
{ "comment", "", false, ALL, "", "" },
|
|
{ "morecomment", "", false, ALL, "", "" },
|
|
{ "deletecomment", "", false, ALL, "", "" },
|
|
{ "keywordcomment", "", false, ALL, "", "" },
|
|
{ "morekeywordcomment", "", false, ALL, "", "" },
|
|
{ "deletekeywordcomment", "", false, ALL, "", "" },
|
|
{ "keywordcommentsemicolon", "", false, ALL, "", "" },
|
|
{ "podcomment", "", false, ALL, "", "" },
|
|
{ "", "", false, ALL, "", ""}
|
|
};
|
|
|
|
|
|
class parValidator
|
|
{
|
|
public:
|
|
parValidator(string const & name);
|
|
|
|
/// validate given parameter
|
|
/// invalidParam will be thrown if invalid
|
|
/// parameter is found.
|
|
void validate(std::string const & par) const;
|
|
|
|
private:
|
|
/// parameter name
|
|
string const & name;
|
|
///
|
|
listings_param_info const * info;
|
|
};
|
|
|
|
|
|
parValidator::parValidator(string const & n)
|
|
: name(n), info(0)
|
|
{
|
|
if (name.empty())
|
|
throw invalidParam("Invalid (empty) listings param name.");
|
|
else if (name == "?") {
|
|
string pars;
|
|
size_t idx = 0;
|
|
while (listings_param_table[idx].name != string()) {
|
|
if (!pars.empty())
|
|
pars += ", ";
|
|
pars += listings_param_table[idx].name;
|
|
++idx;
|
|
}
|
|
throw invalidParam("Available listings parameters are " + pars);
|
|
}
|
|
// locate name in parameter table
|
|
size_t idx = 0;
|
|
while (listings_param_table[idx].name != name && listings_param_table[idx].name != string())
|
|
++idx;
|
|
// found the name
|
|
if (listings_param_table[idx].name != "") {
|
|
info = &listings_param_table[idx];
|
|
return;
|
|
}
|
|
// otherwise, produce a meaningful error message.
|
|
string matching_names;
|
|
for (size_t i = 0; i < idx; ++i) {
|
|
string n(listings_param_table[i].name);
|
|
if (n.size() >= name.size() && n.substr(0, name.size()) == name) {
|
|
if (matching_names.empty())
|
|
matching_names += n;
|
|
else
|
|
matching_names += ", " + n;
|
|
}
|
|
}
|
|
if (matching_names.empty())
|
|
throw invalidParam("Unknown listings param name: " + name);
|
|
else
|
|
throw invalidParam("Parameters starting with '" + name +
|
|
"': " + matching_names);
|
|
}
|
|
|
|
|
|
void parValidator::validate(std::string const & par) const
|
|
{
|
|
switch (info->type) {
|
|
case ALL:
|
|
if (par.empty() && !info->onoff) {
|
|
if (info->hint != "")
|
|
throw invalidParam(info->hint);
|
|
else
|
|
throw invalidParam("An value is expected");
|
|
}
|
|
return;
|
|
case TRUEFALSE: {
|
|
if (par.empty() && !info->onoff) {
|
|
if (info->hint != "")
|
|
throw invalidParam(info->hint);
|
|
else
|
|
throw invalidParam("Please specify true or false");
|
|
}
|
|
if (par != "true" && par != "false")
|
|
throw invalidParam("Only true or false is allowed for parameter" + name);
|
|
return;
|
|
}
|
|
case INTEGER: {
|
|
if (!isStrInt(par)) {
|
|
if (info->hint != "")
|
|
throw invalidParam(info->hint);
|
|
else
|
|
throw invalidParam("Please specify an integer value");
|
|
}
|
|
if (convert<int>(par) == 0 && par[0] != '0')
|
|
throw invalidParam("An integer is expected for parameter " + name);
|
|
return;
|
|
}
|
|
case LENGTH: {
|
|
if (par.empty() && !info->onoff) {
|
|
if (info->hint != "")
|
|
throw invalidParam(info->hint);
|
|
else
|
|
throw invalidParam("Please specify a latex length expression");
|
|
}
|
|
if (!isValidLength(par))
|
|
throw invalidParam("Invalid latex length expression for parameter " + name);
|
|
return;
|
|
}
|
|
case ONEOF: {
|
|
if (par.empty() && !info->onoff) {
|
|
if (info->hint != "")
|
|
throw invalidParam(info->hint);
|
|
else
|
|
throw invalidParam("Please specify one of " + string(info->info));
|
|
}
|
|
// break value to allowed strings
|
|
vector<string> lists;
|
|
string v;
|
|
for (size_t i = 0; info->info[i] != '\0'; ++i) {
|
|
if (info->info[i] == '\n') {
|
|
lists.push_back(v);
|
|
v = string();
|
|
} else
|
|
v += info->info[i];
|
|
}
|
|
if (!v.empty())
|
|
lists.push_back(v);
|
|
|
|
// good, find the string
|
|
if (std::find(lists.begin(), lists.end(), par) != lists.end())
|
|
return;
|
|
// otherwise, produce a meaningful error message.
|
|
string matching_names;
|
|
for (vector<string>::iterator it = lists.begin();
|
|
it != lists.end(); ++it) {
|
|
if (it->size() >= par.size() && it->substr(0, par.size()) == par) {
|
|
if (matching_names.empty())
|
|
matching_names += *it;
|
|
else
|
|
matching_names += ", " + *it;
|
|
}
|
|
}
|
|
if (matching_names.empty())
|
|
throw invalidParam("Try one of " + string(info->info));
|
|
else
|
|
throw invalidParam("I guess you mean " + matching_names);
|
|
return;
|
|
}
|
|
case SUBSETOF: {
|
|
if (par.empty() && !info->onoff) {
|
|
if (info->hint != "")
|
|
throw invalidParam(info->hint);
|
|
else
|
|
throw invalidParam("Please specify one or more of " + string(info->info));
|
|
}
|
|
for (size_t i = 0; i < par.size(); ++i)
|
|
if (string(info->info).find(par[i], 0) == string::npos)
|
|
throw invalidParam("Parameter " + name +
|
|
" should be composed of one or more of " + info->info);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
InsetListingsParams::InsetListingsParams() :
|
|
inline_(false), params_(), keys_(0), status_(InsetCollapsable::Open)
|
|
{
|
|
}
|
|
|
|
|
|
InsetListingsParams::InsetListingsParams(string const & par, bool in, InsetCollapsable::CollapseStatus s)
|
|
: inline_(in), params_(), keys_(0), status_(s)
|
|
{
|
|
// this will activate parameter validation.
|
|
fromEncodedString(par);
|
|
}
|
|
|
|
|
|
void InsetListingsParams::write(ostream & os) const
|
|
{
|
|
if (inline_)
|
|
os << "true ";
|
|
else
|
|
os << "false ";
|
|
os << status_ << " \"" << encodedString() << "\"";
|
|
}
|
|
|
|
|
|
void InsetListingsParams::read(Lexer & lex)
|
|
{
|
|
lex >> inline_;
|
|
int s;
|
|
lex >> s;
|
|
if (lex)
|
|
status_ = static_cast<InsetCollapsable::CollapseStatus>(s);
|
|
string par;
|
|
lex >> par;
|
|
fromEncodedString(par);
|
|
}
|
|
|
|
|
|
void InsetListingsParams::addParam(string const & key, string const & value)
|
|
{
|
|
if (key.empty())
|
|
return;
|
|
// exception may be thown.
|
|
parValidator(key.c_str()).validate(value);
|
|
// duplicate parameters!
|
|
if (find(keys_.begin(), keys_.end(), key) != keys_.end())
|
|
throw invalidParam("Parameter " + key + " has already been defined");
|
|
else
|
|
keys_.push_back(key);
|
|
if (!params_.empty())
|
|
params_ += ',';
|
|
if (value.empty())
|
|
params_ += key;
|
|
else {
|
|
// check onoff flag
|
|
size_t idx = 0;
|
|
while (listings_param_table[idx].name != key)
|
|
++idx;
|
|
BOOST_ASSERT(listings_param_table[idx].name == key);
|
|
if (listings_param_table[idx].onoff && value == "false")
|
|
params_ += key;
|
|
else
|
|
params_ += key + '=' + value;
|
|
}
|
|
}
|
|
|
|
|
|
void InsetListingsParams::addParams(string const & par)
|
|
{
|
|
string key;
|
|
string value;
|
|
bool isValue = false;
|
|
int braces = 0;
|
|
for (size_t i = 0; i < par.size(); ++i) {
|
|
// end of par
|
|
if (par[i] == '\n') {
|
|
addParam(trim(key), trim(value));
|
|
key = string();
|
|
value = string();
|
|
isValue = false;
|
|
continue;
|
|
} else if (par[i] == ',' && braces == 0) {
|
|
addParam(trim(key), trim(value));
|
|
key = string();
|
|
value = string();
|
|
isValue = false;
|
|
continue;
|
|
} else if (par[i] == '=' && braces == 0) {
|
|
isValue = true;
|
|
continue;
|
|
} else if (par[i] == '{' && par[i - 1] == '=')
|
|
braces ++;
|
|
else if (par[i] == '}' && (i == par.size() - 1 || par[i + 1] == ','))
|
|
braces --;
|
|
|
|
if (isValue)
|
|
value += par[i];
|
|
else
|
|
key += par[i];
|
|
}
|
|
if (!trim(key).empty())
|
|
addParam(trim(key), trim(value));
|
|
}
|
|
|
|
|
|
void InsetListingsParams::setParams(string const & par)
|
|
{
|
|
params_.clear();
|
|
keys_.clear();
|
|
addParams(par);
|
|
}
|
|
|
|
|
|
string InsetListingsParams::encodedString() const
|
|
{
|
|
// Encode string!
|
|
// FIXME:
|
|
// '"' should be handled differently because it will
|
|
// terminate a lyx token. Right now, it is silently ignored.
|
|
string par;
|
|
for (size_t i = 0; i < params_.size(); ++i) {
|
|
BOOST_ASSERT(params_[i] != '\n');
|
|
if (params_[i] != '"')
|
|
par += params_[i];
|
|
}
|
|
return par;
|
|
}
|
|
|
|
|
|
string InsetListingsParams::separatedParams(bool keepComma) const
|
|
{
|
|
// , might be used as regular parameter option so
|
|
// the prcess might be more complicated than what I am doing here
|
|
string opt;
|
|
int braces = 0;
|
|
for (size_t i = 0; i < params_.size(); ++i)
|
|
if (params_[i] == ',' && braces == 0) {
|
|
if (keepComma)
|
|
opt += ",\n";
|
|
else
|
|
opt += "\n";
|
|
} else if (params_[i] == '{' && params_[i - 1] == '=') {
|
|
braces ++;
|
|
opt += params_[i];
|
|
} else if (params_[i] == '}' && (i == params_.size() -1 || params_[i + 1] == ',')) {
|
|
braces --;
|
|
opt += params_[i];
|
|
} else
|
|
opt += params_[i];
|
|
return opt;
|
|
}
|
|
|
|
|
|
void InsetListingsParams::fromEncodedString(string const & in)
|
|
{
|
|
// Decode string!
|
|
// Do nothing because " was silently ignored.
|
|
setParams(in);
|
|
}
|
|
|
|
|
|
string InsetListingsParams::getParamValue(string const & param) const
|
|
{
|
|
// is this parameter defined?
|
|
if (find(keys_.begin(), keys_.end(), param) == keys_.end())
|
|
return string();
|
|
// if so, search for it
|
|
vector<string> pars = getVectorFromString(separatedParams(), "\n");
|
|
for (vector<string>::iterator it = pars.begin(); it != pars.end(); ++it)
|
|
if (prefixIs(*it, param + "=")) {
|
|
string par = it->substr(param.size() + 1);
|
|
if (prefixIs(par, "{") && suffixIs(par, "}"))
|
|
return par.substr(1, par.size() - 2);
|
|
else
|
|
return par;
|
|
}
|
|
// if param= is not found, should be something like float, return ""
|
|
return string();
|
|
}
|
|
|
|
|
|
} // namespace lyx
|