]> git.lyx.org Git - lyx.git/blobdiff - src/insets/InsetListingsParams.cpp
- Simplify prefs, graphics and external display options which are now true or false.
[lyx.git] / src / insets / InsetListingsParams.cpp
index 6529355ca22ab3450de107549d86a5679f160696..4c0b804372e0b472f3f2a18472032b9392779625 100644 (file)
@@ -9,10 +9,11 @@
  */
 
 #include <config.h>
+#include <algorithm>
 
 #include "InsetListingsParams.h"
 
-#include "gettext.h"
+#include "support/gettext.h"
 #include "Length.h"
 #include "Lexer.h"
 
 #include "support/textutils.h"
 #include "support/convert.h"
 
-#include <boost/assert.hpp>
+#include "support/lassert.h"
 
 #include <sstream>
 
-using std::map;
-using std::vector;
-using std::ostream;
-using std::string;
-using std::exception;
+using namespace std;
+using namespace lyx::support;
 
-namespace lyx
-{
-
-using support::bformat;
-using support::trim;
-using support::rtrim;
-using support::subst;
-using support::isStrInt;
-using support::prefixIs;
-using support::suffixIs;
-using support::getVectorFromString;
+namespace lyx {
 
 namespace {
 
@@ -193,7 +181,7 @@ docstring ListingsParam::validate(string const & par) const
                        lists.push_back(v);
 
                // good, find the string
-               if (std::find(lists.begin(), lists.end(), par2) != lists.end()) {
+               if (find(lists.begin(), lists.end(), par2) != lists.end()) {
                        if (unclosed)
                                return _("Unbalanced braces!");
                        return docstring();
@@ -231,6 +219,7 @@ docstring ListingsParam::validate(string const & par) const
                        return _("Unbalanced braces!");
                return docstring();
        }
+       return docstring();
 }
 
 
@@ -244,7 +233,7 @@ char const * allowed_languages =
        "[Sharp]C\nC++\n[ANSI]C++\n[GNU]C++\n[ISO]C++\n[Visual]C++\nCaml\n"
        "[light]Caml\n[Objective]Caml\nClean\nCobol\n[1974]Cobol\n[1985]Cobol\n"
        "[ibm]Cobol\nComal 80\ncommand.com\n[WinXP]command.com\nComsol\ncsh\n"
-       "Delphi\nEiffel\nElan\nEuphoria\nFortran\n[77]Fortran\n[90]Fortran\n"
+       "Delphi\nEiffel\nElan\nerlang\nEuphoria\nFortran\n[77]Fortran\n[90]Fortran\n"
        "[95]Fortran\nGCL\nGnuplot\nHaskell\nHTML\nIDL\n[CORBA]IDL\ninform\n"
        "Java\n[AspectJ]Java\nJVMIS\nksh\nLingo\nLisp\n[Auto]Lisp\nLogo\n"
        "make\n[gnu]make\nMathematica\n[1.0]Mathematica\n[3.0]Mathematica\n"
@@ -269,22 +258,18 @@ class ParValidator
 public:
        ParValidator();
 
-       /// \return the associated \c ListingsParam.
-       /// \warning an \c invalidParamexception will be thrown
-       ///          if the key is not found.
-       ListingsParam const & param(string const & key) const;
+       /// validate a parameter for a given name.
+       /// return an error message if \c par is an invalid parameter.
+       docstring validate(string const & name, string const & par) const;
 
-       /// validate a parameter for a given key.
-       /// \warning an \c invalidParam exception will be thrown if
-       /// \c par is an invalid parameter.
-       ListingsParam const & validate(string const & key, string const & par) const;
+       /// return the onoff status of a parameter \c key, if \c key is not found
+       /// return false
+       bool onoff(string const & key) const;
 
 private:
        /// key is the name of the parameter
        typedef map<string, ListingsParam> ListingsParams;
        ListingsParams all_params_;
-       ///
-       string all_param_names_;
 };
 
 
@@ -320,6 +305,8 @@ ParValidator::ParValidator()
                ListingsParam("", false, INTEGER, "", empty_hint);
        all_params_["lastline"] =
                ListingsParam("", false, INTEGER, "", empty_hint);
+       all_params_["linerange"] =
+               ListingsParam("", false, ALL, "", empty_hint);
        all_params_["showlines"] =
                ListingsParam("", false, TRUEFALSE, "", empty_hint);
        all_params_["emptylines"] =
@@ -419,13 +406,13 @@ ParValidator::ParValidator()
        all_params_["caption"] =
                ListingsParam("", false, ALL, "", _(
                "This parameter should not be entered here. Please use the caption "
-               "edit box (when using the include dialog) or "
+               "edit box (when using the child document dialog) or "
                "menu Insert->Caption (when defining a listing inset)"));
        // this option is not handled in the parameter box
        all_params_["label"] =
                ListingsParam("", false, ALL, "",_(
                "This parameter should not be entered here. Please use the label "
-               "edit box (when using the include dialog) or "
+               "edit box (when using the child document dialog) or "
                "menu Insert->Label (when defining a listing inset)"));
        all_params_["nolol"] =
                ListingsParam("", false, TRUEFALSE, "", empty_hint);
@@ -579,62 +566,122 @@ ParValidator::ParValidator()
                ListingsParam("", false, ALL, "", empty_hint);
        all_params_["podcomment"] =
                ListingsParam("", false, ALL, "", empty_hint);
-
-       ListingsParams::const_iterator it = all_params_.begin();
-       ListingsParams::const_iterator end = all_params_.end();
-       for (; it != end; ++it) {
-               if (!all_param_names_.empty())
-                       all_param_names_ += ", ";
-               all_param_names_ += it->first;
-       }
+       // the following are experimental listings features
+       all_params_["procnamekeys"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["moreprocnamekeys"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["deleteprocnamekeys"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["procnamestyle"] =
+               ListingsParam("", false, ALL, "", style_hint);
+       all_params_["indexprocnames"] =
+               ListingsParam("", false, TRUEFALSE, "", empty_hint);
+       all_params_["hyperref"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["morehyperref"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["deletehyperref"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["hyperanchor"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["hyperlink"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["literate"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["lgrindef"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["rangebeginprefix"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["rangebeginsuffix"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["rangeendprefix"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["rangeendsuffix"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["rangeprefix"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["rangesuffix"] =
+               ListingsParam("", false, ALL, "", empty_hint);
+       all_params_["includerangemarker"] =
+               ListingsParam("", false, TRUEFALSE, "", empty_hint);
+       all_params_["multicols"] =
+               ListingsParam("", false, INTEGER, "", empty_hint);
 }
 
 
-ListingsParam const & ParValidator::validate(string const & key,
+docstring ParValidator::validate(string const & name,
                string const & par) const
 {
-       ListingsParam const & lparam = param(key);
-       docstring s = lparam.validate(par);
-       if (!s.empty())
-               throw invalidParam(bformat(_("Parameter %1$s: "), from_utf8(key)) + s);
-       return lparam;
+       if (name.empty())
+               return _("Invalid (empty) listing parameter name.");
+
+       if (name[0] == '?') {
+               string suffix = trim(string(name, 1));
+               string param_names;
+               ListingsParams::const_iterator it = all_params_.begin();
+               ListingsParams::const_iterator end = all_params_.end();
+               for (; it != end; ++it) {
+                       if (suffix.empty() || contains(it->first, suffix)) {
+                               if (!param_names.empty())
+                                       param_names += ", ";
+                               param_names += it->first;
+                       }
+               }
+               if (suffix.empty())
+                       return bformat(
+                                       _("Available listing parameters are %1$s"), from_ascii(param_names));
+               else
+                       return bformat(
+                                       _("Available listings parameters containing string \"%1$s\" are %2$s"), 
+                                               from_utf8(suffix), from_utf8(param_names));
+       }
+       // locate name in parameter table
+       ListingsParams::const_iterator it = all_params_.find(name);
+       if (it != all_params_.end()) {
+               docstring msg = it->second.validate(par);
+               if (msg.empty())
+                       return msg;
+               else
+                       return bformat(_("Parameter %1$s: "), from_utf8(name)) + msg;
+       } else {
+               // otherwise, produce a meaningful error message.
+               string matching_names;
+               ListingsParams::const_iterator end = all_params_.end();
+               for (it = all_params_.begin(); it != end; ++it) {
+                       if (prefixIs(it->first, name)) {
+                               if (!matching_names.empty())
+                                       matching_names += ", ";
+                               matching_names += it->first;
+                       }
+               }
+               if (matching_names.empty())
+                       return bformat(_("Unknown listing parameter name: %1$s"),
+                                                               from_utf8(name));
+               else
+                       return bformat(_("Parameters starting with '%1$s': %2$s"),
+                                                               from_utf8(name), from_utf8(matching_names));
+       }
+       return docstring();
 }
 
 
-ListingsParam const & ParValidator::param(string const & name) const
+bool ParValidator::onoff(string const & name) const
 {
-       if (name.empty())
-               throw invalidParam(_("Invalid (empty) listing parameter name."));
-
-       if (name == "?")
-               throw invalidParam(bformat(
-                       _("Available listing parameters are %1$s"), from_ascii(all_param_names_)));
-
        // locate name in parameter table
        ListingsParams::const_iterator it = all_params_.find(name);
        if (it != all_params_.end())
-               return it->second;
-
-       // otherwise, produce a meaningful error message.
-       string matching_names;
-       ListingsParams::const_iterator end = all_params_.end();
-       for (it = all_params_.begin(); it != end; ++it) {
-               if (prefixIs(it->first, name)) {
-                       if (!matching_names.empty())
-                               matching_names += ", ";
-                       matching_names += it->first;
-               }
-       }
-       if (matching_names.empty())
-               throw invalidParam(bformat(_("Unknown listing parameter name: %1$s"),
-                                                   from_utf8(name)));
+               return it->second.onoff_;
        else
-               throw invalidParam(bformat(_("Parameters starting with '%1$s': %2$s"),
-                                                   from_utf8(name), from_utf8(matching_names)));
+               return false;
 }
 
 } // namespace anon.
 
+// define a global ParValidator
+ParValidator * par_validator = 0;
+
 InsetListingsParams::InsetListingsParams()
        : inline_(false), params_(), status_(InsetCollapsable::Open)
 {
@@ -663,10 +710,9 @@ void InsetListingsParams::write(ostream & os) const
 void InsetListingsParams::read(Lexer & lex)
 {
        lex >> inline_;
-       int s;
+       int s = Inset::Collapsed;
        lex >> s;
-       if (lex)
-               status_ = static_cast<InsetCollapsable::CollapseStatus>(s);
+       status_ = static_cast<InsetCollapsable::CollapseStatus>(s);
        string par;
        lex >> par;
        fromEncodedString(par);
@@ -695,19 +741,17 @@ void InsetListingsParams::addParam(string const & key, string const & value)
        if (key.empty())
                return;
 
-       static ParValidator par_validator;
-
-       // exception may be thown.
-       ListingsParam const & lparam = par_validator.validate(key, value);
        // duplicate parameters!
        string keyname = key;
        if (params_.find(key) != params_.end())
                // key=value,key=value1 is allowed in listings
                // use key_, key__, key___ etc to avoid name conflict
-               while (params_.find(keyname += '_') != params_.end());
+               while (params_.find(keyname += '_') != params_.end()) { }
        // check onoff flag
        // onoff parameter with value false
-       if (lparam.onoff_ && (value == "false" || value == "{false}"))
+       if (!par_validator)
+               par_validator = new ParValidator();
+       if (par_validator->onoff(key) && (value == "false" || value == "{false}"))
                params_[keyname] = string();
        // if the parameter is surrounded with {}, good
        else if (prefixIs(value, "{") && suffixIs(value, "}"))
@@ -752,7 +796,7 @@ void InsetListingsParams::addParams(string const & par)
                } else if (par[i] == '=' && braces == 0) {
                        isValue = true;
                        continue;
-               } else if (par[i] == '{' && par[i - 1] == '=')
+               } else if (par[i] == '{' && i > 0 && par[i - 1] == '=')
                        braces ++;
                else if (par[i] == '}'
                        && (i == par.size() - 1 || par[i + 1] == ',' || par[i + 1] == '\n'))
@@ -820,8 +864,26 @@ string InsetListingsParams::getParamValue(string const & param) const
 {
        // is this parameter defined?
        map<string, string>::const_iterator it = params_.find(param);
-       return (it == params_.end()) ? string() : it->second;
+       string par = (it == params_.end()) ? string() : it->second;
+       if (prefixIs(par, "{") && suffixIs(par, "}"))
+               return par.substr(1, par.size() - 2);
+       else
+               return par;
 }
 
 
+docstring InsetListingsParams::validate() const
+{
+       docstring msg;
+       if (!par_validator)
+               par_validator = new ParValidator();
+       for (map<string, string>::const_iterator it = params_.begin();
+               it != params_.end(); ++it) {
+               msg = par_validator->validate(it->first, it->second);
+               if (!msg.empty())
+                       return msg;
+       }
+       return msg;
+}
+
 } // namespace lyx