src/gmxlib/selection/scanner_internal.c

   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 Helper functions for the selection tokenizer.
  33  *
  34  * This file implements the functions in the headers scanner.h and
  35  * scanner_internal.h.
  36  */
  37 /*! \internal file scanner_flex.h
  38  * \brief Generated (from scanner.l) header file by Flex.
  39  *
  40  * This file contains definitions of functions that are needed in
  41  * scanner_internal.c.
  42  */
  43 #ifdef HAVE_CONFIG_H
  44 #include <config.h>
  45 #endif
  46
  47 #include <stdlib.h>
  48 #include <typedefs.h>
  49 #include <smalloc.h>
  50 #include <string.h>
  51
  52 #include "string2.h"
  53 #include "gmx_fatal.h"
  54
  55 #include <selmethod.h>
  56
  57 #include "parsetree.h"
  58 #include "selcollection.h"
  59 #include "selelem.h"
  60 #include "symrec.h"
  61
  62 #include "parser.h"
  63 #include "scanner.h"
  64 #include "scanner_internal.h"
  65
  66 #define STRSTORE_ALLOCSTEP 1000
  67
  68 /* These are defined as macros in the generated scanner_flex.h.
  69  * We undefine them here to have them as variable names in the subroutines.
  70  * There are other ways of doing this, but this is probably the easiest. */
  71 #undef yylval
  72 #undef yytext
  73 #undef yyleng
  74
  75 static bool
  76 read_stdin_line(gmx_sel_lexer_t *state)
  77 {
  78     char *ptr     = state->inputstr;
  79     int   max_len = state->nalloc_input;
  80     int   totlen = 0;
  81
  82     if (feof(stdin))
  83     {
  84         return FALSE;
  85     }
  86     if (state->bInteractive)
  87     {
  88         fprintf(stderr, "> ");
  89     }
  90     while (fgets(ptr, max_len, stdin))
  91     {
  92         int len = strlen(ptr);
  93
  94         totlen += len;
  95         if (len >= 2 && ptr[len - 1] == '\n' && ptr[len - 2] == '\\')
  96         {
  97             if (state->bInteractive)
  98             {
  99                 fprintf(stderr, "... ");
 100             }
 101         }
 102         else if (len >= 1 && ptr[len - 1] == '\n')
 103         {
 104             break;
 105         }
 106         else if (len < max_len - 1)
 107         {
 108             if (state->bInteractive)
 109             {
 110                 fprintf(stderr, "\n");
 111             }
 112             break;
 113         }
 114         ptr     += len;
 115         max_len -= len;
 116         if (max_len <= 2)
 117         {
 118             max_len += state->nalloc_input;
 119             state->nalloc_input *= 2;
 120             len = ptr - state->inputstr;
 121             srenew(state->inputstr, state->nalloc_input);
 122             ptr = state->inputstr + len;
 123         }
 124     }
 125     if (ferror(stdin))
 126     {
 127         gmx_input("selection reading failed");
 128     }
 129     state->bCmdStart = totlen > 0;
 130     return totlen > 0;
 131 }
 132
 133 int
 134 _gmx_sel_yyblex(YYSTYPE *yylval, yyscan_t yyscanner)
 135 {
 136     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(yyscanner);
 137     int token;
 138
 139     if (!state->bBuffer && !state->inputstr)
 140     {
 141         state->nalloc_input = 1024;
 142         snew(state->inputstr, state->nalloc_input);
 143         read_stdin_line(state);
 144         _gmx_sel_set_lex_input_str(yyscanner, state->inputstr);
 145     }
 146     token = _gmx_sel_yylex(yylval, yyscanner);
 147     while (state->inputstr && token == 0 && read_stdin_line(state))
 148     {
 149         _gmx_sel_set_lex_input_str(yyscanner, state->inputstr);
 150         token = _gmx_sel_yylex(yylval, yyscanner);
 151     }
 152     return token;
 153 }
 154
 155 static int
 156 init_param_token(YYSTYPE *yylval, gmx_ana_selparam_t *param, bool bBoolNo)
 157 {
 158     if (bBoolNo)
 159     {
 160         snew(yylval->str, strlen(param->name) + 3);
 161         yylval->str[0] = 'n';
 162         yylval->str[1] = 'o';
 163         strcpy(yylval->str+2, param->name);
 164     }
 165     else
 166     {
 167         yylval->str = param->name ? strdup(param->name) : NULL;
 168     }
 169     return PARAM;
 170 }
 171
 172 static int
 173 init_method_token(YYSTYPE *yylval, gmx_ana_selmethod_t *method, bool bPosMod,
 174                   gmx_sel_lexer_t *state)
 175 {
 176     /* If the previous token was not KEYWORD_POS, return EMPTY_POSMOD
 177      * before the actual method to work around a limitation in Bison. */
 178     if (!bPosMod && method->type != POS_VALUE)
 179     {
 180         state->nextmethod = method;
 181         return EMPTY_POSMOD;
 182     }
 183     yylval->meth = method;
 184     if (!(method->flags & SMETH_MODIFIER) && method->nparams == 0)
 185     {
 186         /* Keyword */
 187         switch (method->type)
 188         {
 189             case INT_VALUE:   return KEYWORD_NUMERIC;
 190             case REAL_VALUE:  return KEYWORD_NUMERIC;
 191             case STR_VALUE:   return KEYWORD_STR;
 192             case GROUP_VALUE: return KEYWORD_GROUP;
 193             default:          return INVALID;
 194         }
 195     } else {
 196         /* Method with parameters or a modifier */
 197         if (method->flags & SMETH_MODIFIER)
 198         {
 199             /* Remove all methods from the stack */
 200             state->msp = -1;
 201             if (method->param[1].name == NULL)
 202             {
 203                 state->nextparam = &method->param[1];
 204             }
 205         }
 206         else
 207         {
 208             if (method->param[0].name == NULL)
 209             {
 210                 state->nextparam = &method->param[0];
 211             }
 212         }
 213         ++state->msp;
 214         if (state->msp >= state->mstack_alloc)
 215         {
 216             state->mstack_alloc += 10;
 217             srenew(state->mstack, state->mstack_alloc);
 218         }
 219         state->mstack[state->msp] = method;
 220         if (method->flags & SMETH_MODIFIER)
 221         {
 222             return MODIFIER;
 223         }
 224         switch (method->type)
 225         {
 226             case INT_VALUE:   return METHOD_NUMERIC;
 227             case REAL_VALUE:  return METHOD_NUMERIC;
 228             case POS_VALUE:   return METHOD_POS;
 229             case GROUP_VALUE: return METHOD_GROUP;
 230             default:
 231                 --state->msp;
 232                 return INVALID;
 233         }
 234     }
 235     return INVALID; /* Should not be reached */
 236 }
 237
 238 int
 239 _gmx_sel_lexer_process_pending(YYSTYPE *yylval, gmx_sel_lexer_t *state)
 240 {
 241     if (state->nextparam)
 242     {
 243         gmx_ana_selparam_t *param = state->nextparam;
 244         bool                bBoolNo = state->bBoolNo;
 245
 246         if (state->neom > 0)
 247         {
 248             --state->neom;
 249             return END_OF_METHOD;
 250         }
 251         state->nextparam = NULL;
 252         state->bBoolNo   = FALSE;
 253         _gmx_sel_lexer_add_token(param->name, -1, state);
 254         return init_param_token(yylval, param, bBoolNo);
 255     }
 256     if (state->prev_pos_kw > 0)
 257     {
 258         --state->prev_pos_kw;
 259     }
 260     if (state->nextmethod)
 261     {
 262         gmx_ana_selmethod_t *method = state->nextmethod;
 263
 264         state->nextmethod = NULL;
 265         return init_method_token(yylval, method, TRUE, state);
 266     }
 267     return 0;
 268 }
 269
 270 int
 271 _gmx_sel_lexer_process_identifier(YYSTYPE *yylval, char *yytext, size_t yyleng,
 272                                   gmx_sel_lexer_t *state)
 273 {
 274     gmx_sel_symrec_t *symbol;
 275     e_symbol_t        symtype;
 276
 277     /* Check if the identifier matches with a parameter name */
 278     if (state->msp >= 0)
 279     {
 280         gmx_ana_selparam_t *param = NULL;
 281         bool                bBoolNo = FALSE;
 282         int                 sp = state->msp;
 283         while (!param && sp >= 0)
 284         {
 285             int             i;
 286             for (i = 0; i < state->mstack[sp]->nparams; ++i)
 287             {
 288                 /* Skip NULL parameters and too long parameters */
 289                 if (state->mstack[sp]->param[i].name == NULL
 290                     || strlen(state->mstack[sp]->param[i].name) > yyleng)
 291                 {
 292                     continue;
 293                 }
 294                 if (!strncmp(state->mstack[sp]->param[i].name, yytext, yyleng))
 295                 {
 296                     param = &state->mstack[sp]->param[i];
 297                     break;
 298                 }
 299                 /* Check separately for a 'no' prefix on boolean parameters */
 300                 if (state->mstack[sp]->param[i].val.type == NO_VALUE
 301                     && yyleng > 2 && yytext[0] == 'n' && yytext[1] == 'o'
 302                     && !strncmp(state->mstack[sp]->param[i].name, yytext+2, yyleng-2))
 303                 {
 304                     param = &state->mstack[sp]->param[i];
 305                     bBoolNo = TRUE;
 306                     break;
 307                 }
 308             }
 309             if (!param)
 310             {
 311                 --sp;
 312             }
 313         }
 314         if (param)
 315         {
 316             if (param->val.type == NO_VALUE && !bBoolNo)
 317             {
 318                 state->bMatchBool = TRUE;
 319             }
 320             if (sp < state->msp)
 321             {
 322                 state->neom = state->msp - sp - 1;
 323                 state->nextparam = param;
 324                 state->bBoolNo   = bBoolNo;
 325                 return END_OF_METHOD;
 326             }
 327             _gmx_sel_lexer_add_token(param->name, -1, state);
 328             return init_param_token(yylval, param, bBoolNo);
 329         }
 330     }
 331
 332     /* Check if the identifier matches with a symbol */
 333     symbol = _gmx_sel_find_symbol_len(state->sc->symtab, yytext, yyleng, FALSE);
 334     /* If there is no match, return the token as a string */
 335     if (!symbol)
 336     {
 337         yylval->str = strndup(yytext, yyleng);
 338         _gmx_sel_lexer_add_token(yytext, yyleng, state);
 339         return IDENTIFIER;
 340     }
 341     _gmx_sel_lexer_add_token(_gmx_sel_sym_name(symbol), -1, state);
 342     symtype = _gmx_sel_sym_type(symbol);
 343     /* Reserved symbols should have been caught earlier */
 344     if (symtype == SYMBOL_RESERVED)
 345     {
 346         return INVALID;
 347     }
 348     /* For variable symbols, return the type of the variable value */
 349     if (symtype == SYMBOL_VARIABLE)
 350     {
 351         t_selelem *var;
 352
 353         var = _gmx_sel_sym_value_var(symbol);
 354         /* Return simple tokens for constant variables */
 355         if (var->type == SEL_CONST)
 356         {
 357             switch (var->v.type)
 358             {
 359                 case INT_VALUE:
 360                     yylval->i = var->v.u.i[0];
 361                     return TOK_INT;
 362                 case REAL_VALUE:
 363                     yylval->r = var->v.u.r[0];
 364                     return TOK_REAL;
 365                 case POS_VALUE:
 366                     break;
 367                 default:
 368                     return INVALID;
 369             }
 370         }
 371         yylval->sel = var;
 372         switch (var->v.type)
 373         {
 374             case INT_VALUE:   return VARIABLE_NUMERIC;
 375             case REAL_VALUE:  return VARIABLE_NUMERIC;
 376             case POS_VALUE:   return VARIABLE_POS;
 377             case GROUP_VALUE: return VARIABLE_GROUP;
 378             default:          return INVALID;
 379         }
 380         return INVALID;
 381     }
 382     /* For method symbols, return the correct type */
 383     if (symtype == SYMBOL_METHOD)
 384     {
 385         gmx_ana_selmethod_t *method;
 386
 387         method = _gmx_sel_sym_value_method(symbol);
 388         return init_method_token(yylval, method, state->prev_pos_kw > 0, state);
 389     }
 390     /* For position symbols, we need to return KEYWORD_POS, but we also need
 391      * some additional handling. */
 392     if (symtype == SYMBOL_POS)
 393     {
 394         state->bMatchOf = TRUE;
 395         yylval->str = _gmx_sel_sym_name(symbol);
 396         state->prev_pos_kw = 2;
 397         return KEYWORD_POS;
 398     }
 399     /* Should not be reached */
 400     return INVALID;
 401 }
 402
 403 void
 404 _gmx_sel_lexer_add_token(const char *str, int len, gmx_sel_lexer_t *state)
 405 {
 406     /* Do nothing if the string is empty, or if it is a space and there is
 407      * no other text yet. */
 408     if (!str || len == 0 || strlen(str) == 0
 409         || (str[0] == ' ' && str[1] == 0 && state->pslen == 0))
 410     {
 411         return;
 412     }
 413     if (len < 0)
 414     {
 415         len = strlen(str);
 416     }
 417     /* Allocate more memory if necessary */
 418     if (state->nalloc_psel - state->pslen < len)
 419     {
 420         int incr = STRSTORE_ALLOCSTEP < len ? len : STRSTORE_ALLOCSTEP;
 421         state->nalloc_psel += incr;
 422         srenew(state->pselstr, state->nalloc_psel);
 423     }
 424     /* Append the token to the stored string */
 425     strncpy(state->pselstr + state->pslen, str, len);
 426     state->pslen += len;
 427     state->pselstr[state->pslen] = 0;
 428 }
 429
 430 int
 431 _gmx_sel_init_lexer(yyscan_t *scannerp, struct gmx_ana_selcollection_t *sc,
 432                     bool bInteractive, int maxnr,
 433                     struct gmx_ana_indexgrps_t *grps)
 434 {
 435     gmx_sel_lexer_t *state;
 436     int              rc;
 437
 438     rc = _gmx_sel_yylex_init(scannerp);
 439     if (rc != 0)
 440     {
 441         return rc;
 442     }
 443
 444     snew(state, 1);
 445     state->sc        = sc;
 446     state->grps      = grps;
 447     state->nexpsel   = (maxnr > 0 ? sc->nr + maxnr : -1);
 448
 449     state->bInteractive = bInteractive;
 450     state->nalloc_input = 0;
 451     state->inputstr     = NULL;
 452
 453     snew(state->pselstr, STRSTORE_ALLOCSTEP);
 454     state->pselstr[0]   = 0;
 455     state->pslen        = 0;
 456     state->nalloc_psel  = STRSTORE_ALLOCSTEP;
 457
 458     snew(state->mstack, 20);
 459     state->mstack_alloc = 20;
 460     state->msp          = -1;
 461     state->neom         = 0;
 462     state->nextparam    = NULL;
 463     state->nextmethod   = NULL;
 464     state->prev_pos_kw  = 0;
 465     state->bBoolNo      = FALSE;
 466     state->bMatchOf     = FALSE;
 467     state->bMatchBool   = FALSE;
 468     state->bCmdStart    = TRUE;
 469     state->bBuffer      = FALSE;
 470
 471     _gmx_sel_yyset_extra(state, *scannerp);
 472     return 0;
 473 }
 474
 475 void
 476 _gmx_sel_free_lexer(yyscan_t scanner)
 477 {
 478     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(scanner);
 479
 480     sfree(state->inputstr);
 481     sfree(state->pselstr);
 482     sfree(state->mstack);
 483     if (state->bBuffer)
 484     {
 485         _gmx_sel_yy_delete_buffer(state->buffer, scanner);
 486     }
 487     sfree(state);
 488     _gmx_sel_yylex_destroy(scanner);
 489 }
 490
 491 bool
 492 _gmx_sel_is_lexer_interactive(yyscan_t scanner)
 493 {
 494     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(scanner);
 495     return state->bInteractive;
 496 }
 497
 498 struct gmx_ana_selcollection_t *
 499 _gmx_sel_lexer_selcollection(yyscan_t scanner)
 500 {
 501     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(scanner);
 502     return state->sc;
 503 }
 504
 505 struct gmx_ana_indexgrps_t *
 506 _gmx_sel_lexer_indexgrps(yyscan_t scanner)
 507 {
 508     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(scanner);
 509     return state->grps;
 510 }
 511
 512 int
 513 _gmx_sel_lexer_exp_selcount(yyscan_t scanner)
 514 {
 515     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(scanner);
 516     return state->nexpsel;
 517 }
 518
 519 const char *
 520 _gmx_sel_lexer_pselstr(yyscan_t scanner)
 521 {
 522     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(scanner);
 523     return state->pselstr;
 524 }
 525
 526 void
 527 _gmx_sel_lexer_clear_pselstr(yyscan_t scanner)
 528 {
 529     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(scanner);
 530     state->pselstr[0] = 0;
 531     state->pslen      = 0;
 532 }
 533
 534 void
 535 _gmx_sel_lexer_clear_method_stack(yyscan_t scanner)
 536 {
 537     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(scanner);
 538
 539     state->msp = -1;
 540 }
 541
 542 void
 543 _gmx_sel_finish_method(yyscan_t scanner)
 544 {
 545     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(scanner);
 546
 547     if (state->msp >= 0)
 548     {
 549         --state->msp;
 550     }
 551 }
 552
 553 void
 554 _gmx_sel_set_lex_input_file(yyscan_t scanner, FILE *fp)
 555 {
 556     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(scanner);
 557
 558     state->bBuffer = TRUE;
 559     state->buffer  = _gmx_sel_yy_create_buffer(fp, YY_BUF_SIZE, scanner);
 560     _gmx_sel_yy_switch_to_buffer(state->buffer, scanner);
 561 }
 562
 563 void
 564 _gmx_sel_set_lex_input_str(yyscan_t scanner, const char *str)
 565 {
 566     gmx_sel_lexer_t *state = _gmx_sel_yyget_extra(scanner);
 567
 568     if (state->bBuffer)
 569     {
 570         _gmx_sel_yy_delete_buffer(state->buffer, scanner);
 571     }
 572     state->bBuffer = TRUE;
 573     state->buffer  = _gmx_sel_yy_scan_string(str, scanner);
 574 }