Move Lexer to support/ directory (and lyx::support namespace)

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

diff --git a/src/insets/InsetCommandParams.cpp b/src/insets/InsetCommandParams.cpp
index c3df45a36af3d2269aeeeaedea8728c0872a477e..523a4c81dc2d8b9417485072ad5fb1ba720b8f08 100644 (file)
--- a/src/insets/InsetCommandParams.cpp
+++ b/src/insets/InsetCommandParams.cpp
@@ -5,7 +5,7 @@
  *
  * \author Angus Leeming
  * \author Georg Baum
- * \author Richard Heck
+ * \author Richard Kimberly Heck
  *
  * Full author contact details are available in file CREDITS.
  */
@@ -30,7 +30,6 @@
 
 #include "Buffer.h"
 #include "Encoding.h"
-#include "Lexer.h"
 
 #include "frontends/alert.h"
 
@@ -38,9 +37,9 @@
 #include "support/docstream.h"
 #include "support/ExceptionMessage.h"
 #include "support/gettext.h"
-#include "support/lstrings.h"
-
 #include "support/lassert.h"
+#include "support/Lexer.h"
+#include "support/lstrings.h"
 
 #include <algorithm>
 #include <functional>
@@ -322,7 +321,7 @@ void InsetCommandParams::Read(Lexer & lex, Buffer const * buffer)
                        preview_ = lex.getBool();
                        continue;
                }
-               if (info_.hasParam(token)) {
+               if (hasParam(token)) {
                        lex.next(true);
                        docstring data = lex.getDocString();
                        if (buffer && token == "filename") {
@@ -455,7 +454,21 @@ docstring InsetCommandParams::prepareCommand(OutputParams const & runparams,
        // LATEXIFY, ESCAPE and NONE are mutually exclusive
        if (handling & ParamInfo::HANDLING_LATEXIFY) {
                // First handle backslash
-               result = subst(command, from_ascii("\\"), from_ascii("\\textbackslash{}"));
+               // we cannot replace yet with \textbackslash{}
+               // as the braces would be erroneously escaped
+               // in the following routines ("\textbackslash\{\}").
+               // So create a unique placeholder which is replaced
+               // in the end.
+               docstring bs = from_ascii("@LyXBackslash@");
+               // We are super-careful and assure the placeholder
+               // does not exist in the string
+               for (int i = 0; ; ++i) {
+                       if (!contains(command, bs)) {
+                               result = subst(command, from_ascii("\\"), bs);
+                               break;
+                       }
+                       bs = from_ascii("@LyXBackslash") + i + '@';
+               }
                // Then get LaTeX macros
                pair<docstring, docstring> command_latexed =
                        runparams.encoding->latexString(result, runparams.dryrun);
@@ -493,6 +506,8 @@ docstring InsetCommandParams::prepareCommand(OutputParams const & runparams,
                                                        result.replace(pos, 1, backslash + chars_escape[k] + term);
                                }
                }
+               // set in real backslash now
+               result = subst(result, bs, from_ascii("\\textbackslash{}"));
        }
        else if (handling & ParamInfo::HANDLING_ESCAPE)
                result = escape(command);
@@ -553,28 +568,33 @@ docstring InsetCommandParams::prepareCommand(OutputParams const & runparams,
 }
 
 
-docstring InsetCommandParams::getCommand(OutputParams const & runparams) const
+docstring InsetCommandParams::getCommand(OutputParams const & runparams, bool starred, bool unhandled) const
 {
        docstring s = '\\' + from_ascii(cmdName_);
+       if (starred)
+               s += from_utf8("*");
        bool noparam = true;
        ParamInfo::const_iterator it  = info_.begin();
        ParamInfo::const_iterator end = info_.end();
        for (; it != end; ++it) {
                std::string const & name = it->name();
+               ParamInfo::ParamHandling handling = unhandled ?
+                                       ParamInfo::HANDLING_NONE
+                                     : it->handling();
                switch (it->type()) {
                case ParamInfo::LYX_INTERNAL:
                        break;
 
                case ParamInfo::LATEX_REQUIRED: {
                        docstring const data =
-                               prepareCommand(runparams, (*this)[name], it->handling());
+                               prepareCommand(runparams, (*this)[name], handling);
                        s += '{' + data + '}';
                        noparam = false;
                        break;
                }
                case ParamInfo::LATEX_OPTIONAL: {
                        docstring data =
-                               prepareCommand(runparams, (*this)[name], it->handling());
+                               prepareCommand(runparams, (*this)[name], handling);
                        if (!data.empty()) {
                                s += '[' + protectArgument(data) + ']';
                                noparam = false;
@@ -604,10 +624,24 @@ docstring InsetCommandParams::getFirstNonOptParam() const
 }
 
 
+bool InsetCommandParams::hasParam(std::string const & name) const
+{
+       return info_.hasParam(name);
+}
+
+
+docstring const & InsetCommandParams::getParamOr(std::string const & name, docstring const & defaultValue) const
+{
+       if (hasParam(name))
+               return (*this)[name];
+       return defaultValue;
+}
+
+
 docstring const & InsetCommandParams::operator[](string const & name) const
 {
        static const docstring dummy;
-       LASSERT(info_.hasParam(name), return dummy);
+       LASSERT(hasParam(name), return dummy);
        ParamMap::const_iterator data = params_.find(name);
        if (data == params_.end() || data->second.empty())
                return dummy;
@@ -620,7 +654,7 @@ docstring const & InsetCommandParams::operator[](string const & name) const
 
 docstring & InsetCommandParams::operator[](string const & name)
 {
-       LATTEST(info_.hasParam(name));
+       LATTEST(hasParam(name));
        // this will add the name in release mode
        ParamInfo::ParamData const & param = info_[name];
        if (param.ignore())