src/gromacs/selection/parsetree.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2009,2010,2011,2012, by the GROMACS development team, led by
   5  * David van der Spoel, Berk Hess, Erik Lindahl, and including many
   6  * others, as listed in the AUTHORS file in the top-level source
   7  * directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  * \brief
  37  * Implements functions in parsetree.h.
  38  *
  39  * \author Teemu Murtola <teemu.murtola@gmail.com>
  40  * \ingroup module_selection
  41  */
  42 /*! \internal
  43  * \page page_module_selection_parser Selection parsing
  44  *
  45  * The selection parser is implemented in the following files:
  46  *  - scanner.l:
  47  *    Tokenizer implemented using Flex, splits the input into tokens
  48  *    (scanner.c and scanner_flex.h are generated from this file).
  49  *  - scanner.h, scanner_internal.h, scanner_internal.cpp:
  50  *    Helper functions for scanner.l and for interfacing between
  51  *    scanner.l and parser.y. Functions in scanner_internal.h are only
  52  *    used from scanner.l, while scanner.h is used from the parser.
  53  *  - symrec.h, symrec.cpp:
  54  *    Functions used by the tokenizer to handle the symbol table, i.e.,
  55  *    the recognized keywords. Some basic keywords are hardcoded into
  56  *    scanner.l, but all method and variable references go through the
  57  *    symbol table, as do position evaluation keywords.
  58  *  - parser.y:
  59  *    Semantic rules for parsing the grammar
  60  *    (parser.cpp and parser.h are generated from this file by Bison).
  61  *  - parsetree.h, parsetree.cpp:
  62  *    Functions called from actions in parser.y to construct the
  63  *    evaluation elements corresponding to different grammar elements.
  64  *  - params.c:
  65  *    Defines a function that processes the parameters of selection
  66  *    methods and initializes the children of the method element.
  67  *  - selectioncollection.h, selectioncollection.cpp:
  68  *    These files define the high-level public interface to the parser
  69  *    through SelectionCollection::parseFromStdin(),
  70  *    SelectionCollection::parseFromFile() and
  71  *    SelectionCollection::parseFromString().
  72  *
  73  * The basic control flow in the parser is as follows: when a parser function
  74  * in SelectionCollection gets called, it performs some
  75  * initialization, and then calls the _gmx_sel_yyparse() function generated
  76  * by Bison. This function then calls _gmx_sel_yylex() to repeatedly read
  77  * tokens from the input (more complex tasks related to token recognition
  78  * and bookkeeping are done by functions in scanner_internal.cpp) and uses the
  79  * grammar rules to decide what to do with them. Whenever a grammar rule
  80  * matches, a corresponding function in parsetree.cpp is called to construct
  81  * either a temporary representation for the object or a
  82  * gmx::SelectionTreeElement object
  83  * (some simple rules are handled internally in parser.y).
  84  * When a complete selection has been parsed, the functions in parsetree.cpp
  85  * also take care of updating the ::gmx_ana_selcollection_t structure
  86  * appropriately.
  87  *
  88  * The rest of this page describes the resulting gmx::SelectionTreeElement
  89  * object tree.
  90  * Before the selections can be evaluated, this tree needs to be passed to
  91  * the selection compiler, which is described on a separate page:
  92  * \ref page_module_selection_compiler
  93  *
  94  *
  95  * \section selparser_tree Element tree constructed by the parser
  96  *
  97  * The parser initializes the following fields in all selection elements:
  98  * gmx::SelectionTreeElement::name, gmx::SelectionTreeElement::type,
  99  * gmx::SelectionTreeElement::v\c .type,
 100  * gmx::SelectionTreeElement::flags, gmx::SelectionTreeElement::child, and
 101  * gmx::SelectionTreeElement::next.
 102  * Some other fields are also initialized for particular element types as
 103  * discussed below.
 104  * Fields that are not initialized are set to zero, NULL, or other similar
 105  * value.
 106  *
 107  *
 108  * \subsection selparser_tree_root Root elements
 109  *
 110  * The parser creates a \ref SEL_ROOT selection element for each variable
 111  * assignment and each selection. However, there are two exceptions that do
 112  * not result in a \ref SEL_ROOT element (in these cases, only the symbol
 113  * table is modified):
 114  *  - Variable assignments that assign a variable to another variable.
 115  *  - Variable assignments that assign a non-group constant.
 116  *  .
 117  * The \ref SEL_ROOT elements are linked together in a chain in the same order
 118  * as in the input.
 119  *
 120  * The children of the \ref SEL_ROOT elements can be used to distinguish
 121  * the two types of root elements from each other:
 122  *  - For variable assignments, the first and only child is always
 123  *    a \ref SEL_SUBEXPR element.
 124  *  - For selections, the first child is a \ref SEL_EXPRESSION or a
 125  *    \ref SEL_MODIFIER element that evaluates the final positions (if the
 126  *    selection defines a constant position, the child is a \ref SEL_CONST).
 127  *    The rest of the children are \ref SEL_MODIFIER elements with
 128  *    \ref NO_VALUE, in the order given by the user.
 129  *  .
 130  * The name of the selection/variable is stored in
 131  * gmx::SelectionTreeElement::cgrp\c .name.
 132  * It is set to either the name provided by the user or the selection string
 133  * for selections not explicitly named by the user.
 134  * \ref SEL_ROOT or \ref SEL_SUBEXPR elements do not appear anywhere else.
 135  *
 136  *
 137  * \subsection selparser_tree_const Constant elements
 138  *
 139  * \ref SEL_CONST elements are created for every constant that is required
 140  * for later evaluation.
 141  * Currently, \ref SEL_CONST elements can be present for
 142  *  - selections that consist of a constant position,
 143  *  - \ref GROUP_VALUE method parameters if provided using external index
 144  *    groups,
 145  *  .
 146  * For group-valued elements, the value is stored in
 147  * gmx::SelectionTreeElement::cgrp; other types of values are stored in
 148  * gmx::SelectionTreeElement::v.
 149  * Constants that appear as parameters for selection methods are not present
 150  * in the selection tree unless they have \ref GROUP_VALUE.
 151  * \ref SEL_CONST elements have no children.
 152  *
 153  *
 154  * \subsection selparser_tree_method Method evaluation elements
 155  *
 156  * \ref SEL_EXPRESSION and \ref SEL_MODIFIER elements are treated very
 157  * similarly. The \c gmx_ana_selmethod_t structure corresponding to the
 158  * evaluation method is in gmx::SelectionTreeElement::method, and the method
 159  * data in gmx::SelectionTreeElement::mdata has been allocated using
 160  * sel_datafunc().
 161  * If a non-standard reference position type was set,
 162  * gmx::SelectionTreeElement::pc has also been created, but only the type has
 163  * been set.
 164  * All children of these elements are of the type \ref SEL_SUBEXPRREF, and
 165  * each describes a selection that needs to be evaluated to obtain a value
 166  * for one parameter of the method.
 167  * No children are present for parameters that were given a constant
 168  * non-\ref GROUP_VALUE value.
 169  * The children are sorted in the order in which the parameters appear in the
 170  * \ref gmx_ana_selmethod_t structure.
 171  *
 172  * In addition to actual selection keywords, \ref SEL_EXPRESSION elements
 173  * are used internally to implement numerical comparisons (e.g., "x < 5")
 174  * and keyword matching (e.g., "resnr 1 to 3" or "name CA").
 175  *
 176  *
 177  * \subsection selparser_tree_subexpr Subexpression elements
 178  *
 179  * \ref SEL_SUBEXPR elements only appear for variables, as described above.
 180  * gmx::SelectionTreeElement::name points to the name of the variable (from the
 181  * \ref SEL_ROOT element).
 182  * The element always has exactly one child, which represents the value of
 183  * the variable.
 184  *
 185  * \ref SEL_SUBEXPRREF elements are used for two purposes:
 186  *  - Variable references that need to be evaluated (i.e., there is a
 187  *    \ref SEL_SUBEXPR element for the variable) are represented using
 188  *    \ref SEL_SUBEXPRREF elements.
 189  *    In this case, gmx::SelectionTreeElement::param is NULL, and the first and
 190  *    only child of the element is the \ref SEL_SUBEXPR element of the
 191  *    variable.
 192  *    Such references can appear anywhere where the variable value
 193  *    (the child of the \ref SEL_SUBEXPR element) would be valid.
 194  *  - Children of \ref SEL_EXPRESSION and \ref SEL_MODIFIER elements are
 195  *    always of this type. For these elements, gmx::SelectionTreeElement::param
 196  *    is initialized to point to the parameter that receives the value from
 197  *    the expression.
 198  *    Each such element has exactly one child, which can be of any type;
 199  *    the \ref SEL_SUBEXPR element of a variable is used if the value comes
 200  *    from a variable, otherwise the child type is not \ref SEL_SUBEXPR.
 201  *
 202  *
 203  * \subsection selparser_tree_bool Boolean elements
 204  *
 205  * One \ref SEL_BOOLEAN element is created for each boolean keyword in the
 206  * input, and the tree structure represents the evaluation order.
 207  * The gmx::SelectionTreeElement::boolt type gives the type of the operation.
 208  * Each element has exactly two children (one for \ref BOOL_NOT elements),
 209  * which are in the order given in the input.
 210  * The children always have \ref GROUP_VALUE, but different element types
 211  * are possible.
 212  *
 213  *
 214  * \subsection selparser_tree_arith Arithmetic elements
 215  *
 216  * One \ref SEL_ARITHMETIC element is created for each arithmetic operation in
 217  * the input, and the tree structure represents the evaluation order.
 218  * The gmx::SelectionTreeElement::optype type gives the name of the operation.
 219  * Each element has exactly two children (one for unary negation elements),
 220  * which are in the order given in the input.
 221  */
 222 #include <stdio.h>
 223 #include <stdarg.h>
 224
 225 #include <boost/exception_ptr.hpp>
 226 #include <boost/shared_ptr.hpp>
 227
 228 #include "gromacs/legacyheaders/futil.h"
 229 #include "gromacs/legacyheaders/smalloc.h"
 230 #include "gromacs/legacyheaders/string2.h"
 231
 232 #include "gromacs/onlinehelp/helpmanager.h"
 233 #include "gromacs/onlinehelp/helpwritercontext.h"
 234 #include "gromacs/selection/poscalc.h"
 235 #include "gromacs/selection/selection.h"
 236 #include "gromacs/selection/selmethod.h"
 237 #include "gromacs/utility/exceptions.h"
 238 #include "gromacs/utility/file.h"
 239 #include "gromacs/utility/messagestringcollector.h"
 240
 241 #include "keywords.h"
 242 #include "parsetree.h"
 243 #include "selectioncollection-impl.h"
 244 #include "selelem.h"
 245 #include "selhelp.h"
 246 #include "symrec.h"
 247
 248 #include "scanner.h"
 249
 250 using gmx::SelectionParserValue;
 251 using gmx::SelectionParserValueList;
 252 using gmx::SelectionParserValueListPointer;
 253 using gmx::SelectionParserParameter;
 254 using gmx::SelectionParserParameterList;
 255 using gmx::SelectionParserParameterListPointer;
 256 using gmx::SelectionParserValue;
 257 using gmx::SelectionTreeElement;
 258 using gmx::SelectionTreeElementPointer;
 259
 260 void
 261 _gmx_selparser_error(yyscan_t scanner, const char *fmt, ...)
 262 {
 263     gmx::MessageStringCollector *errors = _gmx_sel_lexer_error_reporter(scanner);
 264     // FIXME: Use an arbitrary length buffer.
 265     char    buf[1024];
 266     va_list ap;
 267     va_start(ap, fmt);
 268     vsprintf(buf, fmt, ap);
 269     va_end(ap);
 270     errors->append(buf);
 271 }
 272
 273 bool
 274 _gmx_selparser_handle_exception(yyscan_t scanner, const std::exception & /*ex*/)
 275 {
 276     _gmx_sel_lexer_set_exception(scanner, boost::current_exception());
 277     return false;
 278 }
 279
 280 namespace gmx
 281 {
 282
 283 /********************************************************************
 284  * SelectionParserValue
 285  */
 286
 287 SelectionParserValue::SelectionParserValue(e_selvalue_t type)
 288     : type(type)
 289 {
 290     memset(&u, 0, sizeof(u));
 291 }
 292
 293 SelectionParserValue::SelectionParserValue(
 294         const SelectionTreeElementPointer &expr)
 295     : type(expr->v.type), expr(expr)
 296 {
 297     memset(&u, 0, sizeof(u));
 298 }
 299
 300 /********************************************************************
 301  * SelectionParserParameter
 302  */
 303
 304 SelectionParserParameter::SelectionParserParameter(
 305         const char                     *name,
 306         SelectionParserValueListPointer values)
 307     : name_(name != NULL ? name : ""),
 308       values_(values ? move(values)
 309               : SelectionParserValueListPointer(new SelectionParserValueList))
 310 {
 311 }
 312
 313 } // namespace gmx
 314
 315 /*!
 316  * \param[in,out] sel  Root of the selection element tree to initialize.
 317  * \param[in]     scanner Scanner data structure.
 318  * \returns       0 on success, an error code on error.
 319  *
 320  * Propagates the \ref SEL_DYNAMIC flag from the children of \p sel to \p sel
 321  * (if any child of \p sel is dynamic, \p sel is also marked as such).
 322  * The \ref SEL_DYNAMIC flag is also set for \ref SEL_EXPRESSION elements with
 323  * a dynamic method.
 324  * Also, sets one of the \ref SEL_SINGLEVAL, \ref SEL_ATOMVAL, or
 325  * \ref SEL_VARNUMVAL flags, either based on the children or on the type of
 326  * the selection method.
 327  * If the types of the children conflict, an error is returned.
 328  *
 329  * The flags of the children of \p sel are also updated if not done earlier.
 330  * The flags are initialized only once for any element; if \ref SEL_FLAGSSET
 331  * is set for an element, the function returns immediately, and the recursive
 332  * operation does not descend beyond such elements.
 333  */
 334 void
 335 _gmx_selelem_update_flags(const SelectionTreeElementPointer &sel,
 336                           yyscan_t                           scanner)
 337 {
 338     bool                bUseChildType = false;
 339     bool                bOnlySingleChildren;
 340
 341     /* Return if the flags have already been set */
 342     if (sel->flags & SEL_FLAGSSET)
 343     {
 344         return;
 345     }
 346     /* Set the flags based on the current element type */
 347     switch (sel->type)
 348     {
 349         case SEL_CONST:
 350         case SEL_GROUPREF:
 351             sel->flags   |= SEL_SINGLEVAL;
 352             bUseChildType = false;
 353             break;
 354
 355         case SEL_EXPRESSION:
 356             if (sel->u.expr.method->flags & SMETH_DYNAMIC)
 357             {
 358                 sel->flags |= SEL_DYNAMIC;
 359             }
 360             if (sel->u.expr.method->flags & SMETH_SINGLEVAL)
 361             {
 362                 sel->flags |= SEL_SINGLEVAL;
 363             }
 364             else if (sel->u.expr.method->flags & SMETH_VARNUMVAL)
 365             {
 366                 sel->flags |= SEL_VARNUMVAL;
 367             }
 368             else
 369             {
 370                 sel->flags |= SEL_ATOMVAL;
 371             }
 372             bUseChildType = false;
 373             break;
 374
 375         case SEL_ARITHMETIC:
 376             sel->flags   |= SEL_ATOMVAL;
 377             bUseChildType = false;
 378             break;
 379
 380         case SEL_MODIFIER:
 381             if (sel->v.type != NO_VALUE)
 382             {
 383                 sel->flags |= SEL_VARNUMVAL;
 384             }
 385             bUseChildType = false;
 386             break;
 387
 388         case SEL_ROOT:
 389             bUseChildType = false;
 390             break;
 391
 392         case SEL_BOOLEAN:
 393         case SEL_SUBEXPR:
 394         case SEL_SUBEXPRREF:
 395             bUseChildType = true;
 396             break;
 397     }
 398     /* Loop through children to propagate their flags upwards */
 399     bOnlySingleChildren = true;
 400     SelectionTreeElementPointer child = sel->child;
 401     while (child)
 402     {
 403         /* Update the child */
 404         _gmx_selelem_update_flags(child, scanner);
 405         /* Propagate the dynamic flag */
 406         sel->flags |= (child->flags & SEL_DYNAMIC);
 407         /* Propagate the type flag if necessary and check for problems */
 408         if (bUseChildType)
 409         {
 410             if ((sel->flags & SEL_VALTYPEMASK)
 411                 && !(sel->flags & child->flags & SEL_VALTYPEMASK))
 412             {
 413                 _gmx_selparser_error(scanner, "invalid combination of selection expressions");
 414                 // FIXME: Use an exception.
 415                 return;
 416             }
 417             sel->flags |= (child->flags & SEL_VALTYPEMASK);
 418         }
 419         if (!(child->flags & SEL_SINGLEVAL))
 420         {
 421             bOnlySingleChildren = false;
 422         }
 423
 424         child = child->next;
 425     }
 426     /* For arithmetic expressions consisting only of single values,
 427      * the result is also a single value. */
 428     if (sel->type == SEL_ARITHMETIC && bOnlySingleChildren)
 429     {
 430         sel->flags = (sel->flags & ~SEL_VALTYPEMASK) | SEL_SINGLEVAL;
 431     }
 432     /* For root elements, the type should be propagated here, after the
 433      * children have been updated. */
 434     if (sel->type == SEL_ROOT)
 435     {
 436         GMX_ASSERT(sel->child, "Root elements should always have a child");
 437         sel->flags |= (sel->child->flags & SEL_VALTYPEMASK);
 438     }
 439     /* Mark that the flags are set */
 440     sel->flags |= SEL_FLAGSSET;
 441 }
 442
 443 /*!
 444  * \param[in,out] sel    Selection element to initialize.
 445  * \param[in]     scanner Scanner data structure.
 446  *
 447  * A deep copy of the parameters is made to allow several
 448  * expressions with the same method to coexist peacefully.
 449  * Calls sel_datafunc() if one is specified for the method.
 450  */
 451 void
 452 _gmx_selelem_init_method_params(const SelectionTreeElementPointer &sel,
 453                                 yyscan_t                           scanner)
 454 {
 455     int                 nparams;
 456     gmx_ana_selparam_t *orgparam;
 457     gmx_ana_selparam_t *param;
 458     int                 i;
 459     void               *mdata;
 460
 461     nparams   = sel->u.expr.method->nparams;
 462     orgparam  = sel->u.expr.method->param;
 463     snew(param, nparams);
 464     memcpy(param, orgparam, nparams*sizeof(gmx_ana_selparam_t));
 465     for (i = 0; i < nparams; ++i)
 466     {
 467         param[i].flags &= ~SPAR_SET;
 468         _gmx_selvalue_setstore(&param[i].val, NULL);
 469         if (param[i].flags & SPAR_VARNUM)
 470         {
 471             param[i].val.nr = -1;
 472         }
 473         /* Duplicate the enum value array if it is given statically */
 474         if ((param[i].flags & SPAR_ENUMVAL) && orgparam[i].val.u.ptr != NULL)
 475         {
 476             int n;
 477
 478             /* Count the values */
 479             n = 1;
 480             while (orgparam[i].val.u.s[n] != NULL)
 481             {
 482                 ++n;
 483             }
 484             _gmx_selvalue_reserve(&param[i].val, n+1);
 485             memcpy(param[i].val.u.s, orgparam[i].val.u.s,
 486                    (n+1)*sizeof(param[i].val.u.s[0]));
 487         }
 488     }
 489     mdata = NULL;
 490     if (sel->u.expr.method->init_data)
 491     {
 492         mdata = sel->u.expr.method->init_data(nparams, param);
 493     }
 494     if (sel->u.expr.method->set_poscoll)
 495     {
 496         gmx_ana_selcollection_t *sc = _gmx_sel_lexer_selcollection(scanner);
 497
 498         sel->u.expr.method->set_poscoll(&sc->pcc, mdata);
 499     }
 500     /* Store the values */
 501     sel->u.expr.method->param = param;
 502     sel->u.expr.mdata         = mdata;
 503 }
 504
 505 /*!
 506  * \param[in,out] sel    Selection element to initialize.
 507  * \param[in]     method Selection method to set.
 508  * \param[in]     scanner Scanner data structure.
 509  *
 510  * Makes a copy of \p method and stores it in \p sel->u.expr.method,
 511  * and calls _gmx_selelem_init_method_params();
 512  */
 513 void
 514 _gmx_selelem_set_method(const SelectionTreeElementPointer &sel,
 515                         gmx_ana_selmethod_t               *method,
 516                         yyscan_t                           scanner)
 517 {
 518     _gmx_selelem_set_vtype(sel, method->type);
 519     sel->setName(method->name);
 520     snew(sel->u.expr.method, 1);
 521     memcpy(sel->u.expr.method, method, sizeof(gmx_ana_selmethod_t));
 522     _gmx_selelem_init_method_params(sel, scanner);
 523 }
 524
 525 /*! \brief
 526  * Initializes the reference position calculation for a \ref SEL_EXPRESSION
 527  * element.
 528  *
 529  * \param[in,out] pcc    Position calculation collection to use.
 530  * \param[in,out] sel    Selection element to initialize.
 531  * \param[in]     rpost  Reference position type to use (NULL = default).
 532  * \param[in]     scanner Scanner data structure.
 533  * \returns       0 on success, a non-zero error code on error.
 534  */
 535 static void
 536 set_refpos_type(gmx::PositionCalculationCollection *pcc,
 537                 const SelectionTreeElementPointer &sel,
 538                 const char *rpost, yyscan_t scanner)
 539 {
 540     if (!rpost)
 541     {
 542         return;
 543     }
 544
 545     if (sel->u.expr.method->pupdate)
 546     {
 547         /* By default, use whole residues/molecules. */
 548         sel->u.expr.pc
 549             = pcc->createCalculationFromEnum(rpost, POS_COMPLWHOLE);
 550     }
 551     else
 552     {
 553         // TODO: Should this be treated as a real error?
 554         _gmx_selparser_error(scanner, "modifier '%s' is not applicable for '%s'",
 555                              rpost, sel->u.expr.method->name);
 556     }
 557 }
 558
 559 /*!
 560  * \param[in]  left    Selection element for the left hand side.
 561  * \param[in]  right   Selection element for the right hand side.
 562  * \param[in]  op      String representation of the operator.
 563  * \param[in]  scanner Scanner data structure.
 564  * \returns    The created selection element.
 565  *
 566  * This function handles the creation of a gmx::SelectionTreeElement object for
 567  * arithmetic expressions.
 568  */
 569 SelectionTreeElementPointer
 570 _gmx_sel_init_arithmetic(const SelectionTreeElementPointer &left,
 571                          const SelectionTreeElementPointer &right,
 572                          char op, yyscan_t scanner)
 573 {
 574     SelectionTreeElementPointer sel(new SelectionTreeElement(SEL_ARITHMETIC));
 575     sel->v.type        = REAL_VALUE;
 576     switch (op)
 577     {
 578         case '+': sel->u.arith.type = ARITH_PLUS; break;
 579         case '-': sel->u.arith.type = (right ? ARITH_MINUS : ARITH_NEG); break;
 580         case '*': sel->u.arith.type = ARITH_MULT; break;
 581         case '/': sel->u.arith.type = ARITH_DIV;  break;
 582         case '^': sel->u.arith.type = ARITH_EXP;  break;
 583     }
 584     char               buf[2];
 585     buf[0] = op;
 586     buf[1] = 0;
 587     sel->setName(buf);
 588     sel->u.arith.opstr = strdup(buf);
 589     sel->child         = left;
 590     sel->child->next   = right;
 591     return sel;
 592 }
 593
 594 /*!
 595  * \param[in]  left   Selection element for the left hand side.
 596  * \param[in]  right  Selection element for the right hand side.
 597  * \param[in]  cmpop  String representation of the comparison operator.
 598  * \param[in]  scanner Scanner data structure.
 599  * \returns    The created selection element.
 600  *
 601  * This function handles the creation of a gmx::SelectionTreeElement object for
 602  * comparison expressions.
 603  */
 604 SelectionTreeElementPointer
 605 _gmx_sel_init_comparison(const SelectionTreeElementPointer &left,
 606                          const SelectionTreeElementPointer &right,
 607                          const char *cmpop, yyscan_t scanner)
 608 {
 609     gmx::MessageStringCollector *errors = _gmx_sel_lexer_error_reporter(scanner);
 610     gmx::MessageStringContext    context(errors, "In comparison initialization");
 611
 612     SelectionTreeElementPointer  sel(new SelectionTreeElement(SEL_EXPRESSION));
 613     _gmx_selelem_set_method(sel, &sm_compare, scanner);
 614
 615     SelectionParserParameterList params;
 616     const char                  *name;
 617     // Create the parameter for the left expression.
 618     name  = left->v.type == INT_VALUE ? "int1" : "real1";
 619     params.push_back(SelectionParserParameter::createFromExpression(name, left));
 620     // Create the parameter for the right expression.
 621     name  = right->v.type == INT_VALUE ? "int2" : "real2";
 622     params.push_back(SelectionParserParameter::createFromExpression(name, right));
 623     // Create the parameter for the operator.
 624     params.push_back(
 625             SelectionParserParameter::create(
 626                     "op", SelectionParserValue::createString(cmpop)));
 627     if (!_gmx_sel_parse_params(params, sel->u.expr.method->nparams,
 628                                sel->u.expr.method->param, sel, scanner))
 629     {
 630         return SelectionTreeElementPointer();
 631     }
 632
 633     return sel;
 634 }
 635
 636 /*! \brief
 637  * Implementation method for keyword expression creation.
 638  *
 639  * \param[in]  method Method to use.
 640  * \param[in]  matchType String matching type (only used if \p method is
 641  *      a string keyword and \p args is not empty.
 642  * \param[in]  args   Pointer to the first argument.
 643  * \param[in]  rpost  Reference position type to use (NULL = default).
 644  * \param[in]  scanner Scanner data structure.
 645  * \returns    The created selection element.
 646  *
 647  * This function handles the creation of a gmx::SelectionTreeElement object for
 648  * selection methods that do not take parameters.
 649  */
 650 static SelectionTreeElementPointer
 651 init_keyword_internal(gmx_ana_selmethod_t *method,
 652                       gmx::SelectionStringMatchType matchType,
 653                       SelectionParserValueListPointer args,
 654                       const char *rpost, yyscan_t scanner)
 655 {
 656     gmx_ana_selcollection_t     *sc = _gmx_sel_lexer_selcollection(scanner);
 657
 658     gmx::MessageStringCollector *errors = _gmx_sel_lexer_error_reporter(scanner);
 659     char  buf[128];
 660     sprintf(buf, "In keyword '%s'", method->name);
 661     gmx::MessageStringContext  context(errors, buf);
 662
 663     if (method->nparams > 0)
 664     {
 665         // TODO: Would assert be better?
 666         GMX_THROW(gmx::InternalError(
 667                           "Keyword initialization called with non-keyword method"));
 668     }
 669
 670     SelectionTreeElementPointer root(new SelectionTreeElement(SEL_EXPRESSION));
 671     SelectionTreeElementPointer child = root;
 672     _gmx_selelem_set_method(child, method, scanner);
 673
 674     /* Initialize the evaluation of keyword matching if values are provided */
 675     if (args)
 676     {
 677         gmx_ana_selmethod_t *kwmethod;
 678         switch (method->type)
 679         {
 680             case INT_VALUE:  kwmethod = &sm_keyword_int;  break;
 681             case REAL_VALUE: kwmethod = &sm_keyword_real; break;
 682             case STR_VALUE:  kwmethod = &sm_keyword_str;  break;
 683             default:
 684                 GMX_THROW(gmx::InternalError(
 685                                   "Unknown type for keyword selection"));
 686         }
 687         /* Initialize the selection element */
 688         root.reset(new SelectionTreeElement(SEL_EXPRESSION));
 689         _gmx_selelem_set_method(root, kwmethod, scanner);
 690         if (method->type == STR_VALUE)
 691         {
 692             _gmx_selelem_set_kwstr_match_type(root, matchType);
 693         }
 694         SelectionParserParameterList params;
 695         params.push_back(
 696                 SelectionParserParameter::createFromExpression(NULL, child));
 697         params.push_back(SelectionParserParameter::create(NULL, move(args)));
 698         if (!_gmx_sel_parse_params(params, root->u.expr.method->nparams,
 699                                    root->u.expr.method->param, root, scanner))
 700         {
 701             return SelectionTreeElementPointer();
 702         }
 703     }
 704     set_refpos_type(&sc->pcc, child, rpost, scanner);
 705
 706     return root;
 707 }
 708
 709 /*!
 710  * \param[in]  method Method to use.
 711  * \param[in]  args   Pointer to the first argument.
 712  * \param[in]  rpost  Reference position type to use (NULL = default).
 713  * \param[in]  scanner Scanner data structure.
 714  * \returns    The created selection element.
 715  *
 716  * This function handles the creation of a gmx::SelectionTreeElement object for
 717  * selection methods that do not take parameters.
 718  */
 719 SelectionTreeElementPointer
 720 _gmx_sel_init_keyword(gmx_ana_selmethod_t *method,
 721                       SelectionParserValueListPointer args,
 722                       const char *rpost, yyscan_t scanner)
 723 {
 724     return init_keyword_internal(method, gmx::eStringMatchType_Auto, move(args),
 725                                  rpost, scanner);
 726 }
 727
 728 /*!
 729  * \param[in]  method    Method to use.
 730  * \param[in]  matchType String matching type.
 731  * \param[in]  args      Pointer to the first argument.
 732  * \param[in]  rpost     Reference position type to use (NULL = default).
 733  * \param[in]  scanner   Scanner data structure.
 734  * \returns    The created selection element.
 735  *
 736  * This function handles the creation of a gmx::SelectionTreeElement object for
 737  * keyword string matching.
 738  */
 739 SelectionTreeElementPointer
 740 _gmx_sel_init_keyword_strmatch(gmx_ana_selmethod_t *method,
 741                                gmx::SelectionStringMatchType matchType,
 742                                SelectionParserValueListPointer args,
 743                                const char *rpost, yyscan_t scanner)
 744 {
 745     GMX_RELEASE_ASSERT(method->type == STR_VALUE,
 746                        "String keyword method called for a non-string-valued method");
 747     GMX_RELEASE_ASSERT(args && !args->empty(),
 748                        "String keyword matching method called without any values");
 749     return init_keyword_internal(method, matchType, move(args), rpost, scanner);
 750 }
 751
 752 /*!
 753  * \param[in]  method Method to use for initialization.
 754  * \param[in]  params Pointer to the first parameter.
 755  * \param[in]  rpost  Reference position type to use (NULL = default).
 756  * \param[in]  scanner Scanner data structure.
 757  * \returns    The created selection element.
 758  *
 759  * This function handles the creation of a gmx::SelectionTreeElement object for
 760  * selection methods that take parameters.
 761  *
 762  * Part of the behavior of the \c same selection keyword is hardcoded into
 763  * this function (or rather, into _gmx_selelem_custom_init_same()) to allow the
 764  * use of any keyword in \c "same KEYWORD as" without requiring special
 765  * handling somewhere else (or sacrificing the simple syntax).
 766  */
 767 SelectionTreeElementPointer
 768 _gmx_sel_init_method(gmx_ana_selmethod_t *method,
 769                      SelectionParserParameterListPointer params,
 770                      const char *rpost, yyscan_t scanner)
 771 {
 772     gmx_ana_selcollection_t     *sc = _gmx_sel_lexer_selcollection(scanner);
 773     int                          rc;
 774
 775     gmx::MessageStringCollector *errors = _gmx_sel_lexer_error_reporter(scanner);
 776     char  buf[128];
 777     sprintf(buf, "In keyword '%s'", method->name);
 778     gmx::MessageStringContext  context(errors, buf);
 779
 780     _gmx_sel_finish_method(scanner);
 781     /* The "same" keyword needs some custom massaging of the parameters. */
 782     rc = _gmx_selelem_custom_init_same(&method, params, scanner);
 783     if (rc != 0)
 784     {
 785         return SelectionTreeElementPointer();
 786     }
 787     SelectionTreeElementPointer root(new SelectionTreeElement(SEL_EXPRESSION));
 788     _gmx_selelem_set_method(root, method, scanner);
 789     /* Process the parameters */
 790     if (!_gmx_sel_parse_params(*params, root->u.expr.method->nparams,
 791                                root->u.expr.method->param, root, scanner))
 792     {
 793         return SelectionTreeElementPointer();
 794     }
 795     set_refpos_type(&sc->pcc, root, rpost, scanner);
 796
 797     return root;
 798 }
 799
 800 /*!
 801  * \param[in]  method Modifier to use for initialization.
 802  * \param[in]  params Pointer to the first parameter.
 803  * \param[in]  sel    Selection element that the modifier should act on.
 804  * \param[in]  scanner Scanner data structure.
 805  * \returns    The created selection element.
 806  *
 807  * This function handles the creation of a gmx::SelectionTreeElement object for
 808  * selection modifiers.
 809  */
 810 SelectionTreeElementPointer
 811 _gmx_sel_init_modifier(gmx_ana_selmethod_t *method,
 812                        SelectionParserParameterListPointer params,
 813                        const SelectionTreeElementPointer &sel, yyscan_t scanner)
 814 {
 815     gmx::MessageStringCollector *errors = _gmx_sel_lexer_error_reporter(scanner);
 816     char  buf[128];
 817     sprintf(buf, "In keyword '%s'", method->name);
 818     gmx::MessageStringContext  context(errors, buf);
 819
 820     _gmx_sel_finish_method(scanner);
 821     SelectionTreeElementPointer modifier(new SelectionTreeElement(SEL_MODIFIER));
 822     _gmx_selelem_set_method(modifier, method, scanner);
 823     SelectionTreeElementPointer root;
 824     if (method->type == NO_VALUE)
 825     {
 826         SelectionTreeElementPointer child = sel;
 827         while (child->next)
 828         {
 829             child = child->next;
 830         }
 831         child->next = modifier;
 832         root        = sel;
 833     }
 834     else
 835     {
 836         params->push_front(
 837                 SelectionParserParameter::createFromExpression(NULL, sel));
 838         root = modifier;
 839     }
 840     /* Process the parameters */
 841     if (!_gmx_sel_parse_params(*params, modifier->u.expr.method->nparams,
 842                                modifier->u.expr.method->param, modifier, scanner))
 843     {
 844         return SelectionTreeElementPointer();
 845     }
 846
 847     return root;
 848 }
 849
 850 /*!
 851  * \param[in]  expr    Input selection element for the position calculation.
 852  * \param[in]  type    Reference position type or NULL for default.
 853  * \param[in]  scanner Scanner data structure.
 854  * \returns    The created selection element.
 855  *
 856  * This function handles the creation of a gmx::SelectionTreeElement object for
 857  * evaluation of reference positions.
 858  */
 859 SelectionTreeElementPointer
 860 _gmx_sel_init_position(const SelectionTreeElementPointer &expr,
 861                        const char *type, yyscan_t scanner)
 862 {
 863     gmx::MessageStringCollector *errors = _gmx_sel_lexer_error_reporter(scanner);
 864     char  buf[128];
 865     sprintf(buf, "In position evaluation");
 866     gmx::MessageStringContext   context(errors, buf);
 867
 868     SelectionTreeElementPointer root(new SelectionTreeElement(SEL_EXPRESSION));
 869     _gmx_selelem_set_method(root, &sm_keyword_pos, scanner);
 870     _gmx_selelem_set_kwpos_type(root.get(), type);
 871     /* Create the parameters for the parameter parser. */
 872     SelectionParserParameterList params;
 873     params.push_back(SelectionParserParameter::createFromExpression(NULL, expr));
 874     /* Parse the parameters. */
 875     if (!_gmx_sel_parse_params(params, root->u.expr.method->nparams,
 876                                root->u.expr.method->param, root, scanner))
 877     {
 878         return SelectionTreeElementPointer();
 879     }
 880
 881     return root;
 882 }
 883
 884 /*!
 885  * \param[in] x,y,z  Coordinates for the position.
 886  * \returns   The creates selection element.
 887  */
 888 SelectionTreeElementPointer
 889 _gmx_sel_init_const_position(real x, real y, real z)
 890 {
 891     rvec                        pos;
 892
 893     SelectionTreeElementPointer sel(new SelectionTreeElement(SEL_CONST));
 894     _gmx_selelem_set_vtype(sel, POS_VALUE);
 895     _gmx_selvalue_reserve(&sel->v, 1);
 896     pos[XX] = x;
 897     pos[YY] = y;
 898     pos[ZZ] = z;
 899     gmx_ana_pos_init_const(sel->v.u.p, pos);
 900     return sel;
 901 }
 902
 903 /*!
 904  * \param[in] name  Name of an index group to search for.
 905  * \param[in] scanner Scanner data structure.
 906  * \returns   The created constant selection element, or NULL if no matching
 907  *     index group found.
 908  *
 909  * See gmx_ana_indexgrps_find() for information on how \p name is matched
 910  * against the index groups.
 911  */
 912 SelectionTreeElementPointer
 913 _gmx_sel_init_group_by_name(const char *name, yyscan_t scanner)
 914 {
 915     gmx_ana_indexgrps_t *grps = _gmx_sel_lexer_indexgrps(scanner);
 916
 917     if (!_gmx_sel_lexer_has_groups_set(scanner))
 918     {
 919         SelectionTreeElementPointer sel(new SelectionTreeElement(SEL_GROUPREF));
 920         _gmx_selelem_set_vtype(sel, GROUP_VALUE);
 921         sel->setName(name);
 922         sel->u.gref.name = strdup(name);
 923         sel->u.gref.id   = -1;
 924         return sel;
 925     }
 926     if (!grps)
 927     {
 928         _gmx_selparser_error(scanner, "No index groups set; cannot match 'group %s'", name);
 929         return SelectionTreeElementPointer();
 930     }
 931     SelectionTreeElementPointer sel(new SelectionTreeElement(SEL_CONST));
 932     _gmx_selelem_set_vtype(sel, GROUP_VALUE);
 933     /* FIXME: The constness should not be cast away */
 934     if (!gmx_ana_indexgrps_find(&sel->u.cgrp, grps, (char *)name))
 935     {
 936         _gmx_selparser_error(scanner, "Cannot match 'group %s'", name);
 937         return SelectionTreeElementPointer();
 938     }
 939     sel->setName(sel->u.cgrp.name);
 940     return sel;
 941 }
 942
 943 /*!
 944  * \param[in] id    Zero-based index number of the group to extract.
 945  * \param[in] scanner Scanner data structure.
 946  * \returns   The created constant selection element, or NULL if no matching
 947  *     index group found.
 948  */
 949 SelectionTreeElementPointer
 950 _gmx_sel_init_group_by_id(int id, yyscan_t scanner)
 951 {
 952     gmx_ana_indexgrps_t *grps = _gmx_sel_lexer_indexgrps(scanner);
 953
 954     if (!_gmx_sel_lexer_has_groups_set(scanner))
 955     {
 956         SelectionTreeElementPointer sel(new SelectionTreeElement(SEL_GROUPREF));
 957         _gmx_selelem_set_vtype(sel, GROUP_VALUE);
 958         sel->u.gref.name = NULL;
 959         sel->u.gref.id   = id;
 960         return sel;
 961     }
 962     if (!grps)
 963     {
 964         _gmx_selparser_error(scanner, "No index groups set; cannot match 'group %d'", id);
 965         return SelectionTreeElementPointer();
 966     }
 967     SelectionTreeElementPointer sel(new SelectionTreeElement(SEL_CONST));
 968     _gmx_selelem_set_vtype(sel, GROUP_VALUE);
 969     if (!gmx_ana_indexgrps_extract(&sel->u.cgrp, grps, id))
 970     {
 971         _gmx_selparser_error(scanner, "Cannot match 'group %d'", id);
 972         return SelectionTreeElementPointer();
 973     }
 974     sel->setName(sel->u.cgrp.name);
 975     return sel;
 976 }
 977
 978 /*!
 979  * \param[in,out] sel  Value of the variable.
 980  * \returns       The created selection element that references \p sel.
 981  *
 982  * The reference count of \p sel is updated, but no other modifications are
 983  * made.
 984  */
 985 SelectionTreeElementPointer
 986 _gmx_sel_init_variable_ref(const SelectionTreeElementPointer &sel)
 987 {
 988     SelectionTreeElementPointer ref;
 989
 990     if (sel->v.type == POS_VALUE && sel->type == SEL_CONST)
 991     {
 992         ref = sel;
 993     }
 994     else
 995     {
 996         ref.reset(new SelectionTreeElement(SEL_SUBEXPRREF));
 997         _gmx_selelem_set_vtype(ref, sel->v.type);
 998         ref->setName(sel->name());
 999         ref->child = sel;
1000     }
1001     return ref;
1002 }
1003
1004 /*!
1005  * \param[in]  name     Name for the selection
1006  *     (if NULL, a default name is constructed).
1007  * \param[in]  sel      The selection element that evaluates the selection.
1008  * \param      scanner  Scanner data structure.
1009  * \returns    The created root selection element.
1010  *
1011  * This function handles the creation of root (\ref SEL_ROOT)
1012  * gmx::SelectionTreeElement objects for selections.
1013  */
1014 SelectionTreeElementPointer
1015 _gmx_sel_init_selection(const char                        *name,
1016                         const SelectionTreeElementPointer &sel,
1017                         yyscan_t                           scanner)
1018 {
1019     gmx::MessageStringCollector *errors = _gmx_sel_lexer_error_reporter(scanner);
1020     char  buf[1024];
1021     sprintf(buf, "In selection '%s'", _gmx_sel_lexer_pselstr(scanner));
1022     gmx::MessageStringContext  context(errors, buf);
1023
1024     if (sel->v.type != POS_VALUE)
1025     {
1026         /* FIXME: Better handling of this error */
1027         GMX_THROW(gmx::InternalError(
1028                           "Each selection must evaluate to a position"));
1029     }
1030
1031     SelectionTreeElementPointer root(new SelectionTreeElement(SEL_ROOT));
1032     root->child = sel;
1033     if (name)
1034     {
1035         root->setName(name);
1036         root->u.cgrp.name = strdup(name);
1037     }
1038     /* Update the flags */
1039     _gmx_selelem_update_flags(root, scanner);
1040
1041     /* If there is no name provided by the user, check whether the actual
1042      * selection given was from an external group, and if so, use the name
1043      * of the external group. */
1044     if (root->name().empty())
1045     {
1046         SelectionTreeElementPointer child = root->child;
1047         while (child->type == SEL_MODIFIER)
1048         {
1049             if (!child->child || child->child->type != SEL_SUBEXPRREF
1050                 || !child->child->child)
1051             {
1052                 break;
1053             }
1054             child = child->child->child;
1055         }
1056         if (child->type == SEL_EXPRESSION
1057             && child->child && child->child->type == SEL_SUBEXPRREF
1058             && child->child->child
1059             && child->child->child->type == SEL_CONST
1060             && child->child->child->v.type == GROUP_VALUE)
1061         {
1062             const char *grpName = child->child->child->u.cgrp.name;
1063             root->setName(grpName);
1064             root->u.cgrp.name = strdup(grpName);
1065         }
1066     }
1067     /* If there still is no name, use the selection string */
1068     if (root->name().empty())
1069     {
1070         const char *selStr = _gmx_sel_lexer_pselstr(scanner);
1071         root->setName(selStr);
1072         root->u.cgrp.name = strdup(selStr);
1073     }
1074
1075     /* Print out some information if the parser is interactive */
1076     if (_gmx_sel_is_lexer_interactive(scanner))
1077     {
1078         fprintf(stderr, "Selection '%s' parsed\n",
1079                 _gmx_sel_lexer_pselstr(scanner));
1080     }
1081
1082     return root;
1083 }
1084
1085
1086 /*!
1087  * \param[in]  name     Name of the variable.
1088  * \param[in]  expr     The selection element that evaluates the variable.
1089  * \param      scanner  Scanner data structure.
1090  * \returns    The created root selection element.
1091  *
1092  * This function handles the creation of root gmx::SelectionTreeElement objects
1093  * for variable assignments. A \ref SEL_ROOT element and a \ref SEL_SUBEXPR
1094  * element are both created.
1095  */
1096 SelectionTreeElementPointer
1097 _gmx_sel_assign_variable(const char                        *name,
1098                          const SelectionTreeElementPointer &expr,
1099                          yyscan_t                           scanner)
1100 {
1101     gmx_ana_selcollection_t     *sc      = _gmx_sel_lexer_selcollection(scanner);
1102     const char                  *pselstr = _gmx_sel_lexer_pselstr(scanner);
1103     SelectionTreeElementPointer  root;
1104
1105     gmx::MessageStringCollector *errors = _gmx_sel_lexer_error_reporter(scanner);
1106     char  buf[1024];
1107     sprintf(buf, "In selection '%s'", pselstr);
1108     gmx::MessageStringContext  context(errors, buf);
1109
1110     _gmx_selelem_update_flags(expr, scanner);
1111     /* Check if this is a constant non-group value */
1112     if (expr->type == SEL_CONST && expr->v.type != GROUP_VALUE)
1113     {
1114         /* If so, just assign the constant value to the variable */
1115         sc->symtab->addVariable(name, expr);
1116         goto finish;
1117     }
1118     /* Check if we are assigning a variable to another variable */
1119     if (expr->type == SEL_SUBEXPRREF)
1120     {
1121         /* If so, make a simple alias */
1122         sc->symtab->addVariable(name, expr->child);
1123         goto finish;
1124     }
1125     /* Create the root element */
1126     root.reset(new SelectionTreeElement(SEL_ROOT));
1127     root->setName(name);
1128     root->u.cgrp.name = strdup(name);
1129     /* Create the subexpression element */
1130     root->child.reset(new SelectionTreeElement(SEL_SUBEXPR));
1131     root->child->setName(name);
1132     _gmx_selelem_set_vtype(root->child, expr->v.type);
1133     root->child->child  = expr;
1134     /* Update flags */
1135     _gmx_selelem_update_flags(root, scanner);
1136     /* Add the variable to the symbol table */
1137     sc->symtab->addVariable(name, root->child);
1138 finish:
1139     srenew(sc->varstrs, sc->nvars + 1);
1140     sc->varstrs[sc->nvars] = strdup(pselstr);
1141     ++sc->nvars;
1142     if (_gmx_sel_is_lexer_interactive(scanner))
1143     {
1144         fprintf(stderr, "Variable '%s' parsed\n", pselstr);
1145     }
1146     return root;
1147 }
1148
1149 /*!
1150  * \param         sel   Selection to append (can be NULL, in which
1151  *   case nothing is done).
1152  * \param         last  Last selection, or NULL if not present or not known.
1153  * \param         scanner  Scanner data structure.
1154  * \returns       The last selection after the append.
1155  *
1156  * Appends \p sel after the last root element, and returns either \p sel
1157  * (if it was non-NULL) or the last element (if \p sel was NULL).
1158  */
1159 SelectionTreeElementPointer
1160 _gmx_sel_append_selection(const SelectionTreeElementPointer &sel,
1161                           SelectionTreeElementPointer        last,
1162                           yyscan_t                           scanner)
1163 {
1164     gmx_ana_selcollection_t *sc = _gmx_sel_lexer_selcollection(scanner);
1165
1166     /* Append sel after last, or the last element of sc if last is NULL */
1167     if (last)
1168     {
1169         last->next = sel;
1170     }
1171     else
1172     {
1173         if (sc->root)
1174         {
1175             last = sc->root;
1176             while (last->next)
1177             {
1178                 last = last->next;
1179             }
1180             last->next = sel;
1181         }
1182         else
1183         {
1184             sc->root = sel;
1185         }
1186     }
1187     /* Initialize a selection object if necessary */
1188     if (sel)
1189     {
1190         last = sel;
1191         /* Add the new selection to the collection if it is not a variable. */
1192         if (sel->child->type != SEL_SUBEXPR)
1193         {
1194             gmx::SelectionDataPointer selPtr(
1195                     new gmx::internal::SelectionData(
1196                             sel.get(), _gmx_sel_lexer_pselstr(scanner)));
1197             sc->sel.push_back(gmx::move(selPtr));
1198         }
1199     }
1200     /* Clear the selection string now that we've saved it */
1201     _gmx_sel_lexer_clear_pselstr(scanner);
1202     return last;
1203 }
1204
1205 /*!
1206  * \param[in] scanner Scanner data structure.
1207  * \returns   true if the parser should finish, false if parsing should
1208  *   continue.
1209  *
1210  * This function is called always after _gmx_sel_append_selection() to
1211  * check whether a sufficient number of selections has already been provided.
1212  * This is used to terminate interactive parsers when the correct number of
1213  * selections has been provided.
1214  */
1215 bool
1216 _gmx_sel_parser_should_finish(yyscan_t scanner)
1217 {
1218     gmx_ana_selcollection_t *sc = _gmx_sel_lexer_selcollection(scanner);
1219     return (int)sc->sel.size() == _gmx_sel_lexer_exp_selcount(scanner);
1220 }
1221
1222 /*!
1223  * \param[in] scanner Scanner data structure.
1224  */
1225 void
1226 _gmx_sel_handle_empty_cmd(yyscan_t scanner)
1227 {
1228     gmx_ana_selcollection_t *sc   = _gmx_sel_lexer_selcollection(scanner);
1229     gmx_ana_indexgrps_t     *grps = _gmx_sel_lexer_indexgrps(scanner);
1230     int                      i;
1231
1232     if (!_gmx_sel_is_lexer_interactive(scanner))
1233     {
1234         return;
1235     }
1236
1237     if (grps)
1238     {
1239         fprintf(stderr, "Available index groups:\n");
1240         gmx_ana_indexgrps_print(stderr, _gmx_sel_lexer_indexgrps(scanner), 0);
1241     }
1242     if (sc->nvars > 0 || !sc->sel.empty())
1243     {
1244         fprintf(stderr, "Currently provided selections:\n");
1245         for (i = 0; i < sc->nvars; ++i)
1246         {
1247             fprintf(stderr, "     %s\n", sc->varstrs[i]);
1248         }
1249         for (i = 0; i < (int)sc->sel.size(); ++i)
1250         {
1251             fprintf(stderr, " %2d. %s\n", i+1, sc->sel[i]->selectionText());
1252         }
1253     }
1254 }
1255
1256 /*!
1257  * \param[in] topic   Topic for which help was requested, or NULL for general
1258  *                    help.
1259  * \param[in] scanner Scanner data structure.
1260  *
1261  * \p topic is freed by this function.
1262  */
1263 void
1264 _gmx_sel_handle_help_cmd(const SelectionParserValueListPointer &topic,
1265                          yyscan_t                               scanner)
1266 {
1267     gmx_ana_selcollection_t *sc = _gmx_sel_lexer_selcollection(scanner);
1268
1269     if (sc->rootHelp.get() == NULL)
1270     {
1271         sc->rootHelp = gmx::createSelectionHelpTopic();
1272     }
1273     gmx::HelpWriterContext context(&gmx::File::standardError(),
1274                                    gmx::eHelpOutputFormat_Console);
1275     gmx::HelpManager       manager(*sc->rootHelp, context);
1276     try
1277     {
1278         SelectionParserValueList::const_iterator value;
1279         for (value = topic->begin(); value != topic->end(); ++value)
1280         {
1281             manager.enterTopic(value->stringValue());
1282         }
1283     }
1284     catch (const gmx::InvalidInputError &ex)
1285     {
1286         fprintf(stderr, "%s\n", ex.what());
1287         return;
1288     }
1289     manager.writeCurrentTopic();
1290 }