src/insets/insetcommandparams.C

   1 /**
   2  * \file insetcommandparams.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Angus Leeming
   7  * \author Georg Baum
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "insetcommandparams.h"
  15
  16 #include "debug.h"
  17 #include "lyxlex.h"
  18
  19 #include "support/lstrings.h"
  20
  21 #include <boost/assert.hpp>
  22
  23
  24 namespace lyx {
  25
  26 using support::findToken;
  27
  28 using std::string;
  29 using std::endl;
  30 using std::ostream;
  31
  32
  33 InsetCommandParams::InsetCommandParams(string const & name)
  34         : name_(name), preview_(false)
  35 {
  36         info_ = findInfo(name);
  37         BOOST_ASSERT(info_);
  38         params_.resize(info_->n);
  39 }
  40
  41
  42 InsetCommandParams::CommandInfo const *
  43 InsetCommandParams::findInfo(std::string const & name)
  44 {
  45         // No parameter may be named "preview", because that is a required
  46         // flag for all commands.
  47
  48         // InsetBibitem
  49         if (name == "bibitem") {
  50                 static const char * const paramnames[] = {"label", "key", ""};
  51                 static const bool isoptional[] = {true, false};
  52                 static const CommandInfo info = {2, paramnames, isoptional};
  53                 return &info;
  54         }
  55
  56         // InsetBibtex
  57         if (name == "bibtex") {
  58                 static const char * const paramnames[] =
  59                                 {"options", "btprint", "bibfiles", ""};
  60                 static const bool isoptional[] = {true, true, false};
  61                 static const CommandInfo info = {3, paramnames, isoptional};
  62                 return &info;
  63         }
  64
  65         // InsetCitation
  66         // FIXME: Use is_possible_cite_command() in
  67         // src/frontends/controllers/biblio.C, see comment in src/factory.C.
  68         if (name == "cite" || name == "citet" || name == "citep" || name == "citealt" ||
  69             name == "citealp" || name == "citeauthor" || name == "citeyear" ||
  70             name == "citeyearpar" || name == "citet*" || name == "citep*" ||
  71             name == "citealt*" || name == "citealp*" ||
  72             name == "citeauthor*" || name == "Citet" || name == "Citep" ||
  73             name == "Citealt" || name == "Citealp" || name == "Citeauthor" ||
  74             name == "Citet*" || name == "Citep*" || name == "Citealt*" ||
  75             name == "Citealp*" || name == "Citeauthor*" ||
  76             name == "citefield" || name == "citetitle" || name == "cite*") {
  77                 // standard cite does only take one argument if jurabib is
  78                 // not used, but jurabib extends this to two arguments, so
  79                 // we have to allow both here. InsetCitation takes care that
  80                 // LaTeX output is nevertheless correct.
  81                 static const char * const paramnames[] =
  82                                 {"after", "before", "key", ""};
  83                 static const bool isoptional[] = {true, true, false};
  84                 static const CommandInfo info = {3, paramnames, isoptional};
  85                 return &info;
  86         }
  87
  88         // InsetFloatlist
  89         if (name == "floatlist") {
  90                 static const char * const paramnames[] = {"type", ""};
  91                 static const bool isoptional[] = {false};
  92                 static const CommandInfo info = {1, paramnames, isoptional};
  93                 return &info;
  94         }
  95
  96         // InsetHfill
  97         if (name == "hfill") {
  98                 static const char * const paramnames[] = {""};
  99                 static const CommandInfo info = {0, paramnames, 0};
 100                 return &info;
 101         }
 102
 103         // InsetInclude
 104         if (name == "include" || name == "input" || name == "verbatiminput" ||
 105             name == "verbatiminput*") {
 106                 static const char * const paramnames[] = {"filename", ""};
 107                 static const bool isoptional[] = {false};
 108                 static const CommandInfo info = {1, paramnames, isoptional};
 109                 return &info;
 110         }
 111
 112         // InsetIndex, InsetPrintIndex, InsetLabel
 113         if (name == "index" || name == "printindex" || name == "label") {
 114                 static const char * const paramnames[] = {"name", ""};
 115                 static const bool isoptional[] = {false};
 116                 static const CommandInfo info = {1, paramnames, isoptional};
 117                 return &info;
 118         }
 119
 120         // InsetNomencl
 121         if (name == "nomenclature") {
 122                 static const char * const paramnames[] = {"prefix", "symbol", "description", ""};
 123                 static const bool isoptional[] = {true, false, false};
 124                 static const CommandInfo info = {3, paramnames, isoptional};
 125                 return &info;
 126         }
 127
 128         // InsetPrintNomencl
 129         if (name == "printnomenclature") {
 130                 static const char * const paramnames[] = {"labelwidth", ""};
 131                 static const bool isoptional[] = {true};
 132                 static const CommandInfo info = {1, paramnames, isoptional};
 133                 return &info;
 134         }
 135
 136         // InsetRef
 137         if (name == "eqref" || name == "pageref" || name == "vpageref" ||
 138             name == "vref" || name == "prettyref" || name == "ref") {
 139                 static const char * const paramnames[] =
 140                                 {"name", "reference", ""};
 141                 static const bool isoptional[] = {true, false};
 142                 static const CommandInfo info = {2, paramnames, isoptional};
 143                 return &info;
 144         }
 145
 146         // InsetTOC
 147         if (name == "tableofcontents") {
 148                 static const char * const paramnames[] = {"type", ""};
 149                 static const bool isoptional[] = {false};
 150                 static const CommandInfo info = {1, paramnames, isoptional};
 151                 return &info;
 152         }
 153
 154         // InsetUrl
 155         if (name == "htmlurl" || name == "url") {
 156                 static const char * const paramnames[] =
 157                                 {"name", "target", ""};
 158                 static const bool isoptional[] = {true, false};
 159                 static const CommandInfo info = {2, paramnames, isoptional};
 160                 return &info;
 161         }
 162
 163         return 0;
 164 }
 165
 166
 167 void InsetCommandParams::setCmdName(string const & name)
 168 {
 169         name_ = name;
 170         CommandInfo const * const info = findInfo(name);
 171         BOOST_ASSERT(info);
 172         ParamVector params(info->n);
 173         // Overtake parameters with the same name
 174         for (size_t i = 0; i < info_->n; ++i) {
 175                 int j = findToken(info->paramnames, info_->paramnames[i]);
 176                 if (j >= 0)
 177                         params[j] = params_[i];
 178         }
 179         info_ = info;
 180         std::swap(params, params_);
 181 }
 182
 183
 184 void InsetCommandParams::scanCommand(string const & cmd)
 185 {
 186         string tcmdname, toptions, tsecoptions, tcontents;
 187
 188         if (cmd.empty()) return;
 189
 190         enum { WS, CMDNAME, OPTION, SECOPTION, CONTENT } state = WS;
 191
 192         // Used to handle things like \command[foo[bar]]{foo{bar}}
 193         int nestdepth = 0;
 194
 195         for (string::size_type i = 0; i < cmd.length(); ++i) {
 196                 char const c = cmd[i];
 197                 if ((state == CMDNAME && c == ' ') ||
 198                     (state == CMDNAME && c == '[') ||
 199                     (state == CMDNAME && c == '{')) {
 200                         state = WS;
 201                 }
 202                 if ((state == OPTION  && c == ']') ||
 203                     (state == SECOPTION  && c == ']') ||
 204                     (state == CONTENT && c == '}')) {
 205                         if (nestdepth == 0) {
 206                                 state = WS;
 207                         } else {
 208                                 --nestdepth;
 209                         }
 210                 }
 211                 if ((state == OPTION  && c == '[') ||
 212                     (state == SECOPTION  && c == '[') ||
 213                     (state == CONTENT && c == '{')) {
 214                         ++nestdepth;
 215                 }
 216                 switch (state) {
 217                 case CMDNAME:   tcmdname += c; break;
 218                 case OPTION:    toptions += c; break;
 219                 case SECOPTION: tsecoptions += c; break;
 220                 case CONTENT:   tcontents += c; break;
 221                 case WS: {
 222                         char const b = i? cmd[i-1]: 0;
 223                         if (c == '\\') {
 224                                 state = CMDNAME;
 225                         } else if (c == '[' && b != ']') {
 226                                 state = OPTION;
 227                                 nestdepth = 0; // Just to be sure
 228                         } else if (c == '[' && b == ']') {
 229                                 state = SECOPTION;
 230                                 nestdepth = 0; // Just to be sure
 231                         } else if (c == '{') {
 232                                 state = CONTENT;
 233                                 nestdepth = 0; // Just to be sure
 234                         }
 235                         break;
 236                 }
 237                 }
 238         }
 239
 240         // Don't mess with this.
 241         if (!tcmdname.empty())  setCmdName(tcmdname);
 242         if (!toptions.empty())  setOptions(toptions);
 243         if (!tsecoptions.empty())  setSecOptions(tsecoptions);
 244         if (!tcontents.empty()) setContents(tcontents);
 245
 246         LYXERR(Debug::PARSER) << "Command <" <<  cmd
 247                 << "> == <" << to_utf8(getCommand())
 248                 << "> == <" << getCmdName()
 249                 << '|' << getContents()
 250                 << '|' << getOptions()
 251                 << '|' << getSecOptions() << '>' << endl;
 252 }
 253
 254
 255 void InsetCommandParams::read(LyXLex & lex)
 256 {
 257         if (lex.isOK()) {
 258                 lex.next();
 259                 name_ = lex.getString();
 260                 info_ = findInfo(name_);
 261                 if (!info_)
 262                         lex.printError("InsetCommand: Unknown inset name `$$Token'");
 263         }
 264
 265         string token;
 266         while (lex.isOK()) {
 267                 lex.next();
 268                 token = lex.getString();
 269                 if (token == "\\end_inset")
 270                         break;
 271                 // FIXME Why is preview_ read but not written?
 272                 if (token == "preview") {
 273                         lex.next();
 274                         preview_ = lex.getBool();
 275                         continue;
 276                 }
 277                 int const i = findToken(info_->paramnames, token);
 278                 if (i >= 0) {
 279                         lex.next(true);
 280                         params_[i] = lex.getDocString();
 281                 } else
 282                         lex.printError("Unknown parameter name `$$Token' for command " + name_);
 283         }
 284         if (token != "\\end_inset") {
 285                 lex.printError("Missing \\end_inset at this point. "
 286                                "Read: `$$Token'");
 287         }
 288 }
 289
 290
 291 void InsetCommandParams::write(ostream & os) const
 292 {
 293         os << "LatexCommand " << name_ << '\n';
 294         for (size_t i = 0; i < info_->n; ++i)
 295                 if (!params_[i].empty())
 296                         // FIXME UNICODE
 297                         os << info_->paramnames[i] << ' '
 298                            << LyXLex::quoteString(to_utf8(params_[i]))
 299                            << '\n';
 300 }
 301
 302
 303 docstring const InsetCommandParams::getCommand() const
 304 {
 305         docstring s = '\\' + from_ascii(name_);
 306         bool noparam = true;
 307         for (size_t i = 0; i < info_->n; ++i) {
 308                 if (info_->optional[i]) {
 309                         if (params_[i].empty()) {
 310                                 // We need to write this parameter even if
 311                                 // it is empty if nonempty optional parameters
 312                                 // follow before the next required parameter.
 313                                 for (size_t j = i + 1; j < info_->n; ++j) {
 314                                         if (!info_->optional[j])
 315                                                 break;
 316                                         if (!params_[j].empty()) {
 317                                                 s += "[]";
 318                                                 noparam = false;
 319                                                 break;
 320                                         }
 321                                 }
 322                         } else {
 323                                 s += '[' + params_[i] + ']';
 324                                 noparam = false;
 325                         }
 326                 } else {
 327                         s += '{' + params_[i] + '}';
 328                         noparam = false;
 329                 }
 330         }
 331         if (noparam)
 332                 // Make sure that following stuff does not change the
 333                 // command name.
 334                 s += "{}";
 335         return s;
 336 }
 337
 338
 339 std::string const InsetCommandParams::getOptions() const
 340 {
 341         for (size_t i = 0; i < info_->n; ++i)
 342                 if (info_->optional[i])
 343                         return to_utf8(params_[i]);
 344         lyxerr << "Programming error: get nonexisting option in "
 345                << name_ << " inset." << endl;;
 346         return string();
 347 }
 348
 349
 350 std::string const InsetCommandParams::getSecOptions() const
 351 {
 352         bool first = true;
 353         for (size_t i = 0; i < info_->n; ++i)
 354                 if (info_->optional[i]) {
 355                         if (first)
 356                                 first = false;
 357                         else
 358                                 return to_utf8(params_[i]);
 359                 }
 360         // Happens in InsetCitation
 361         lyxerr << "Programming error: get nonexisting second option in "
 362                << name_ << " inset." << endl;;
 363         return string();
 364 }
 365
 366
 367 std::string const InsetCommandParams::getContents() const
 368 {
 369         for (size_t i = 0; i < info_->n; ++i)
 370                 if (!info_->optional[i])
 371                         return to_utf8(params_[i]);
 372         BOOST_ASSERT(false);
 373         return string();
 374 }
 375
 376
 377 void InsetCommandParams::setOptions(std::string const & o)
 378 {
 379         for (size_t i = 0; i < info_->n; ++i)
 380                 if (info_->optional[i]) {
 381                         params_[i] = from_utf8(o);
 382                         return;
 383                 }
 384         lyxerr << "Programming error: set nonexisting option in "
 385                << name_ << " inset." << endl;;
 386 }
 387
 388
 389 void InsetCommandParams::setSecOptions(std::string const & s)
 390 {
 391         bool first = true;
 392         for (size_t i = 0; i < info_->n; ++i)
 393                 if (info_->optional[i]) {
 394                         if (first)
 395                                 first = false;
 396                         else {
 397                                 params_[i] = from_utf8(s);
 398                                 return;
 399                         }
 400                 }
 401         // Happens in InsetCitation
 402         lyxerr << "Programming error: set nonexisting second option in "
 403                << name_ << " inset." << endl;;
 404 }
 405
 406
 407 void InsetCommandParams::setContents(std::string const & c)
 408 {
 409         for (size_t i = 0; i < info_->n; ++i)
 410                 if (!info_->optional[i]) {
 411                         params_[i] = from_utf8(c);
 412                         return;
 413                 }
 414         BOOST_ASSERT(false);
 415 }
 416
 417
 418 docstring const & InsetCommandParams::operator[](string const & name) const
 419 {
 420         int const i = findToken(info_->paramnames, name);
 421         BOOST_ASSERT(i >= 0);
 422         return params_[i];
 423 }
 424
 425
 426 docstring & InsetCommandParams::operator[](string const & name)
 427 {
 428         int const i = findToken(info_->paramnames, name);
 429         BOOST_ASSERT(i >= 0);
 430         return params_[i];
 431 }
 432
 433
 434 void InsetCommandParams::clear()
 435 {
 436         for (size_t i = 0; i < info_->n; ++i)
 437                 params_[i].clear();
 438 }
 439
 440
 441 bool operator==(InsetCommandParams const & o1,
 442                 InsetCommandParams const & o2)
 443 {
 444         return o1.name_ == o2.name_ &&
 445                o1.info_ == o2.info_ &&
 446                o1.params_ == o2.params_ &&
 447                o1.preview_ == o2.preview_;
 448 }
 449
 450
 451 bool operator!=(InsetCommandParams const & o1,
 452                 InsetCommandParams const & o2)
 453 {
 454         return !(o1 == o2);
 455 }
 456
 457
 458 } // namespace lyx