AtomParser.C Source File

00001 
00002 # line 2 "AtomParser.y"
00003 /***************************************************************************
00004  *cr                                                                       
00005  *cr            (C) Copyright 1995-2019 The Board of Trustees of the           
00006  *cr                        University of Illinois                       
00007  *cr                         All Rights Reserved                        
00008  *cr                                                                   
00009  ***************************************************************************/
00010 
00011 /***************************************************************************
00012  * RCS INFORMATION:
00013  *
00014  *      $RCSfile: AtomParser.C,v $
00015  *      $Author: johns $        $Locker:  $             $State: Exp $
00016  *      $Revision: 1.28 $       $Date: 2019/01/17 21:20:58 $
00017  *
00018  ***************************************************************************
00019  * DESCRIPTION:
00020  *  a parser for atom selections
00021  *
00022  ***************************************************************************/
00023 
00024 
00025 
00026 #include <stdio.h>
00027 #include <string.h>
00028 #include "AtomParser.h"
00029 #include "Inform.h"
00030 
00031 #if !defined(_MSC_VER)
00032 extern "C" int yyparse();
00033 #endif
00034 extern "C" void yyerror(const char *s);
00035 extern "C" int yylex();
00036 
00037 atomparser_node *atomparser_result;
00038 
00039 # line 39 "AtomParser.y"
00040 typedef union
00041 #ifdef __cplusplus
00042         YYSTYPE
00043 #endif
00044  {
00045         int ival;
00046         double dval;
00047         atomparser_node *node;
00048 } YYSTYPE;
00049 # define KEY 257
00050 # define WITHIN 258
00051 # define EXWITHIN 259
00052 # define PBWITHIN 260
00053 # define WITHINBONDS 261
00054 # define MAXRINGSIZE 262
00055 # define RINGSIZE 263
00056 # define WHERE 264
00057 # define FUNC 265
00058 # define STRFCTN 266
00059 # define SAME 267
00060 # define NEAREST 268
00061 # define SINGLE 269
00062 # define FROM 270
00063 # define OF 271
00064 # define AS 272
00065 # define THROUGH 273
00066 # define PARSEERROR 274
00067 # define RANGE 275
00068 # define FLOATVAL 276
00069 # define INTVAL 277
00070 # define STRWORD 278
00071 # define COMPARE 279
00072 # define OR 280
00073 # define AND 281
00074 # define LT 282
00075 # define LE 283
00076 # define EQ 284
00077 # define GE 285
00078 # define GT 286
00079 # define NE 287
00080 # define NLT 288
00081 # define NLE 289
00082 # define NEQ 290
00083 # define NGE 291
00084 # define NGT 292
00085 # define NNE 293
00086 # define SLT 294
00087 # define SLE 295
00088 # define SEQ 296
00089 # define SGE 297
00090 # define SGT 298
00091 # define SNE 299
00092 # define MATCH 300
00093 # define ADD 301
00094 # define SUB 302
00095 # define MULT 303
00096 # define DIV 304
00097 # define MOD 305
00098 # define EXP 306
00099 # define nonassoc 307
00100 # define NOT 308
00101 # define UMINUS 309
00102 
00103 #if !defined(_MSC_VER) && !defined(ARCH_TRU64)
00104 #include <inttypes.h>
00105 #endif
00106 
00107 #if 1
00108 //#ifdef __STDC__
00109 #include <stdlib.h>
00110 #include <string.h>
00111 #define YYCONST const
00112 #else
00113 #include <malloc.h>
00114 #include <memory.h>
00115 #define YYCONST
00116 #endif
00117 
00118 #if !defined(_MSC_VER) && !defined(__APPLE__) && !defined(ARCH_FREEBSD) && !defined(ARCH_FREEBSDAMD64) && !defined(ARCH_ANDROIDARMV7A)
00119 #include <values.h>
00120 #endif
00121 
00122 #if defined(__cplusplus) || defined(__STDC__)
00123 
00124 #if defined(__cplusplus) && defined(__EXTERN_C__)
00125 extern "C" {
00126 #endif
00127 #ifndef yyerror
00128 #if defined(__cplusplus)
00129         void yyerror(YYCONST char *);
00130 #endif
00131 #endif
00132 #ifndef yylex
00133         int yylex(void);
00134 #endif
00135         int yyparse(void);
00136 #if defined(__cplusplus) && defined(__EXTERN_C__)
00137 }
00138 #endif
00139 
00140 #endif
00141 
00142 #define yyclearin yychar = -1
00143 #define yyerrok yyerrflag = 0
00144 extern int yychar;
00145 extern int yyerrflag;
00146 YYSTYPE yylval;
00147 YYSTYPE yyval;
00148 typedef int yytabelem;
00149 #ifndef YYMAXDEPTH
00150 #define YYMAXDEPTH 150
00151 #endif
00152 #if YYMAXDEPTH > 0
00153 int yy_yys[YYMAXDEPTH], *yys = yy_yys;
00154 YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv;
00155 #else   /* user does initial allocation */
00156 int *yys;
00157 YYSTYPE *yyv;
00158 #endif
00159 static int yymaxdepth = YYMAXDEPTH;
00160 # define YYERRCODE 256
00161 
00162 # line 279 "AtomParser.y"
00163 
00164 
00165 extern "C" void yyerror(const char *s) {
00166   msgErr << s << sendmsg;
00167 }
00168 
00169 // everything comes from a string, so there is no way to
00170 // reset "yyin" (or whatever) to the next input
00171 extern "C" int yywrap(void) {
00172   return 1;
00173 }
00174 
00175 static YYCONST yytabelem yyexca[] ={
00176 -1, 0,
00177         0, 1,
00178         -2, 0,
00179 -1, 1,
00180         0, -1,
00181         -2, 0,
00182         };
00183 # define YYNPROD 59
00184 # define YYLAST 368
00185 static YYCONST yytabelem yyact[]={
00186 
00187      4,    49,    50,    51,    52,    53,    54,    55,    56,    57,
00188     58,    59,    60,    61,    43,    44,    47,    48,    45,    46,
00189     46,    26,     4,    43,    44,    47,    48,    45,    46,    47,
00190     48,    45,    46,    76,    27,    26,    67,    66,    65,    33,
00191     34,    40,    39,    38,    77,    37,    94,    82,    85,    81,
00192    106,    80,    79,    78,    84,    83,    77,    41,     2,    64,
00193     73,    63,    62,    28,    30,    31,    32,     1,     8,     7,
00194     42,     0,     0,     0,    17,     0,     0,    35,    36,    29,
00195      0,     0,    68,     0,     0,    74,    75,     0,     0,     0,
00196      0,     0,     0,     0,     0,     0,     0,     0,    69,    72,
00197      0,     0,     0,     0,     0,    70,     0,     0,     0,     0,
00198      0,     0,     0,     0,     0,     0,     0,    86,    87,    88,
00199     89,    90,    91,    92,    93,     0,     0,     0,     0,     0,
00200     93,     0,     0,     0,     0,     0,     0,    97,    98,    99,
00201    100,   101,   102,   103,   104,    95,     0,     0,    96,     0,
00202      0,     0,     0,     0,   105,     0,     0,     0,     0,     0,
00203      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00204      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00205      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00206      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00207      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00208      0,     0,     0,     0,     0,     0,     3,    18,     9,    10,
00209     11,    12,    14,    15,     0,    25,    19,    16,    13,     6,
00210      0,     0,     0,     0,     0,     0,    20,    21,    22,    18,
00211      9,    10,    11,    12,    14,    15,     0,    25,    19,    16,
00212     13,     6,     0,     0,     0,     0,     0,     0,    20,    21,
00213     22,    24,    23,     0,     0,     0,     0,     0,     5,     0,
00214      0,     0,    27,    26,     0,     0,     0,     0,     0,     0,
00215      0,     0,     0,    24,    23,     0,     0,     0,     0,     0,
00216      5,    49,    50,    51,    52,    53,    54,    55,    56,    57,
00217     58,    59,    60,    61,    43,    44,    47,    48,    45,    46,
00218     43,    44,    47,    48,    45,    46,    43,    44,    47,    48,
00219     45,    46,    71,     0,     0,     0,     0,     0,     0,     0,
00220     25,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00221      0,    20,    21,    22,     0,     0,     0,     0,     0,     0,
00222      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00223      0,     0,     0,     0,     0,     0,    24,    23 };
00224 static YYCONST yytabelem yypact[]={
00225 
00226    -40,-10000000,  -246,-10000000,   -18,   -18,   -18,-10000000,-10000000,  -237,
00227   -237,  -237,  -232,  -234,  -235,  -236,  -200,  -287,  -240,  -240,
00228 -10000000,-10000000,-10000000,    65,    65,    20,   -18,   -18,    -8,     3,
00229 -10000000,  -246,  -218,-10000000,-10000000,  -219,  -220,  -222,  -226,  -215,
00230   -216,  -224,    65,    65,    65,    65,    65,    65,    65,-10000000,
00231 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
00232 -10000000,-10000000,  -240,-10000000,  -227,-10000000,-10000000,-10000000,  -240,-10000000,
00233     65,-10000000,-10000000,    65,-10000000,  -260,-10000000,-10000000,   -18,   -18,
00234    -18,   -18,   -18,   -18,   -18,   -18,  -278,  -274,  -274,  -286,
00235 -10000000,  -286,  -286,-10000000,  -240,    15,     9,  -246,  -246,  -246,
00236   -246,  -246,  -246,  -246,  -246,-10000000,-10000000 };
00237 static YYCONST yytabelem yypgo[]={
00238 
00239      0,    70,    58,    74,    69,    62,    59,    61,    68,    66,
00240     67 };
00241 static YYCONST yytabelem yyr1[]={
00242 
00243      0,    10,    10,    10,     2,     2,     2,     2,     2,     2,
00244      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00245      2,     4,     8,     6,     6,     6,     7,     7,     5,     5,
00246      9,     9,     3,     3,     3,     3,     3,     3,     3,     3,
00247      3,     3,     3,     3,     3,     3,     1,     1,     1,     1,
00248      1,     1,     1,     1,     1,     1,     1,     1,     1 };
00249 static YYCONST yytabelem yyr2[]={
00250 
00251      0,     1,     3,     3,     7,     5,     3,     5,     7,     7,
00252      3,     3,     9,     9,     9,     9,     9,     9,     9,     9,
00253      7,     5,     5,     3,     3,     3,     3,     7,     3,     5,
00254      3,     3,     3,     3,     3,     7,     7,     7,     5,     5,
00255      7,     7,     7,     7,     3,     9,     3,     3,     3,     3,
00256      3,     3,     3,     3,     3,     3,     3,     3,     3 };
00257 static YYCONST yytabelem yychk[]={
00258 
00259 -10000000,   -10,    -2,   256,    40,   308,   269,    -4,    -8,   258,
00260    259,   260,   261,   268,   262,   263,   267,    -3,   257,   266,
00261    276,   277,   278,   302,   301,   265,   281,   280,    -2,    -3,
00262     -2,    -2,    -9,   276,   277,    -9,    -9,   277,   277,   277,
00263    277,   257,    -1,   301,   302,   305,   306,   303,   304,   288,
00264    289,   290,   291,   292,   293,   294,   295,   296,   297,   298,
00265    299,   300,    -5,    -7,    -6,   278,   277,   276,    -5,    -3,
00266     40,   257,    -3,    40,    -2,    -2,    41,    41,   271,   271,
00267    271,   271,   273,   270,   270,   272,    -3,    -3,    -3,    -3,
00268     -3,    -3,    -3,    -7,   273,    -3,    -3,    -2,    -2,    -2,
00269     -2,    -2,    -2,    -2,    -2,    -6,    41 };
00270 static YYCONST yytabelem yydef[]={
00271 
00272     -2,    -2,     2,     3,     0,     0,     6,    10,    11,     0,
00273      0,     0,     0,     0,     0,     0,     0,     0,    44,     0,
00274     32,    33,    34,     0,     0,     0,     0,     0,     0,     0,
00275      5,     7,     0,    30,    31,     0,     0,     0,     0,     0,
00276      0,     0,     0,     0,     0,     0,     0,     0,     0,    46,
00277     47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
00278     57,    58,    21,    28,    26,    23,    24,    25,    22,    38,
00279      0,    44,    39,     0,     8,     9,     4,    35,     0,     0,
00280      0,     0,     0,     0,     0,     0,    20,    36,    37,    40,
00281     41,    42,    43,    29,     0,     0,     0,    12,    13,    14,
00282     15,    16,    17,    18,    19,    27,    45 };
00283 typedef struct
00284 #ifdef __cplusplus
00285         yytoktype
00286 #endif
00287 {
00288 #ifdef __cplusplus
00289 const
00290 #endif
00291 char *t_name; int t_val; } yytoktype;
00292 #ifndef YYDEBUG
00293 #       define YYDEBUG  0       /* don't allow debugging */
00294 #endif
00295 
00296 #if YYDEBUG
00297 
00298 yytoktype yytoks[] =
00299 {
00300         "KEY",  257,
00301         "WITHIN",       258,
00302         "EXWITHIN",     259,
00303         "PBWITHIN",     260,
00304         "WITHINBONDS",  261,
00305         "MAXRINGSIZE",  262,
00306         "RINGSIZE",     263,
00307         "WHERE",        264,
00308         "FUNC", 265,
00309         "STRFCTN",      266,
00310         "SAME", 267,
00311         "NEAREST",      268,
00312         "SINGLE",       269,
00313         "FROM", 270,
00314         "OF",   271,
00315         "AS",   272,
00316         "THROUGH",      273,
00317         "PARSEERROR",   274,
00318         "RANGE",        275,
00319         "FLOATVAL",     276,
00320         "INTVAL",       277,
00321         "STRWORD",      278,
00322         "COMPARE",      279,
00323         "OR",   280,
00324         "AND",  281,
00325         "LT",   282,
00326         "LE",   283,
00327         "EQ",   284,
00328         "GE",   285,
00329         "GT",   286,
00330         "NE",   287,
00331         "NLT",  288,
00332         "NLE",  289,
00333         "NEQ",  290,
00334         "NGE",  291,
00335         "NGT",  292,
00336         "NNE",  293,
00337         "SLT",  294,
00338         "SLE",  295,
00339         "SEQ",  296,
00340         "SGE",  297,
00341         "SGT",  298,
00342         "SNE",  299,
00343         "MATCH",        300,
00344         "ADD",  301,
00345         "SUB",  302,
00346         "MULT", 303,
00347         "DIV",  304,
00348         "MOD",  305,
00349         "EXP",  306,
00350         "nonassoc",     307,
00351         "NOT",  308,
00352         "UMINUS",       309,
00353         "-unknown-",    -1      /* ends search */
00354 };
00355 
00356 #ifdef __cplusplus
00357 const
00358 #endif
00359 char * yyreds[] =
00360 {
00361         "-no such reduction-",
00362         "selection_list : /* empty */",
00363         "selection_list : selection",
00364         "selection_list : error",
00365         "selection : '(' selection ')'",
00366         "selection : NOT selection",
00367         "selection : SINGLE",
00368         "selection : SINGLE selection",
00369         "selection : selection AND selection",
00370         "selection : selection OR selection",
00371         "selection : keyword_list",
00372         "selection : strfctn_list",
00373         "selection : WITHIN number OF selection",
00374         "selection : EXWITHIN number OF selection",
00375         "selection : PBWITHIN number OF selection",
00376         "selection : WITHINBONDS INTVAL OF selection",
00377         "selection : NEAREST INTVAL THROUGH selection",
00378         "selection : MAXRINGSIZE INTVAL FROM selection",
00379         "selection : RINGSIZE INTVAL FROM selection",
00380         "selection : SAME KEY AS selection",
00381         "selection : expression compare expression",
00382         "keyword_list : KEY string_list",
00383         "strfctn_list : STRFCTN string_list",
00384         "word : STRWORD",
00385         "word : INTVAL",
00386         "word : FLOATVAL",
00387         "string_list_ele : word",
00388         "string_list_ele : word THROUGH word",
00389         "string_list : string_list_ele",
00390         "string_list : string_list string_list_ele",
00391         "number : FLOATVAL",
00392         "number : INTVAL",
00393         "expression : FLOATVAL",
00394         "expression : INTVAL",
00395         "expression : STRWORD",
00396         "expression : '(' expression ')'",
00397         "expression : expression ADD expression",
00398         "expression : expression SUB expression",
00399         "expression : SUB expression",
00400         "expression : ADD expression",
00401         "expression : expression MOD expression",
00402         "expression : expression EXP expression",
00403         "expression : expression MULT expression",
00404         "expression : expression DIV expression",
00405         "expression : KEY",
00406         "expression : FUNC '(' expression ')'",
00407         "compare : NLT",
00408         "compare : NLE",
00409         "compare : NEQ",
00410         "compare : NGE",
00411         "compare : NGT",
00412         "compare : NNE",
00413         "compare : SLT",
00414         "compare : SLE",
00415         "compare : SEQ",
00416         "compare : SGE",
00417         "compare : SGT",
00418         "compare : SNE",
00419         "compare : MATCH",
00420 };
00421 #endif /* YYDEBUG */
00422 # line  1 "/usr/ccs/bin/yaccpar"
00423 /*
00424  * Copyright (c) 1993 by Sun Microsystems, Inc.
00425  */
00426 
00427 #pragma ident   "@(#)yaccpar    6.16    99/01/20 SMI"
00428 
00429 /*
00430 ** Skeleton parser driver for yacc output
00431 */
00432 
00433 /*
00434 ** yacc user known macros and defines
00435 */
00436 #define YYERROR         goto yyerrlab
00437 #define YYACCEPT        return(0)
00438 #define YYABORT         return(1)
00439 #define YYBACKUP( newtoken, newvalue )\
00440 {\
00441         if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
00442         {\
00443                 yyerror( "syntax error - cannot backup" );\
00444                 goto yyerrlab;\
00445         }\
00446         yychar = newtoken;\
00447         yystate = *yyps;\
00448         yylval = newvalue;\
00449         goto yynewstate;\
00450 }
00451 #define YYRECOVERING()  (!!yyerrflag)
00452 #define YYNEW(type)     malloc(sizeof(type) * yynewmax)
00453 #define YYCOPY(to, from, type) \
00454         (type *) memcpy(to, (char *) from, yymaxdepth * sizeof (type))
00455 #define YYENLARGE( from, type) \
00456         (type *) realloc((char *) from, yynewmax * sizeof(type))
00457 #ifndef YYDEBUG
00458 #       define YYDEBUG  1       /* make debugging available */
00459 #endif
00460 
00461 /*
00462 ** user known globals
00463 */
00464 int yydebug;                    /* set to 1 to get debugging */
00465 
00466 /*
00467 ** driver internal defines
00468 */
00469 #define YYFLAG          (-10000000)
00470 
00471 /*
00472 ** global variables used by the parser
00473 */
00474 YYSTYPE *yypv;                  /* top of value stack */
00475 int *yyps;                      /* top of state stack */
00476 
00477 int yystate;                    /* current state */
00478 int yytmp;                      /* extra var (lasts between blocks) */
00479 
00480 int yynerrs;                    /* number of errors */
00481 int yyerrflag;                  /* error recovery flag */
00482 int yychar;                     /* current input token number */
00483 
00484 
00485 
00486 #ifdef YYNMBCHARS
00487 #define YYLEX()         yycvtok(yylex())
00488 /*
00489 ** yycvtok - return a token if i is a wchar_t value that exceeds 255.
00490 **      If i<255, i itself is the token.  If i>255 but the neither 
00491 **      of the 30th or 31st bit is on, i is already a token.
00492 */
00493 #if defined(__STDC__) || defined(__cplusplus)
00494 int yycvtok(int i)
00495 #else
00496 int yycvtok(i) int i;
00497 #endif
00498 {
00499         int first = 0;
00500         int last = YYNMBCHARS - 1;
00501         int mid;
00502         wchar_t j;
00503 
00504         if(i&0x60000000){/*Must convert to a token. */
00505                 if( yymbchars[last].character < i ){
00506                         return i;/*Giving up*/
00507                 }
00508                 while ((last>=first)&&(first>=0)) {/*Binary search loop*/
00509                         mid = (first+last)/2;
00510                         j = yymbchars[mid].character;
00511                         if( j==i ){/*Found*/ 
00512                                 return yymbchars[mid].tvalue;
00513                         }else if( j<i ){
00514                                 first = mid + 1;
00515                         }else{
00516                                 last = mid -1;
00517                         }
00518                 }
00519                 /*No entry in the table.*/
00520                 return i;/* Giving up.*/
00521         }else{/* i is already a token. */
00522                 return i;
00523         }
00524 }
00525 #else
00526 #define YYLEX()         yylex()
00527 #endif
00529 /*
00530 ** yyparse - return 0 if worked, 1 if syntax error not recovered from
00531 */
00532 #if defined(__STDC__) || defined(__cplusplus)
00533 int yyparse(void)
00534 #else
00535 int yyparse()
00536 #endif
00537 {
00538         register YYSTYPE *yypvt = 0;    /* top of value stack for $vars */
00539 
00540 #if defined(__cplusplus) || defined(lint)
00541 /*
00542         hacks to please C++ and lint - goto's inside
00543         switch should never be executed
00544 */
00545         static int __yaccpar_lint_hack__ = 0;
00546         switch (__yaccpar_lint_hack__)
00547         {
00548                 case 1: goto yyerrlab;
00549                 case 2: goto yynewstate;
00550         }
00551 #endif
00552 
00553         /*
00554         ** Initialize externals - yyparse may be called more than once
00555         */
00556         yypv = &yyv[-1];
00557         yyps = &yys[-1];
00558         yystate = 0;
00559         yytmp = 0;
00560         yynerrs = 0;
00561         yyerrflag = 0;
00562         yychar = -1;
00563 
00564 #if YYMAXDEPTH <= 0
00565         if (yymaxdepth <= 0)
00566         {
00567                 if ((yymaxdepth = YYEXPAND(0)) <= 0)
00568                 {
00569                         yyerror("yacc initialization error");
00570                         YYABORT;
00571                 }
00572         }
00573 #endif
00574 
00575         {
00576                 register YYSTYPE *yy_pv;        /* top of value stack */
00577                 register int *yy_ps;            /* top of state stack */
00578                 register int yy_state;          /* current state */
00579                 register int  yy_n;             /* internal state number info */
00580         goto yystack;   /* moved from 6 lines above to here to please C++ */
00581 
00582                 /*
00583                 ** get globals into registers.
00584                 ** branch to here only if YYBACKUP was called.
00585                 */
00586         yynewstate:
00587                 yy_pv = yypv;
00588                 yy_ps = yyps;
00589                 yy_state = yystate;
00590                 goto yy_newstate;
00591 
00592                 /*
00593                 ** get globals into registers.
00594                 ** either we just started, or we just finished a reduction
00595                 */
00596         yystack:
00597                 yy_pv = yypv;
00598                 yy_ps = yyps;
00599                 yy_state = yystate;
00600 
00601                 /*
00602                 ** top of for (;;) loop while no reductions done
00603                 */
00604         yy_stack:
00605                 /*
00606                 ** put a state and value onto the stacks
00607                 */
00608 #if YYDEBUG
00609                 /*
00610                 ** if debugging, look up token value in list of value vs.
00611                 ** name pairs.  0 and negative (-1) are special values.
00612                 ** Note: linear search is used since time is not a real
00613                 ** consideration while debugging.
00614                 */
00615                 if ( yydebug )
00616                 {
00617                         register int yy_i;
00618 
00619                         printf( "State %d, token ", yy_state );
00620                         if ( yychar == 0 )
00621                                 printf( "end-of-file\n" );
00622                         else if ( yychar < 0 )
00623                                 printf( "-none-\n" );
00624                         else
00625                         {
00626                                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
00627                                         yy_i++ )
00628                                 {
00629                                         if ( yytoks[yy_i].t_val == yychar )
00630                                                 break;
00631                                 }
00632                                 printf( "%s\n", yytoks[yy_i].t_name );
00633                         }
00634                 }
00635 #endif /* YYDEBUG */
00636                 if ( ++yy_ps >= &yys[ yymaxdepth ] )    /* room on stack? */
00637                 {
00638                         /*
00639                         ** reallocate and recover.  Note that pointers
00640                         ** have to be reset, or bad things will happen
00641                         */
00642                         long yyps_index = (yy_ps - yys);
00643                         long yypv_index = (yy_pv - yyv);
00644                         long yypvt_index = (yypvt - yyv);
00645                         int yynewmax;
00646 #ifdef YYEXPAND
00647                         yynewmax = YYEXPAND(yymaxdepth);
00648 #else
00649                         yynewmax = 2 * yymaxdepth;      /* double table size */
00650                         if (yymaxdepth == YYMAXDEPTH)   /* first time growth */
00651                         {
00652                                 char *newyys = (char *)YYNEW(int);
00653                                 char *newyyv = (char *)YYNEW(YYSTYPE);
00654                                 if (newyys != 0 && newyyv != 0)
00655                                 {
00656                                         yys = YYCOPY(newyys, yys, int);
00657                                         yyv = YYCOPY(newyyv, yyv, YYSTYPE);
00658                                 }
00659                                 else
00660                                         yynewmax = 0;   /* failed */
00661                         }
00662                         else                            /* not first time */
00663                         {
00664                                 yys = YYENLARGE(yys, int);
00665                                 yyv = YYENLARGE(yyv, YYSTYPE);
00666                                 if (yys == 0 || yyv == 0)
00667                                         yynewmax = 0;   /* failed */
00668                         }
00669 #endif
00670                         if (yynewmax <= yymaxdepth)     /* tables not expanded */
00671                         {
00672                                 yyerror( "yacc stack overflow" );
00673                                 YYABORT;
00674                         }
00675                         yymaxdepth = yynewmax;
00676 
00677                         yy_ps = yys + yyps_index;
00678                         yy_pv = yyv + yypv_index;
00679                         yypvt = yyv + yypvt_index;
00680                 }
00681                 *yy_ps = yy_state;
00682                 *++yy_pv = yyval;
00683 
00684                 /*
00685                 ** we have a new state - find out what to do
00686                 */
00687         yy_newstate:
00688                 if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
00689                         goto yydefault;         /* simple state */
00690 #if YYDEBUG
00691                 /*
00692                 ** if debugging, need to mark whether new token grabbed
00693                 */
00694                 yytmp = yychar < 0;
00695 #endif
00696                 if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) )
00697                         yychar = 0;             /* reached EOF */
00698 #if YYDEBUG
00699                 if ( yydebug && yytmp )
00700                 {
00701                         register int yy_i;
00702 
00703                         printf( "Received token " );
00704                         if ( yychar == 0 )
00705                                 printf( "end-of-file\n" );
00706                         else if ( yychar < 0 )
00707                                 printf( "-none-\n" );
00708                         else
00709                         {
00710                                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
00711                                         yy_i++ )
00712                                 {
00713                                         if ( yytoks[yy_i].t_val == yychar )
00714                                                 break;
00715                                 }
00716                                 printf( "%s\n", yytoks[yy_i].t_name );
00717                         }
00718                 }
00719 #endif /* YYDEBUG */
00720                 if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
00721                         goto yydefault;
00722                 if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )  /*valid shift*/
00723                 {
00724                         yychar = -1;
00725                         yyval = yylval;
00726                         yy_state = yy_n;
00727                         if ( yyerrflag > 0 )
00728                                 yyerrflag--;
00729                         goto yy_stack;
00730                 }
00731 
00732         yydefault:
00733                 if ( ( yy_n = yydef[ yy_state ] ) == -2 )
00734                 {
00735 #if YYDEBUG
00736                         yytmp = yychar < 0;
00737 #endif
00738                         if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) )
00739                                 yychar = 0;             /* reached EOF */
00740 #if YYDEBUG
00741                         if ( yydebug && yytmp )
00742                         {
00743                                 register int yy_i;
00744 
00745                                 printf( "Received token " );
00746                                 if ( yychar == 0 )
00747                                         printf( "end-of-file\n" );
00748                                 else if ( yychar < 0 )
00749                                         printf( "-none-\n" );
00750                                 else
00751                                 {
00752                                         for ( yy_i = 0;
00753                                                 yytoks[yy_i].t_val >= 0;
00754                                                 yy_i++ )
00755                                         {
00756                                                 if ( yytoks[yy_i].t_val
00757                                                         == yychar )
00758                                                 {
00759                                                         break;
00760                                                 }
00761                                         }
00762                                         printf( "%s\n", yytoks[yy_i].t_name );
00763                                 }
00764                         }
00765 #endif /* YYDEBUG */
00766                         /*
00767                         ** look through exception table
00768                         */
00769                         {
00770                                 register YYCONST int *yyxi = yyexca;
00771 
00772                                 while ( ( *yyxi != -1 ) ||
00773                                         ( yyxi[1] != yy_state ) )
00774                                 {
00775                                         yyxi += 2;
00776                                 }
00777                                 while ( ( *(yyxi += 2) >= 0 ) &&
00778                                         ( *yyxi != yychar ) )
00779                                         ;
00780                                 if ( ( yy_n = yyxi[1] ) < 0 )
00781                                         YYACCEPT;
00782                         }
00783                 }
00784 
00785                 /*
00786                 ** check for syntax error
00787                 */
00788                 if ( yy_n == 0 )        /* have an error */
00789                 {
00790                         /* no worry about speed here! */
00791                         switch ( yyerrflag )
00792                         {
00793                         case 0:         /* new error */
00794                                 yyerror( "syntax error" );
00795                                 goto skip_init;
00796                         yyerrlab:
00797                                 /*
00798                                 ** get globals into registers.
00799                                 ** we have a user generated syntax type error
00800                                 */
00801                                 yy_pv = yypv;
00802                                 yy_ps = yyps;
00803                                 yy_state = yystate;
00804                         skip_init:
00805                                 yynerrs++;
00806                                 /* FALLTHRU */
00807                         case 1:
00808                         case 2:         /* incompletely recovered error */
00809                                         /* try again... */
00810                                 yyerrflag = 3;
00811                                 /*
00812                                 ** find state where "error" is a legal
00813                                 ** shift action
00814                                 */
00815                                 while ( yy_ps >= yys )
00816                                 {
00817                                         yy_n = yypact[ *yy_ps ] + YYERRCODE;
00818                                         if ( yy_n >= 0 && yy_n < YYLAST &&
00819                                                 yychk[yyact[yy_n]] == YYERRCODE)                                        {
00820                                                 /*
00821                                                 ** simulate shift of "error"
00822                                                 */
00823                                                 yy_state = yyact[ yy_n ];
00824                                                 goto yy_stack;
00825                                         }
00826                                         /*
00827                                         ** current state has no shift on
00828                                         ** "error", pop stack
00829                                         */
00830 #if YYDEBUG
00831 #       define _POP_ "Error recovery pops state %d, uncovers state %d\n"
00832                                         if ( yydebug )
00833                                                 printf( _POP_, *yy_ps,
00834                                                         yy_ps[-1] );
00835 #       undef _POP_
00836 #endif
00837                                         yy_ps--;
00838                                         yy_pv--;
00839                                 }
00840                                 /*
00841                                 ** there is no state on stack with "error" as
00842                                 ** a valid shift.  give up.
00843                                 */
00844                                 YYABORT;
00845                         case 3:         /* no shift yet; eat a token */
00846 #if YYDEBUG
00847                                 /*
00848                                 ** if debugging, look up token in list of
00849                                 ** pairs.  0 and negative shouldn't occur,
00850                                 ** but since timing doesn't matter when
00851                                 ** debugging, it doesn't hurt to leave the
00852                                 ** tests here.
00853                                 */
00854                                 if ( yydebug )
00855                                 {
00856                                         register int yy_i;
00857 
00858                                         printf( "Error recovery discards " );
00859                                         if ( yychar == 0 )
00860                                                 printf( "token end-of-file\n" );
00861                                         else if ( yychar < 0 )
00862                                                 printf( "token -none-\n" );
00863                                         else
00864                                         {
00865                                                 for ( yy_i = 0;
00866                                                         yytoks[yy_i].t_val >= 0;
00867                                                         yy_i++ )
00868                                                 {
00869                                                         if ( yytoks[yy_i].t_val
00870                                                                 == yychar )
00871                                                         {
00872                                                                 break;
00873                                                         }
00874                                                 }
00875                                                 printf( "token %s\n",
00876                                                         yytoks[yy_i].t_name );
00877                                         }
00878                                 }
00879 #endif /* YYDEBUG */
00880                                 if ( yychar == 0 )      /* reached EOF. quit */
00881                                         YYABORT;
00882                                 yychar = -1;
00883                                 goto yy_newstate;
00884                         }
00885                 }/* end if ( yy_n == 0 ) */
00886                 /*
00887                 ** reduction by production yy_n
00888                 ** put stack tops, etc. so things right after switch
00889                 */
00890 #if YYDEBUG
00891                 /*
00892                 ** if debugging, print the string that is the user's
00893                 ** specification of the reduction which is just about
00894                 ** to be done.
00895                 */
00896                 if ( yydebug )
00897                         printf( "Reduce by (%d) \"%s\"\n",
00898                                 yy_n, yyreds[ yy_n ] );
00899 #endif
00900                 yytmp = yy_n;                   /* value to switch over */
00901                 yypvt = yy_pv;                  /* $vars top of value stack */
00902                 /*
00903                 ** Look in goto table for next state
00904                 ** Sorry about using yy_state here as temporary
00905                 ** register variable, but why not, if it works...
00906                 ** If yyr2[ yy_n ] doesn't have the low order bit
00907                 ** set, then there is no action to be done for
00908                 ** this reduction.  So, no saving & unsaving of
00909                 ** registers done.  The only difference between the
00910                 ** code just after the if and the body of the if is
00911                 ** the goto yy_stack in the body.  This way the test
00912                 ** can be made before the choice of what to do is needed.
00913                 */
00914                 {
00915                         /* length of production doubled with extra bit */
00916                         register int yy_len = yyr2[ yy_n ];
00917 
00918                         if ( !( yy_len & 01 ) )
00919                         {
00920                                 yy_len >>= 1;
00921                                 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
00922                                 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
00923                                         *( yy_ps -= yy_len ) + 1;
00924                                 if ( yy_state >= YYLAST ||
00925                                         yychk[ yy_state =
00926                                         yyact[ yy_state ] ] != -yy_n )
00927                                 {
00928                                         yy_state = yyact[ yypgo[ yy_n ] ];
00929                                 }
00930                                 goto yy_stack;
00931                         }
00932                         yy_len >>= 1;
00933                         yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
00934                         yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
00935                                 *( yy_ps -= yy_len ) + 1;
00936                         if ( yy_state >= YYLAST ||
00937                                 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
00938                         {
00939                                 yy_state = yyact[ yypgo[ yy_n ] ];
00940                         }
00941                 }
00942                                         /* save until reenter driver code */
00943                 yystate = yy_state;
00944                 yyps = yy_ps;
00945                 yypv = yy_pv;
00946         }
00947         /*
00948         ** code supplied by user is placed in this switch
00949         */
00950         switch( yytmp )
00951         {
00952                 
00953 case 1:
00954 # line 76 "AtomParser.y"
00955 {// printf("Blank line.\n");
00956                                           atomparser_result =  NULL;
00957                                         } break;
00958 case 2:
00959 # line 79 "AtomParser.y"
00960 { //printf("Parsed a line\n");
00961                                           if (*atomparser_yystring != 0) {
00962     msgErr << "Selection terminated too early" << sendmsg;
00963     if (yypvt[-0].node) delete yypvt[-0].node;
00964     yypvt[-0].node = NULL;
00965                                           }
00966                                           atomparser_result = yypvt[-0].node;
00967                                         } break;
00968 case 3:
00969 # line 87 "AtomParser.y"
00970 { //printf("Error occured\n");
00971                                           atomparser_result = NULL;
00972 //                                        yyerrok;
00973                                         } break;
00974 case 4:
00975 # line 93 "AtomParser.y"
00976 { // printf("Parens\n");
00977                                           yyval.node = yypvt[-1].node;
00978                                         } break;
00979 case 5:
00980 # line 96 "AtomParser.y"
00981 { yyval.node = new atomparser_node(NOT);
00982                                           yyval.node->left = yypvt[-0].node;
00983                                         } break;
00984 case 6:
00985 # line 99 "AtomParser.y"
00986 { yyval.node = yypvt[-0].node; } break;
00987 case 7:
00988 # line 100 "AtomParser.y"
00989 { yyval.node = new atomparser_node(AND);
00990                                           yyval.node->left = yypvt[-1].node;
00991                                           yyval.node->right = yypvt[-0].node;
00992                                         } break;
00993 case 8:
00994 # line 104 "AtomParser.y"
00995 { //printf("AND\n");
00996                                           yyval.node = new atomparser_node(AND);
00997                                           yyval.node->left = yypvt[-2].node;
00998                                           yyval.node->right = yypvt[-0].node;
00999                                         } break;
01000 case 9:
01001 # line 109 "AtomParser.y"
01002 { //printf("OR\n");
01003                                           yyval.node = new atomparser_node(OR);
01004                                           yyval.node->left = yypvt[-2].node;
01005                                           yyval.node->right = yypvt[-0].node;
01006                                         } break;
01007 case 10:
01008 # line 114 "AtomParser.y"
01009 { yyval.node = yypvt[-0].node; } break;
01010 case 11:
01011 # line 115 "AtomParser.y"
01012 { yyval.node = yypvt[-0].node; } break;
01013 case 12:
01014 # line 116 "AtomParser.y"
01015 { yyval.node = new atomparser_node(WITHIN);
01016                                           yyval.node->left = yypvt[-0].node;
01017                                           yyval.node->dval = yypvt[-2].dval;
01018                                         } break;
01019 case 13:
01020 # line 120 "AtomParser.y"
01021 { yyval.node = new atomparser_node(EXWITHIN);
01022                                           yyval.node->left = yypvt[-0].node;
01023                                           yyval.node->dval = yypvt[-2].dval;
01024                                         } break;
01025 case 14:
01026 # line 124 "AtomParser.y"
01027 { yyval.node = new atomparser_node(PBWITHIN);
01028                                           yyval.node->left = yypvt[-0].node;
01029                                           yyval.node->dval = yypvt[-2].dval;
01030                                         } break;
01031 case 15:
01032 # line 128 "AtomParser.y"
01033 { yyval.node = new atomparser_node(WITHINBONDS);
01034                                           yyval.node->left = yypvt[-0].node;
01035                                           yyval.node->ival = yypvt[-2].ival;
01036                                         } break;
01037 case 16:
01038 # line 132 "AtomParser.y"
01039 { yyval.node = new atomparser_node(NEAREST);
01040                                           yyval.node->left = yypvt[-0].node;
01041                                           yyval.node->ival = yypvt[-2].ival;
01042                                         } break;
01043 case 17:
01044 # line 136 "AtomParser.y"
01045 { yyval.node = new atomparser_node(MAXRINGSIZE);
01046                                           yyval.node->left = yypvt[-0].node;
01047                                           yyval.node->ival = yypvt[-2].ival;
01048                                         } break;
01049 case 18:
01050 # line 140 "AtomParser.y"
01051 { yyval.node = new atomparser_node(RINGSIZE);
01052                                           yyval.node->left = yypvt[-0].node;
01053                                           yyval.node->ival = yypvt[-2].ival;
01054                                         } break;
01055 case 19:
01056 # line 144 "AtomParser.y"
01057 { yyval.node = yypvt[-2].node;
01058                                           yyval.node->node_type = SAME;
01059                                           yyval.node->left = yypvt[-0].node;
01060                                         } break;
01061 case 20:
01062 # line 148 "AtomParser.y"
01063 {yyval.node = new atomparser_node(COMPARE);
01064                                           yyval.node -> ival = yypvt[-1].ival;
01065                                           yyval.node -> left = yypvt[-2].node;
01066                                           yyval.node -> right = yypvt[-0].node;
01067                                         } break;
01068 case 21:
01069 # line 155 "AtomParser.y"
01070 {
01071                                           yypvt[-1].node -> left = yypvt[-0].node;
01072                                           yypvt[-0].node -> right = NULL;
01073                                           yyval.node = yypvt[-1].node;
01074                                         } break;
01075 case 22:
01076 # line 162 "AtomParser.y"
01077 {  yypvt[-1].node -> left = yypvt[-0].node;
01078                                            yypvt[-0].node -> right = NULL;
01079                                            yyval.node = yypvt[-1].node;
01080                                         } break;
01081 case 23:
01082 # line 168 "AtomParser.y"
01083 { 
01084                                           yyval.node = yypvt[-0].node;
01085                                           //printf("Single\n");
01086                                         } break;
01087 case 24:
01088 # line 172 "AtomParser.y"
01089 { yyval.node = new atomparser_node(STRWORD);
01090                                           //printf("converted int\n");
01091                                           char s[100];
01092                                           sprintf(s, "%ld", (long) yypvt[-0].ival);
01093                                           yyval.node -> sele.s = s;
01094                                           yyval.node -> sele.st = RAW_STRING;
01095                                         } break;
01096 case 25:
01097 # line 179 "AtomParser.y"
01098 { yyval.node = new atomparser_node(STRWORD);
01099                                           char s[100];
01100                                           sprintf(s, "%f", (double) yypvt[-0].dval);
01101                                           yyval.node -> sele.s = s;
01102                                           yyval.node -> sele.st = RAW_STRING;
01103                                         } break;
01104 case 26:
01105 # line 187 "AtomParser.y"
01106 { 
01107                                           yypvt[-0].node -> right = yypvt[-0].node;
01108                                           yyval.node = yypvt[-0].node; 
01109                                         } break;
01110 case 27:
01111 # line 191 "AtomParser.y"
01112 { yypvt[-2].node -> right = yypvt[-0].node;
01113                                           yypvt[-2].node -> left = yypvt[-0].node;
01114                                           yypvt[-2].node -> extra_type = 1;
01115                                           yyval.node = yypvt[-2].node;
01116                                           //printf("Using through\n");
01117                                         } break;
01118 case 28:
01119 # line 200 "AtomParser.y"
01120 { yyval.node = yypvt[-0].node; } break;
01121 case 29:
01122 # line 201 "AtomParser.y"
01123 { /* copy the new word on the list */
01124                /* like a linked list, with head's right pointed to the end */
01125                /* element and head's left pointed to the second element    */
01126                                           yypvt[-1].node -> right -> left = yypvt[-0].node;
01127                                           yypvt[-1].node -> right = yypvt[-0].node -> right;
01128                                           yypvt[-0].node -> right = NULL;
01129                                           // printf("Returning\n");
01130                                           yyval.node = yypvt[-1].node;
01131                                        } break;
01132 case 30:
01133 # line 212 "AtomParser.y"
01134 { yyval.dval = yypvt[-0].dval;// printf("## %lf\n", yyval.dval);
01135                                         } break;
01136 case 31:
01137 # line 214 "AtomParser.y"
01138 { yyval.dval = (double) yypvt[-0].ival; 
01139                                           // printf("# %lf\n", yyval.dval);
01140                                         } break;
01141 case 32:
01142 # line 219 "AtomParser.y"
01143 { yyval.node = new atomparser_node(FLOATVAL);
01144                                           yyval.node->dval = yypvt[-0].dval; 
01145                                         } break;
01146 case 33:
01147 # line 222 "AtomParser.y"
01148 { yyval.node = new atomparser_node(INTVAL);
01149                                           yyval.node->ival = yypvt[-0].ival; 
01150                                         } break;
01151 case 34:
01152 # line 225 "AtomParser.y"
01153 { yyval.node = yypvt[-0].node; 
01154                                         } break;
01155 case 35:
01156 # line 227 "AtomParser.y"
01157 { yyval.node = yypvt[-1].node; } break;
01158 case 36:
01159 # line 228 "AtomParser.y"
01160 { yyval.node = new atomparser_node(ADD);
01161                                           yyval.node->left = yypvt[-2].node;
01162                                           yyval.node->right = yypvt[-0].node;
01163                                         } break;
01164 case 37:
01165 # line 232 "AtomParser.y"
01166 { yyval.node = new atomparser_node(SUB);
01167                                           yyval.node->left = yypvt[-2].node;
01168                                           yyval.node->right = yypvt[-0].node;
01169                                         } break;
01170 case 38:
01171 # line 236 "AtomParser.y"
01172 { yyval.node = new atomparser_node(UMINUS);
01173                                           yyval.node->left = yypvt[-0].node;
01174                                         } break;
01175 case 39:
01176 # line 239 "AtomParser.y"
01177 { yyval.node = yypvt[-0].node;
01178                                         } break;
01179 case 40:
01180 # line 241 "AtomParser.y"
01181 { yyval.node = new atomparser_node(MOD);
01182                                           yyval.node->left = yypvt[-2].node;
01183                                           yyval.node->right = yypvt[-0].node;
01184                                         } break;
01185 case 41:
01186 # line 245 "AtomParser.y"
01187 { yyval.node = new atomparser_node(EXP);
01188                                           yyval.node->left = yypvt[-2].node;
01189                                           yyval.node->right = yypvt[-0].node;
01190                                         } break;
01191 case 42:
01192 # line 249 "AtomParser.y"
01193 { yyval.node = new atomparser_node(MULT);
01194                                           yyval.node->left = yypvt[-2].node;
01195                                           yyval.node->right = yypvt[-0].node;
01196                                         } break;
01197 case 43:
01198 # line 253 "AtomParser.y"
01199 { yyval.node = new atomparser_node(DIV);
01200                                           yyval.node->left = yypvt[-2].node;
01201                                           yyval.node->right = yypvt[-0].node;
01202                                         } break;
01203 case 44:
01204 # line 257 "AtomParser.y"
01205 { yyval.node = yypvt[-0].node; } break;
01206 case 45:
01207 # line 258 "AtomParser.y"
01208 { yypvt[-3].node->left = yypvt[-1].node;
01209                                           yyval.node = yypvt[-3].node;
01210                                         } break;
01211 case 46:
01212 # line 263 "AtomParser.y"
01213 { yyval.ival = NLT; } break;
01214 case 47:
01215 # line 264 "AtomParser.y"
01216 { yyval.ival = NLE; } break;
01217 case 48:
01218 # line 265 "AtomParser.y"
01219 { yyval.ival = NEQ; } break;
01220 case 49:
01221 # line 266 "AtomParser.y"
01222 { yyval.ival = NGE; } break;
01223 case 50:
01224 # line 267 "AtomParser.y"
01225 { yyval.ival = NGT; } break;
01226 case 51:
01227 # line 268 "AtomParser.y"
01228 { yyval.ival = NNE; } break;
01229 case 52:
01230 # line 269 "AtomParser.y"
01231 { yyval.ival = SLT; } break;
01232 case 53:
01233 # line 270 "AtomParser.y"
01234 { yyval.ival = SLE; } break;
01235 case 54:
01236 # line 271 "AtomParser.y"
01237 { yyval.ival = SEQ; } break;
01238 case 55:
01239 # line 272 "AtomParser.y"
01240 { yyval.ival = SGE; } break;
01241 case 56:
01242 # line 273 "AtomParser.y"
01243 { yyval.ival = SGT; } break;
01244 case 57:
01245 # line 274 "AtomParser.y"
01246 { yyval.ival = SNE; } break;
01247 case 58:
01248 # line 275 "AtomParser.y"
01249 { yyval.ival = MATCH; } break;
01250 # line  531 "/usr/ccs/bin/yaccpar"
01251         }
01252         goto yystack;           /* reset registers in driver code */
01253 }
01254