Fix bug #8580: Do not include material in the XHTML TOC that is not

[lyx.git] / src / insets / InsetListingsParams.cpp

diff --git a/src/insets/InsetListingsParams.cpp b/src/insets/InsetListingsParams.cpp
index ce5042e7a30b4348b7e8cda65369ffa258fc300b..fa488c07d82f60af68a702e285e4003f534d0702 100644 (file)
--- a/src/insets/InsetListingsParams.cpp
+++ b/src/insets/InsetListingsParams.cpp
@@ -9,39 +9,24 @@
  */
 
 #include <config.h>
+#include <algorithm>
 
 #include "InsetListingsParams.h"
 
-#include "gettext.h"
 #include "Length.h"
 #include "Lexer.h"
 
+#include "support/convert.h"
+#include "support/gettext.h"
 #include "support/lstrings.h"
 #include "support/textutils.h"
-#include "support/convert.h"
-
-#include <boost/assert.hpp>
 
 #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;
-using lyx::support::contains;
+namespace lyx {
 
 namespace {
 
@@ -51,7 +36,7 @@ enum param_type {
        INTEGER, // accept an integer
        LENGTH,  // accept a latex length
        ONEOF,  // accept one of a few values
-       SUBSETOF, // accept a string composed of given characters
+       SUBSETOF // accept a string composed of given characters
 };
 
 
@@ -113,13 +98,19 @@ docstring ListingsParam::validate(string const & par) const
        bool unclosed = false;
        string par2 = par;
        // braces are allowed
-       if (prefixIs(par, "{") && suffixIs(par, "}"))
+       if (prefixIs(par, "{") && suffixIs(par, "}") && !suffixIs(par, "\\}"))  
                par2 = par.substr(1, par.size() - 2);
-       else if (prefixIs(par, "{")) {
-               par2 = par.substr(1);
-               unclosed = true;
-       }
 
+       // check for unmatched braces
+       int braces = 0;
+       for (size_t i = 0; i < par2.size(); ++i) {
+               if (par2[i] == '{' && (i == 0 || par2[i-1] != '\\'))
+                       ++braces;
+               else if (par2[i] == '}' && (i == 0 || par2[i-1] != '\\'))
+                       --braces;
+       }
+       unclosed = braces != 0;
+       
        switch (type_) {
 
        case ALL:
@@ -130,7 +121,7 @@ docstring ListingsParam::validate(string const & par) const
                                return _("A value is expected.");
                }
                if (unclosed)
-                               return _("Unbalanced braces!");
+                       return _("Unbalanced braces!");
                return docstring();
 
        case TRUEFALSE:
@@ -194,7 +185,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();
@@ -246,7 +237,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"
@@ -445,6 +436,8 @@ ParValidator::ParValidator()
                ListingsParam("", false, TRUEFALSE, "", empty_hint);
        all_params_["breaklines"] =
                ListingsParam("", false, TRUEFALSE, "", empty_hint);
+       all_params_["breakatwhitespace"] =
+               ListingsParam("", false, TRUEFALSE, "", empty_hint);
        all_params_["prebreak"] =
                ListingsParam("", false, ALL, "", empty_hint);
        all_params_["postbreak"] =
@@ -693,7 +686,7 @@ bool ParValidator::onoff(string const & name) const
 } // namespace anon.
 
 // define a global ParValidator
-ParValidator * par_validator = NULL;
+ParValidator * par_validator = 0;
 
 InsetListingsParams::InsetListingsParams()
        : inline_(false), params_(), status_(InsetCollapsable::Open)
@@ -723,10 +716,9 @@ void InsetListingsParams::write(ostream & os) const
 void InsetListingsParams::read(Lexer & lex)
 {
        lex >> inline_;
-       int s;
+       int s = InsetCollapsable::Collapsed;
        lex >> s;
-       if (lex)
-               status_ = static_cast<InsetCollapsable::CollapseStatus>(s);
+       status_ = static_cast<InsetCollapsable::CollapseStatus>(s);
        string par;
        lex >> par;
        fromEncodedString(par);
@@ -750,21 +742,22 @@ string InsetListingsParams::params(string const & sep) const
 }
 
 
-void InsetListingsParams::addParam(string const & key, string const & value)
+void InsetListingsParams::addParam(string const & key, 
+               string const & value, bool replace)
 {
        if (key.empty())
                return;
 
        // duplicate parameters!
        string keyname = key;
-       if (params_.find(key) != params_.end())
+       if (!replace && 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 (!par_validator)
-               par_validator = new ParValidator();
+               par_validator = new ParValidator;
        if (par_validator->onoff(key) && (value == "false" || value == "{false}"))
                params_[keyname] = string();
        // if the parameter is surrounded with {}, good
@@ -775,7 +768,7 @@ void InsetListingsParams::addParam(string const & key, string const & value)
        else {
                bool has_special_char = false;
                for (size_t i = 0; i < value.size(); ++i)
-                       if (!isAlphaASCII(value[i]) && !isDigit(value[i])) {
+                       if (!isAlnumASCII(value[i])) {
                                has_special_char = true;
                                break;
                        }
@@ -810,11 +803,12 @@ void InsetListingsParams::addParams(string const & par)
                } 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] == ',' || par[i + 1] == '\n'))
-                       braces --;
+               } else if (par[i] == '{' && i > 0 && par[i-1] != '\\')
+                       // don't count a brace in first position
+                       ++braces;
+               else if (par[i] == '}' && i != par.size() - 1 
+                        && (i == 0 || (i > 0 && par[i-1] != '\\')))
+                       --braces;
 
                if (isValue)
                        value += par[i];
@@ -890,7 +884,7 @@ docstring InsetListingsParams::validate() const
 {
        docstring msg;
        if (!par_validator)
-               par_validator = new ParValidator();
+               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);