src/gromacs/selection/selmethod.cpp

   1 /*
   2  *
   3  *                This source code is part of
   4  *
   5  *                 G   R   O   M   A   C   S
   6  *
   7  *          GROningen MAchine for Chemical Simulations
   8  *
   9  * Written by David van der Spoel, Erik Lindahl, Berk Hess, and others.
  10  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
  11  * Copyright (c) 2001-2009, The GROMACS development team,
  12  * check out http://www.gromacs.org for more information.
  13
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * If you want to redistribute modifications, please consider that
  20  * scientific software is very special. Version control is crucial -
  21  * bugs must be traceable. We will be happy to consider code for
  22  * inclusion in the official distribution, but derived work must not
  23  * be called official GROMACS. Details are found in the README & COPYING
  24  * files - if they are missing, get the official version at www.gromacs.org.
  25  *
  26  * To help us fund GROMACS development, we humbly ask that you cite
  27  * the papers on the package - you can find them in the top README file.
  28  *
  29  * For more info, check our website at http://www.gromacs.org
  30  */
  31 /*! \internal \file
  32  * \brief
  33  * Implements functions in selmethod.h.
  34  *
  35  * \author Teemu Murtola <teemu.murtola@gmail.com>
  36  * \ingroup module_selection
  37  */
  38 #include <ctype.h>
  39 #include <stdarg.h>
  40
  41 #include "gromacs/legacyheaders/macros.h"
  42 #include "gromacs/legacyheaders/string2.h"
  43
  44 #include "gromacs/selection/selmethod.h"
  45 #include "gromacs/utility/exceptions.h"
  46
  47 #include "symrec.h"
  48
  49 /*
  50  * These global variables cannot be const because gmx_ana_selmethod_register()
  51  * modifies them to set some defaults. This is a small price to pay for the
  52  * convenience of not having to remember exactly how the selection compiler
  53  * expects the structures to be filled, and even more so if the expectations
  54  * change. Also, even if the gmx_ana_selmethod_t structures were made const,
  55  * the parameters could not be without typecasts somewhere, because the param
  56  * field in gmx_ana_selmethod_t cannot be declared const.
  57  *
  58  * Even though the variables may be modified, this should be thread-safe as
  59  * modifications are done only in gmx_ana_selmethod_register(), and it should
  60  * work even if called more than once for the same structure, and even if
  61  * called concurrently from multiple threads (as long as the selection
  62  * collection is not the same).
  63  *
  64  * All of these problems should go away if/when the selection methods are
  65  * implemented as C++ classes.
  66  */
  67
  68 /* From sm_com.c */
  69 extern gmx_ana_selmethod_t sm_cog;
  70 extern gmx_ana_selmethod_t sm_com;
  71 /* From sm_simple.c */
  72 extern gmx_ana_selmethod_t sm_all;
  73 extern gmx_ana_selmethod_t sm_none;
  74 extern gmx_ana_selmethod_t sm_atomnr;
  75 extern gmx_ana_selmethod_t sm_resnr;
  76 extern gmx_ana_selmethod_t sm_resindex;
  77 extern gmx_ana_selmethod_t sm_molindex;
  78 extern gmx_ana_selmethod_t sm_atomname;
  79 extern gmx_ana_selmethod_t sm_pdbatomname;
  80 extern gmx_ana_selmethod_t sm_atomtype;
  81 extern gmx_ana_selmethod_t sm_resname;
  82 extern gmx_ana_selmethod_t sm_insertcode;
  83 extern gmx_ana_selmethod_t sm_chain;
  84 extern gmx_ana_selmethod_t sm_mass;
  85 extern gmx_ana_selmethod_t sm_charge;
  86 extern gmx_ana_selmethod_t sm_altloc;
  87 extern gmx_ana_selmethod_t sm_occupancy;
  88 extern gmx_ana_selmethod_t sm_betafactor;
  89 extern gmx_ana_selmethod_t sm_x;
  90 extern gmx_ana_selmethod_t sm_y;
  91 extern gmx_ana_selmethod_t sm_z;
  92 /* From sm_distance.c */
  93 extern gmx_ana_selmethod_t sm_distance;
  94 extern gmx_ana_selmethod_t sm_mindistance;
  95 extern gmx_ana_selmethod_t sm_within;
  96 /* From sm_insolidangle.c */
  97 extern gmx_ana_selmethod_t sm_insolidangle;
  98 /* From sm_same.c */
  99 extern gmx_ana_selmethod_t sm_same;
 100
 101 /* From sm_merge.c */
 102 extern gmx_ana_selmethod_t sm_merge;
 103 extern gmx_ana_selmethod_t sm_plus;
 104 /* From sm_permute.c */
 105 extern gmx_ana_selmethod_t sm_permute;
 106
 107 /*! \internal \brief
 108  * Helper structure for defining selection methods.
 109  */
 110 typedef struct {
 111     /*! \brief
 112      * Name to register the method under.
 113      *
 114      * If NULL, use the actual name of the method.
 115      * This field is used for defining synonyms.
 116      */
 117     const char            *name;
 118     /** Method data structure to register. */
 119     gmx_ana_selmethod_t   *method;
 120 } t_register_method;
 121
 122 /** Array of selection methods defined in the library. */
 123 static const t_register_method smtable_def[] = {
 124     {NULL,         &sm_cog},
 125     {NULL,         &sm_com},
 126
 127     {NULL,         &sm_all},
 128     {NULL,         &sm_none},
 129     {NULL,         &sm_atomnr},
 130     {NULL,         &sm_resnr},
 131     {"resid",      &sm_resnr},
 132     {NULL,         &sm_resindex},
 133     {"residue",    &sm_resindex},
 134     {NULL,         &sm_molindex},
 135     {"mol",        &sm_molindex},
 136     {"molecule",   &sm_molindex},
 137     {NULL,         &sm_atomname},
 138     {"name",       &sm_atomname},
 139     {NULL,         &sm_pdbatomname},
 140     {"pdbname",    &sm_pdbatomname},
 141     {NULL,         &sm_atomtype},
 142     {"type",       &sm_atomtype},
 143     {NULL,         &sm_resname},
 144     {NULL,         &sm_insertcode},
 145     {NULL,         &sm_chain},
 146     {NULL,         &sm_mass},
 147     {NULL,         &sm_charge},
 148     {NULL,         &sm_altloc},
 149     {NULL,         &sm_occupancy},
 150     {NULL,         &sm_betafactor},
 151     {NULL,         &sm_x},
 152     {NULL,         &sm_y},
 153     {NULL,         &sm_z},
 154
 155     {NULL,         &sm_distance},
 156     {NULL,         &sm_mindistance},
 157     {NULL,         &sm_within},
 158     {NULL,         &sm_insolidangle},
 159     {NULL,         &sm_same},
 160
 161     {NULL,         &sm_merge},
 162     {NULL,         &sm_plus},
 163     {NULL,         &sm_permute},
 164 };
 165
 166 /*! \brief
 167  * Convenience function for reporting errors found in selection methods.
 168  */
 169 static void
 170 report_error(FILE *fp, const char *name, const char *fmt, ...)
 171 {
 172     va_list ap;
 173     va_start(ap, fmt);
 174     if (fp)
 175     {
 176         fprintf(fp, "selection method '%s': ", name);
 177         vfprintf(fp, fmt, ap);
 178         fprintf(fp, "\n");
 179     }
 180     va_end(ap);
 181 }
 182
 183 /*! \brief
 184  * Convenience function for reporting errors found in selection method parameters.
 185  */
 186 static void
 187 report_param_error(FILE *fp, const char *mname, const char *pname,
 188                    const char *fmt, ...)
 189 {
 190     va_list ap;
 191     va_start(ap, fmt);
 192     if (fp)
 193     {
 194         fprintf(fp, "selection method '%s': parameter '%s': ", mname, pname);
 195         vfprintf(fp, fmt, ap);
 196         fprintf(fp, "\n");
 197     }
 198     va_end(ap);
 199 }
 200
 201 /*! \brief
 202  * Checks the validity of parameters.
 203  *
 204  * \param[in]     fp      File handle to use for diagnostic messages
 205  *   (can be NULL).
 206  * \param[in]     name    Name of the method (used for error messages).
 207  * \param[in]     nparams Number of parameters in \p param.
 208  * \param[in,out] param   Parameter array
 209  *   (only the \c flags field of boolean parameters may be modified).
 210  * \param[in]     symtab  Symbol table (used for checking overlaps).
 211  * \returns       true if there are no problems with the parameters,
 212  *   false otherwise.
 213  *
 214  * This function performs some checks common to both check_method() and
 215  * check_modifier().
 216  * The purpose of these checks is to ensure that the selection parser does not
 217  * need to check for the validity of the parameters at each turn, and to
 218  * report programming errors as early as possible.
 219  * If you remove a check, make sure that the parameter parser can handle the
 220  * resulting parameters.
 221  */
 222 static bool
 223 check_params(FILE *fp, const char *name, int nparams, gmx_ana_selparam_t param[],
 224              const gmx::SelectionParserSymbolTable &symtab)
 225 {
 226     bool              bOk = true;
 227     int               i, j;
 228
 229     if (nparams > 0 && !param)
 230     {
 231         report_error(fp, name, "error: missing parameter data");
 232         return false;
 233     }
 234     if (nparams == 0 && param)
 235     {
 236         report_error(fp, name, "warning: parameter data unused because nparams=0");
 237     }
 238     /* Check each parameter */
 239     for (i = 0; i < nparams; ++i)
 240     {
 241         /* Check that there is at most one NULL name, in the beginning */
 242         if (param[i].name == NULL && i > 0)
 243         {
 244             report_error(fp, name, "error: NULL parameter should be the first one");
 245             bOk = false;
 246             continue;
 247         }
 248         /* Check for duplicates */
 249         for (j = 0; j < i; ++j)
 250         {
 251             if (param[j].name == NULL)
 252             {
 253                 continue;
 254             }
 255             if (!gmx_strcasecmp(param[i].name, param[j].name))
 256             {
 257                 report_error(fp, name, "error: duplicate parameter name '%s'", param[i].name);
 258                 bOk = false;
 259                 break;
 260             }
 261         }
 262         /* Check flags */
 263         if (param[i].flags & SPAR_SET)
 264         {
 265             report_param_error(fp, name, param[i].name, "warning: flag SPAR_SET is set");
 266             param[i].flags &= ~SPAR_SET;
 267         }
 268         if (param[i].flags & SPAR_RANGES)
 269         {
 270             if (param[i].val.type != INT_VALUE && param[i].val.type != REAL_VALUE)
 271             {
 272                 report_param_error(fp, name, param[i].name, "error: SPAR_RANGES cannot be set for a non-numeric parameter");
 273                 bOk = false;
 274             }
 275             if (param[i].flags & SPAR_DYNAMIC)
 276             {
 277                 report_param_error(fp, name, param[i].name, "warning: SPAR_DYNAMIC does not have effect with SPAR_RANGES");
 278                 param[i].flags &= ~SPAR_DYNAMIC;
 279             }
 280             if (!(param[i].flags & SPAR_VARNUM) && param[i].val.nr != 1)
 281             {
 282                 report_param_error(fp, name, param[i].name, "error: range should take either one or an arbitrary number of values");
 283                 bOk = false;
 284             }
 285             if (param[i].flags & SPAR_ATOMVAL)
 286             {
 287                 report_param_error(fp, name, param[i].name, "error: SPAR_RANGES and SPAR_ATOMVAL both set");
 288                 bOk = false;
 289             }
 290         }
 291         if ((param[i].flags & SPAR_VARNUM) && (param[i].flags & SPAR_ATOMVAL))
 292         {
 293             report_param_error(fp, name, param[i].name, "error: SPAR_VARNUM and SPAR_ATOMVAL both set");
 294             bOk = false;
 295         }
 296         if (param[i].flags & SPAR_ENUMVAL)
 297         {
 298             if (param[i].val.type != STR_VALUE)
 299             {
 300                 report_param_error(fp, name, param[i].name, "error: SPAR_ENUMVAL can only be set for string parameters");
 301                 bOk = false;
 302             }
 303             if (param[i].val.nr != 1)
 304             {
 305                 report_param_error(fp, name, param[i].name, "error: SPAR_ENUMVAL parameters should take exactly one value");
 306                 bOk = false;
 307             }
 308             if (param[i].flags & (SPAR_DYNAMIC | SPAR_VARNUM | SPAR_ATOMVAL))
 309             {
 310                 report_param_error(fp, name, param[i].name, "error: only SPAR_OPTIONAL supported with SPAR_ENUMVAL");
 311                 bOk = false;
 312             }
 313         }
 314         /* Check boolean parameters */
 315         if (param[i].val.type == NO_VALUE)
 316         {
 317             if (param[i].val.nr != 0)
 318             {
 319                 report_param_error(fp, name, param[i].name, "error: number of values should be zero for boolean parameters");
 320                 bOk = false;
 321             }
 322             /* The boolean parameters should always be optional, so set the
 323              * flag for convenience. */
 324             param[i].flags |= SPAR_OPTIONAL;
 325             /* Any other flags should not be specified */
 326             if (param[i].flags & ~SPAR_OPTIONAL)
 327             {
 328                 report_param_error(fp, name, param[i].name, "error: boolean parameter should not have any flags set");
 329                 bOk = false;
 330             }
 331         }
 332         /* Check val.nr */
 333         if (param[i].flags & (SPAR_VARNUM | SPAR_ATOMVAL))
 334         {
 335             if (param[i].val.nr != -1)
 336             {
 337                 report_param_error(fp, name, param[i].name, "warning: val.nr is not -1 although SPAR_VARNUM/SPAR_ATOMVAL is set");
 338             }
 339             param[i].val.nr = -1;
 340         }
 341         else if (param[i].val.type != NO_VALUE)
 342         {
 343             if (param[i].val.nr <= 0)
 344             {
 345                 report_param_error(fp, name, param[i].name, "error: val.nr <= 0");
 346                 bOk = false;
 347             }
 348         }
 349         /* Check that the value pointer is NULL */
 350         if (param[i].nvalptr != NULL)
 351         {
 352             report_param_error(fp, name, param[i].name, "warning: nvalptr is set");
 353         }
 354         if (param[i].val.u.ptr != NULL && !(param[i].flags & SPAR_ENUMVAL))
 355         {
 356             report_param_error(fp, name, param[i].name, "warning: value pointer is set");
 357         }
 358         /* Check that the name contains only valid characters */
 359         if (param[i].name == NULL)
 360         {
 361             continue;
 362         }
 363         if (!isalpha(param[i].name[0]))
 364         {
 365             report_param_error(fp, name, param[i].name, "error: name does not begin with a letter");
 366             bOk = false;
 367             continue;
 368         }
 369         for (j = 1; param[i].name[j] != 0; ++j)
 370         {
 371             if (param[i].name[j] != '_' && !isalnum(param[i].name[j]))
 372             {
 373                 report_param_error(fp, name, param[i].name, "error: name contains non-alphanumeric characters");
 374                 bOk = false;
 375                 break;
 376             }
 377         }
 378         if (param[i].name[j] != 0)
 379         {
 380             continue;
 381         }
 382         /* Check that the name does not conflict with a method */
 383         if (symtab.findSymbol(param[i].name, true))
 384         {
 385             report_param_error(fp, name, param[i].name, "error: name conflicts with another method or a keyword");
 386             bOk = false;
 387         }
 388     } /* End of parameter loop */
 389       /* Check parameters of existing methods */
 390     gmx::SelectionParserSymbolIterator symbol
 391         = symtab.beginIterator(gmx::SelectionParserSymbol::MethodSymbol);
 392     while (symbol != symtab.endIterator())
 393     {
 394         gmx_ana_selmethod_t *method = symbol->methodValue();
 395         gmx_ana_selparam_t  *param  =
 396             gmx_ana_selmethod_find_param(name, method);
 397         if (param)
 398         {
 399             report_param_error(fp, method->name, param->name, "error: name conflicts with another method or a keyword");
 400             bOk = false;
 401         }
 402         ++symbol;
 403     }
 404     return bOk;
 405 }
 406
 407 /*! \brief
 408  * Checks the validity of selection method callback functions.
 409  *
 410  * \param[in] fp        File handle to use for diagnostic messages
 411  *   (can be NULL).
 412  * \param[in] method    The method to check.
 413  * \returns   true if there are no problems, false otherwise.
 414  *
 415  * This function performs some checks common to both check_method() and
 416  * check_modifier().
 417  * This function checks that all the required callbacks are defined, i.e.,
 418  * not NULL, to find programming errors.
 419  */
 420 static bool
 421 check_callbacks(FILE *fp, gmx_ana_selmethod_t *method)
 422 {
 423     bool         bOk = true;
 424     bool         bNeedInit;
 425     int          i;
 426
 427     /* Make some checks on init_data and free */
 428     if (method->nparams > 0 && !method->init_data)
 429     {
 430         report_error(fp, method->name, "error: init_data should be provided because the method has parameters");
 431         bOk = false;
 432     }
 433     if (method->free && !method->init_data)
 434     {
 435         report_error(fp, method->name, "warning: free is not used because of missing init_data");
 436     }
 437     /* Check presence of outinit for position-valued methods */
 438     if (method->type == POS_VALUE && !method->outinit)
 439     {
 440         report_error(fp, method->name, "error: outinit should be provided because the method has POS_VALUE");
 441         bOk = false;
 442     }
 443     /* Check presence of outinit for variable output count methods */
 444     if ((method->flags & SMETH_VARNUMVAL) && !method->outinit)
 445     {
 446         report_error(fp, method->name, "error: outinit should be provided because the method has SMETH_VARNUMVAL");
 447         bOk = false;
 448     }
 449     /* Warn of dynamic callbacks in static methods */
 450     if (!(method->flags & SMETH_MODIFIER))
 451     {
 452         if (method->pupdate && !(method->flags & SMETH_DYNAMIC))
 453         {
 454             report_error(fp, method->name, "warning: pupdate not used because the method is static");
 455             method->pupdate = NULL;
 456         }
 457     }
 458     /* Check that there is an evaluation function */
 459     if (method->type != NO_VALUE && !method->update && !method->pupdate)
 460     {
 461         report_error(fp, method->name, "error: evaluation function missing");
 462         bOk = false;
 463     }
 464     /* Loop through the parameters to determine if initialization callbacks
 465      * are needed. */
 466     bNeedInit = false;
 467     for (i = 0; i < method->nparams; ++i)
 468     {
 469         if (method->param[i].val.type != POS_VALUE
 470             && (method->param[i].flags & (SPAR_VARNUM | SPAR_ATOMVAL)))
 471         {
 472             bNeedInit = true;
 473         }
 474     }
 475     /* Check that the callbacks required by the parameters are present */
 476     if (bNeedInit && !method->init)
 477     {
 478         report_error(fp, method->name, "error: init should be provided");
 479         bOk = false;
 480     }
 481     return bOk;
 482 }
 483
 484 /*!
 485  * Checks the validity of a selection method.
 486  *
 487  * \param[in]     fp     File handle to use for diagnostic messages
 488  *   (can be NULL).
 489  * \param[in,out] method Method to check.
 490  * \param[in]     symtab Symbol table (used for checking overlaps).
 491  *
 492  * Checks the validity of the given selection method data structure
 493  * that does not have \ref SMETH_MODIFIER set.
 494  * If you remove a check, please make sure that the selection parser,
 495  * compiler, and evaluation functions can deal with the method.
 496  */
 497 static bool
 498 check_method(FILE *fp, gmx_ana_selmethod_t *method,
 499              const gmx::SelectionParserSymbolTable &symtab)
 500 {
 501     bool         bOk = true;
 502
 503     /* Check the type */
 504     if (method->type == NO_VALUE)
 505     {
 506         report_error(fp, method->name, "error: no value type specified");
 507         bOk = false;
 508     }
 509     if (method->type == STR_VALUE && method->nparams > 0)
 510     {
 511         report_error(fp, method->name, "error: evaluates to a string but is not a keyword");
 512         bOk = false;
 513     }
 514     /* Check flags */
 515     if (method->type == GROUP_VALUE)
 516     {
 517         /* Group methods should always have SMETH_SINGLEVAL,
 518          * so set it for convenience. */
 519         method->flags |= SMETH_SINGLEVAL;
 520         /* Check that conflicting flags are not present. */
 521         if (method->flags & SMETH_VARNUMVAL)
 522         {
 523             report_error(fp, method->name, "error: SMETH_VARNUMVAL cannot be set for group-valued methods");
 524             bOk = false;
 525         }
 526     }
 527     else
 528     {
 529         if ((method->flags & SMETH_SINGLEVAL)
 530             && (method->flags & SMETH_VARNUMVAL))
 531         {
 532             report_error(fp, method->name, "error: SMETH_SINGLEVAL and SMETH_VARNUMVAL both set");
 533             bOk = false;
 534         }
 535     }
 536     if ((method->flags & SMETH_CHARVAL) && method->type != STR_VALUE)
 537     {
 538         report_error(fp, method->name, "error: SMETH_CHARVAL can only be specified for STR_VALUE methods");
 539         bOk = false;
 540     }
 541     /* Check the parameters */
 542     if (!check_params(fp, method->name, method->nparams, method->param, symtab))
 543     {
 544         bOk = false;
 545     }
 546     /* Check the callback pointers */
 547     if (!check_callbacks(fp, method))
 548     {
 549         bOk = false;
 550     }
 551
 552     return bOk;
 553 }
 554
 555 /*!
 556  * Checks the validity of a selection modifier method.
 557  *
 558  * \param[in]     fp     File handle to use for diagnostic messages
 559  *   (can be NULL).
 560  * \param[in,out] method Method to check.
 561  * \param[in]     symtab Symbol table (used for checking overlaps).
 562  *
 563  * Checks the validity of the given selection method data structure
 564  * that has \ref SMETH_MODIFIER set.
 565  * If you remove a check, please make sure that the selection parser,
 566  * compiler, and evaluation functions can deal with the method.
 567  */
 568 static bool
 569 check_modifier(FILE *fp, gmx_ana_selmethod_t *method,
 570                const gmx::SelectionParserSymbolTable &symtab)
 571 {
 572     bool         bOk = true;
 573
 574     /* Check the type */
 575     if (method->type != NO_VALUE && method->type != POS_VALUE)
 576     {
 577         report_error(fp, method->name, "error: modifier should have type POS_VALUE or NO_VALUE");
 578         bOk = false;
 579     }
 580     /* Check flags */
 581     if (method->flags & (SMETH_SINGLEVAL | SMETH_VARNUMVAL))
 582     {
 583         report_error(fp, method->name, "error: modifier should not have SMETH_SINGLEVAL or SMETH_VARNUMVAL set");
 584         bOk = false;
 585     }
 586     /* Check the parameters */
 587     /* The first parameter is skipped */
 588     if (!check_params(fp, method->name, method->nparams-1, method->param+1, symtab))
 589     {
 590         bOk = false;
 591     }
 592     /* Check the callback pointers */
 593     if (!check_callbacks(fp, method))
 594     {
 595         bOk = false;
 596     }
 597     if (method->update)
 598     {
 599         report_error(fp, method->name, "error: modifier should not have update");
 600         bOk = false;
 601     }
 602     if (method->type == POS_VALUE && !method->pupdate)
 603     {
 604         report_error(fp, method->name, "error: evaluation function missing");
 605         bOk = false;
 606     }
 607
 608     return bOk;
 609 }
 610
 611 /*!
 612  * \param[in,out] symtab Symbol table to register the method to.
 613  * \param[in]     name   Name under which the method should be registered.
 614  * \param[in]     method Method to register.
 615  * \returns       0 on success, EINVAL if there was something wrong with the
 616  *   method.
 617  *
 618  * \p name does not need to match the name of the method, and the same
 619  * method can be registered multiple times under different names.
 620  * If \p name equals some previously registered name,
 621  * an error message is printed and the method is not registered.
 622  *
 623  * The function also performs some sanity checking on the input method,
 624  * and refuses to register it if there are problems.
 625  * Some problems only generate warnings.
 626  * All problems are described to \p stderr.
 627  */
 628 int
 629 gmx_ana_selmethod_register(gmx::SelectionParserSymbolTable *symtab,
 630                            const char *name, gmx_ana_selmethod_t *method)
 631 {
 632     bool bOk;
 633
 634     /* Check the method */
 635     if (method->flags & SMETH_MODIFIER)
 636     {
 637         bOk = check_modifier(stderr, method, *symtab);
 638     }
 639     else
 640     {
 641         bOk = check_method(stderr, method, *symtab);
 642     }
 643     /* Try to register the method if everything is ok */
 644     if (bOk)
 645     {
 646         try
 647         {
 648             symtab->addMethod(name, method);
 649         }
 650         catch (const gmx::APIError &ex)
 651         {
 652             report_error(stderr, name, ex.what());
 653             bOk = false;
 654         }
 655     }
 656     if (!bOk)
 657     {
 658         report_error(stderr, name, "warning: not registered");
 659         return EINVAL;
 660     }
 661     return 0;
 662 }
 663
 664 /*!
 665  * \param[in,out] symtab Symbol table to register the methods to.
 666  * \returns       0 on success, -1 if any of the default methods could not be
 667  *   registered.
 668  */
 669 int
 670 gmx_ana_selmethod_register_defaults(gmx::SelectionParserSymbolTable *symtab)
 671 {
 672     size_t i;
 673     int    rc;
 674     bool   bOk;
 675
 676     bOk = true;
 677     for (i = 0; i < asize(smtable_def); ++i)
 678     {
 679         gmx_ana_selmethod_t *method = smtable_def[i].method;
 680
 681         if (smtable_def[i].name == NULL)
 682         {
 683             rc = gmx_ana_selmethod_register(symtab, method->name, method);
 684         }
 685         else
 686         {
 687             rc = gmx_ana_selmethod_register(symtab, smtable_def[i].name, method);
 688         }
 689         if (rc != 0)
 690         {
 691             bOk = false;
 692         }
 693     }
 694     return bOk ? 0 : -1;
 695 }
 696
 697 /*!
 698  * \param[in] name   Name of the parameter to search.
 699  * \param[in] method Method to search for the parameter.
 700  * \returns   Pointer to the parameter in the
 701  *   \ref gmx_ana_selmethod_t::param "method->param" array,
 702  *   or NULL if no parameter with name \p name was found.
 703  *
 704  * This is a simple wrapper for gmx_ana_selparam_find().
 705  */
 706 gmx_ana_selparam_t *
 707 gmx_ana_selmethod_find_param(const char *name, gmx_ana_selmethod_t *method)
 708 {
 709     return gmx_ana_selparam_find(name, method->nparams, method->param);
 710 }