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