src/signature.c.der

   1 /*
   2 ** Inserted at beginning of c files generated by bison
   3 ** REMEMBER:  Change bison.reset too.
   4 */
   5
   6 /*@-allmacros@*/
   7 /*@+boolint@*/
   8 /*@+charint@*/
   9 /*@-macroparams@*/
  10 /*@-macroundef@*/
  11 /*@-unreachable@*/
  12 /*@-macrospec@*/
  13 /*@-varuse@*/
  14 /*@+ignorequals@*/
  15 /*@-macrostmt@*/
  16 /*@-noeffect@*/
  17 /*@-shadow@*/
  18 /*@-exitarg@*/
  19 /*@-macroredef@*/
  20 /*@-uniondef@*/
  21 /*@-compdef@*/
  22 /*@-matchfields@*/
  23 /*@-exportlocal@*/
  24 /*@-evalorderuncon@*/
  25 /*@-exportheader@*/
  26 /*@-typeuse@*/
  27 /*@-redecl@*/
  28 /*@-redef@*/
  29 /*@-noparams@*/
  30 /*@-ansireserved@*/
  31 /*@-fielduse@*/
  32 /*@-ifblock@*/
  33 /*@-elseifcomplete@*/
  34 /*@-whileblock@*/
  35 /*@-forblock@*/
  36 /*@-branchstate@*/
  37 /*@-readonlytrans@*/
  38 /*@-namechecks@*/
  39 /*@-usedef@*/
  40 /*@-systemunrecog@*/
  41 /*@-dependenttrans@*/
  42 /*@-unqualifiedtrans@*/
  43 /*@-nullassign@*/
  44 /*@-nullpass@*/
  45 /*@-nullptrarith*/
  46 /*@-usereleased@*/
  47 /*@-declundef@*/
  48
  49 /*drl added 11/27/2001*/
  50 /*@-bounds@*/
  51
  52 /*drl added 12/11/2002*/
  53 /*@-type@*/
  54
  55 /* < end of bison.head > */
  56
  57
  58 /*  A Bison parser, made from signature.y
  59     by GNU Bison version 1.28  */
  60
  61 #define YYBISON 1  /* Identify Bison output.  */
  62
  63 #define yyparse lslparse
  64 #define yylex lsllex
  65 #define yyerror lslerror
  66 #define yylval lsllval
  67 #define yychar lslchar
  68 #define yydebug lsldebug
  69 #define yynerrs lslnerrs
  70 #define LST_SIMPLEID    257
  71 #define LST_LOGICALOP   258
  72 #define LST_EQOP        259
  73 #define LST_SIMPLEOP    260
  74 #define LST_MAPSYM      261
  75 #define LST_FIELDMAPSYM 262
  76 #define LST_MARKERSYM   263
  77 #define LST_ifTOKEN     264
  78 #define LST_thenTOKEN   265
  79 #define LST_elseTOKEN   266
  80 #define LST_LBRACKET    267
  81 #define LST_RBRACKET    268
  82 #define LST_SELECTSYM   269
  83 #define LST_SEPSYM      270
  84 #define LST_OPENSYM     271
  85 #define LST_CLOSESYM    272
  86 #define LST_COLON       273
  87 #define LST_COMMA       274
  88 #define LST_EOL 275
  89 #define LST_COMMENTSYM  276
  90 #define LST_WHITESPACE  277
  91 #define LST_QUANTIFIERSYM       278
  92 #define LST_EQUATIONSYM 279
  93 #define LST_EQSEPSYM    280
  94 #define LST_COMPOSESYM  281
  95 #define LST_LPAR        282
  96 #define LST_RPAR        283
  97 #define LST_assertsTOKEN        284
  98 #define LST_assumesTOKEN        285
  99 #define LST_byTOKEN     286
 100 #define LST_convertsTOKEN       287
 101 #define LST_enumerationTOKEN    288
 102 #define LST_equationsTOKEN      289
 103 #define LST_exemptingTOKEN      290
 104 #define LST_forTOKEN    291
 105 #define LST_generatedTOKEN      292
 106 #define LST_impliesTOKEN        293
 107 #define LST_includesTOKEN       294
 108 #define LST_introducesTOKEN     295
 109 #define LST_ofTOKEN     296
 110 #define LST_partitionedTOKEN    297
 111 #define LST_traitTOKEN  298
 112 #define LST_tupleTOKEN  299
 113 #define LST_unionTOKEN  300
 114 #define LST_BADTOKEN    301
 115
 116
 117
 118 # include <stdio.h>
 119 # include "splintMacros.nf"
 120 # include "llbasic.h"
 121 # include "lslparse.h"
 122 # include "signature.h"
 123
 124 static void lslerror (char *);
 125 extern int lsllex ();
 126
 127 /*@dependent@*/ /*@null@*/ lslOp importedlslOp;
 128
 129 /*@-noparams@*/ /* Can't list params since YYSTYPE isn't defined yet. */
 130 static void yyprint (/*FILE *p_file, int p_type, YYSTYPE p_value */);
 131 /*@=noparams@*/
 132
 133 # define YYPRINT(file, type, value) yyprint (file, type, value)
 134
 135 # define YYDEBUG 1
 136
 137 /*@-redef@*/
 138 /*@-readonlytrans@*/
 139 /*@-nullassign@*/
 140
 141
 142 typedef union {
 143   ltoken ltok;  /* a leaf is also an ltoken */
 144   unsigned int count;
 145   /*@only@*/  ltokenList ltokenList;
 146   /*@only@*/  opFormNode opform;
 147   /*@owned@*/ sigNode signature;
 148   /*@only@*/  nameNode name;
 149   /*@owned@*/ lslOp operator;
 150   /*@only@*/  lslOpList operators;
 151   /*@-redef@*/ /*@-matchfields@*/
 152 } YYSTYPE;
 153 #ifndef YYDEBUG
 154 #define YYDEBUG 1
 155 #endif
 156
 157 #include <stdio.h>
 158
 159 #ifndef __cplusplus
 160 #ifndef __STDC__
 161 #define const
 162 #endif
 163 #endif
 164
 165
 166
 167 #define YYFINAL         62
 168 #define YYFLAG          -32768
 169 #define YYNTBASE        48
 170
 171 #define YYTRANSLATE(x) ((unsigned)(x) <= 301 ? yytranslate[x] : 62)
 172
 173 static const char yytranslate[] = {     0,
 174      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 175      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 176      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 177      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 178      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 179      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 180      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 181      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 182      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 183      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 184      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 185      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 186      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 187      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 188      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 189      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 190      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 191      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 192      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 193      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 194      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 195      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 196      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 197      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 198      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 199      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
 200      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
 201     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
 202     27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
 203     37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
 204     47
 205 };
 206
 207 #if YYDEBUG != 0
 208 static const short yyprhs[] = {     0,
 209      0,     2,     4,     7,    11,    13,    15,    22,    24,    27,
 210     30,    34,    38,    43,    48,    54,    58,    63,    68,    74,
 211     77,    81,    85,    87,    89,    91,    92,    94,    96,   100,
 212    102,   104,   108,   109,   111,   113,   117,   119
 213 };
 214
 215 static const short yyrhs[] = {    49,
 216      0,    50,     0,    49,    50,     0,    51,    19,    57,     0,
 217     61,     0,    52,     0,    10,     9,    11,     9,    12,     9,
 218      0,    53,     0,     9,    53,     0,    53,     9,     0,     9,
 219     53,     9,     0,    17,    54,    18,     0,     9,    17,    54,
 220     18,     0,    17,    54,    18,     9,     0,     9,    17,    54,
 221     18,     9,     0,    13,    54,    14,     0,     9,    13,    54,
 222     14,     0,    13,    54,    14,     9,     0,     9,    13,    54,
 223     14,     9,     0,    15,     3,     0,     9,    15,     3,     0,
 224      9,     8,     3,     0,     6,     0,     4,     0,     5,     0,
 225      0,    55,     0,     9,     0,    55,    56,     9,     0,    20,
 226      0,    16,     0,    58,     7,    60,     0,     0,    59,     0,
 227     60,     0,    59,    20,    60,     0,     3,     0,     3,     0
 228 };
 229
 230 #endif
 231
 232 #if YYDEBUG != 0
 233 static const short yyrline[] = { 0,
 234    139,   142,   147,   152,   159,   161,   166,   168,   170,   172,
 235    174,   176,   178,   180,   182,   185,   188,   191,   194,   197,
 236    200,   205,   210,   212,   214,   218,   220,   224,   226,   230,
 237    232,   236,   240,   242,   246,   248,   252,   259
 238 };
 239 #endif
 240
 241
 242 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
 243
 244 static const char * const yytname[] = {   "$","error","$undefined.","LST_SIMPLEID",
 245 "LST_LOGICALOP","LST_EQOP","LST_SIMPLEOP","LST_MAPSYM","LST_FIELDMAPSYM","LST_MARKERSYM",
 246 "LST_ifTOKEN","LST_thenTOKEN","LST_elseTOKEN","LST_LBRACKET","LST_RBRACKET",
 247 "LST_SELECTSYM","LST_SEPSYM","LST_OPENSYM","LST_CLOSESYM","LST_COLON","LST_COMMA",
 248 "LST_EOL","LST_COMMENTSYM","LST_WHITESPACE","LST_QUANTIFIERSYM","LST_EQUATIONSYM",
 249 "LST_EQSEPSYM","LST_COMPOSESYM","LST_LPAR","LST_RPAR","LST_assertsTOKEN","LST_assumesTOKEN",
 250 "LST_byTOKEN","LST_convertsTOKEN","LST_enumerationTOKEN","LST_equationsTOKEN",
 251 "LST_exemptingTOKEN","LST_forTOKEN","LST_generatedTOKEN","LST_impliesTOKEN",
 252 "LST_includesTOKEN","LST_introducesTOKEN","LST_ofTOKEN","LST_partitionedTOKEN",
 253 "LST_traitTOKEN","LST_tupleTOKEN","LST_unionTOKEN","LST_BADTOKEN","top","operatorList",
 254 "operator","name","opForm","anyOp","middle","placeList","separator","signature",
 255 "domain","sortList","sortId","opId", NULL
 256 };
 257 #endif
 258
 259 static const short yyr1[] = {     0,
 260     48,    49,    49,    50,    51,    51,    52,    52,    52,    52,
 261     52,    52,    52,    52,    52,    52,    52,    52,    52,    52,
 262     52,    52,    53,    53,    53,    54,    54,    55,    55,    56,
 263     56,    57,    58,    58,    59,    59,    60,    61
 264 };
 265
 266 static const short yyr2[] = {     0,
 267      1,     1,     2,     3,     1,     1,     6,     1,     2,     2,
 268      3,     3,     4,     4,     5,     3,     4,     4,     5,     2,
 269      3,     3,     1,     1,     1,     0,     1,     1,     3,     1,
 270      1,     3,     0,     1,     1,     3,     1,     1
 271 };
 272
 273 static const short yydefact[] = {     0,
 274     38,    24,    25,    23,     0,     0,    26,     0,    26,     1,
 275      2,     0,     6,     8,     5,     0,    26,     0,    26,     9,
 276      0,    28,     0,    27,    20,     0,     3,    33,    10,    22,
 277      0,    21,     0,    11,     0,    16,    31,    30,     0,    12,
 278     37,     4,     0,    34,    35,    17,    13,     0,    18,    29,
 279     14,     0,     0,    19,    15,     0,    32,    36,     7,     0,
 280      0,     0
 281 };
 282
 283 static const short yydefgoto[] = {    60,
 284     10,    11,    12,    13,    14,    23,    24,    39,    42,    43,
 285     44,    45,    15
 286 };
 287
 288 static const short yypact[] = {    -3,
 289 -32768,-32768,-32768,-32768,    11,    -4,     0,     8,     0,    -3,
 290 -32768,    -1,-32768,    13,-32768,    17,     0,    22,     0,    18,
 291     20,-32768,    19,   -12,-32768,    14,-32768,    31,-32768,-32768,
 292     21,-32768,    23,-32768,    27,    28,-32768,-32768,    29,    30,
 293 -32768,-32768,    33,    24,-32768,    34,    36,    35,-32768,-32768,
 294 -32768,    31,    31,-32768,-32768,    37,-32768,-32768,-32768,    42,
 295     48,-32768
 296 };
 297
 298 static const short yypgoto[] = {-32768,
 299 -32768,    39,-32768,-32768,    45,     4,-32768,-32768,-32768,-32768,
 300 -32768,   -23,-32768
 301 };
 302
 303
 304 #define YYLAST          50
 305
 306
 307 static const short yytable[] = {     1,
 308      2,     3,     4,    37,    21,     5,     6,    38,    22,     7,
 309     25,     8,    26,     9,     2,     3,     4,    28,    16,    30,
 310     31,    29,    33,    17,    32,    18,    34,    19,    57,    58,
 311     35,    40,    36,    41,    46,    48,    49,    50,    51,    52,
 312     47,    61,    54,    53,    55,    59,    56,    62,    27,    20
 313 };
 314
 315 static const short yycheck[] = {     3,
 316      4,     5,     6,    16,     9,     9,    10,    20,     9,    13,
 317      3,    15,     9,    17,     4,     5,     6,    19,     8,     3,
 318     17,     9,    19,    13,     3,    15,     9,    17,    52,    53,
 319     11,    18,    14,     3,    14,     9,     9,     9,     9,     7,
 320     18,     0,     9,    20,     9,     9,    12,     0,    10,     5
 321 };
 322 #define YYPURE 1
 323
 324 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 325
 326 /* This file comes from bison-1.28.  */
 327
 328 /* Skeleton output parser for bison,
 329    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 330
 331    This program is free software; you can redistribute it and/or modify
 332    it under the terms of the GNU General Public License as published by
 333    the Free Software Foundation; either version 2, or (at your option)
 334    any later version.
 335
 336    This program is distributed in the hope that it will be useful,
 337    but WITHOUT ANY WARRANTY; without even the implied warranty of
 338    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 339    GNU General Public License for more details.
 340
 341    You should have received a copy of the GNU General Public License
 342    along with this program; if not, write to the Free Software
 343    Foundation, Inc., 59 Temple Place - Suite 330,
 344    Boston, MA 02111-1307, USA.  */
 345
 346 /* As a special exception, when this file is copied by Bison into a
 347    Bison output file, you may use that output file without restriction.
 348    This special exception was added by the Free Software Foundation
 349    in version 1.24 of Bison.  */
 350
 351 /* This is the parser code that is written into each bison parser
 352   when the %semantic_parser declaration is not specified in the grammar.
 353   It was written by Richard Stallman by simplifying the hairy parser
 354   used when %semantic_parser is specified.  */
 355
 356 #ifndef YYSTACK_USE_ALLOCA
 357 #ifdef alloca
 358 #define YYSTACK_USE_ALLOCA
 359 #else /* alloca not defined */
 360 #ifdef __GNUC__
 361 #define YYSTACK_USE_ALLOCA
 362 #define alloca __builtin_alloca
 363 #else /* not GNU C.  */
 364 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
 365 #define YYSTACK_USE_ALLOCA
 366 #include <alloca.h>
 367 #else /* not sparc */
 368 /* We think this test detects Watcom and Microsoft C.  */
 369 /* This used to test MSDOS, but that is a bad idea
 370    since that symbol is in the user namespace.  */
 371 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
 372 #if 0 /* No need for malloc.h, which pollutes the namespace;
 373          instead, just don't use alloca.  */
 374 #include <malloc.h>
 375 #endif
 376 #else /* not MSDOS, or __TURBOC__ */
 377 #if defined(_AIX)
 378 /* I don't know what this was needed for, but it pollutes the namespace.
 379    So I turned it off.   rms, 2 May 1997.  */
 380 /* #include <malloc.h>  */
 381  #pragma alloca
 382 #define YYSTACK_USE_ALLOCA
 383 #else /* not MSDOS, or __TURBOC__, or _AIX */
 384 #if 0
 385 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
 386                  and on HPUX 10.  Eventually we can turn this on.  */
 387 #define YYSTACK_USE_ALLOCA
 388 #define alloca __builtin_alloca
 389 #endif /* __hpux */
 390 #endif
 391 #endif /* not _AIX */
 392 #endif /* not MSDOS, or __TURBOC__ */
 393 #endif /* not sparc */
 394 #endif /* not GNU C */
 395 #endif /* alloca not defined */
 396 #endif /* YYSTACK_USE_ALLOCA not defined */
 397
 398 #ifdef YYSTACK_USE_ALLOCA
 399 #define YYSTACK_ALLOC alloca
 400 #else
 401 #define YYSTACK_ALLOC malloc
 402 #endif
 403
 404 /* Note: there must be only one dollar sign in this file.
 405    It is replaced by the list of actions, each action
 406    as one case of the switch.  */
 407
 408 #define yyerrok         (yyerrstatus = 0)
 409 #define yyclearin       (yychar = YYEMPTY)
 410 #define YYEMPTY         -2
 411 #define YYEOF           0
 412 #define YYACCEPT        goto yyacceptlab
 413 #define YYABORT         goto yyabortlab
 414 #define YYERROR         goto yyerrlab1
 415 /* Like YYERROR except do call yyerror.
 416    This remains here temporarily to ease the
 417    transition to the new meaning of YYERROR, for GCC.
 418    Once GCC version 2 has supplanted version 1, this can go.  */
 419 #define YYFAIL          goto yyerrlab
 420 #define YYRECOVERING()  (!!yyerrstatus)
 421 #define YYBACKUP(token, value) \
 422 do                                                              \
 423   if (yychar == YYEMPTY && yylen == 1)                          \
 424     { yychar = (token), yylval = (value);                       \
 425       yychar1 = YYTRANSLATE (yychar);                           \
 426       YYPOPSTACK;                                               \
 427       goto yybackup;                                            \
 428     }                                                           \
 429   else                                                          \
 430     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
 431 while (0)
 432
 433 #define YYTERROR        1
 434 #define YYERRCODE       256
 435
 436 #ifndef YYPURE
 437 #define YYLEX           yylex()
 438 #endif
 439
 440 #ifdef YYPURE
 441 #ifdef YYLSP_NEEDED
 442 #ifdef YYLEX_PARAM
 443 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
 444 #else
 445 #define YYLEX           yylex(&yylval, &yylloc)
 446 #endif
 447 #else /* not YYLSP_NEEDED */
 448 #ifdef YYLEX_PARAM
 449 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
 450 #else
 451 #define YYLEX           yylex(&yylval)
 452 #endif
 453 #endif /* not YYLSP_NEEDED */
 454 #endif
 455
 456 /* If nonreentrant, generate the variables here */
 457
 458 #ifndef YYPURE
 459
 460 int     yychar;                 /*  the lookahead symbol                */
 461 YYSTYPE yylval;                 /*  the semantic value of the           */
 462                                 /*  lookahead symbol                    */
 463
 464 #ifdef YYLSP_NEEDED
 465 YYLTYPE yylloc;                 /*  location data for the lookahead     */
 466                                 /*  symbol                              */
 467 #endif
 468
 469 int yynerrs;                    /*  number of parse errors so far       */
 470 #endif  /* not YYPURE */
 471
 472 #if YYDEBUG != 0
 473 int yydebug;                    /*  nonzero means print parse trace     */
 474 /* Since this is uninitialized, it does not stop multiple parsers
 475    from coexisting.  */
 476 #endif
 477
 478 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
 479
 480 #ifndef YYINITDEPTH
 481 #define YYINITDEPTH 200
 482 #endif
 483
 484 /*  YYMAXDEPTH is the maximum size the stacks can grow to
 485     (effective only if the built-in stack extension method is used).  */
 486
 487 #if YYMAXDEPTH == 0
 488 #undef YYMAXDEPTH
 489 #endif
 490
 491 #ifndef YYMAXDEPTH
 492 #define YYMAXDEPTH 10000
 493 #endif
 494 \f
 495 /* Define __yy_memcpy.  Note that the size argument
 496    should be passed with type unsigned int, because that is what the non-GCC
 497    definitions require.  With GCC, __builtin_memcpy takes an arg
 498    of type size_t, but it can handle unsigned int.  */
 499
 500 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
 501 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
 502 #else                           /* not GNU C or C++ */
 503 #ifndef __cplusplus
 504
 505 /* This is the most reliable way to avoid incompatibilities
 506    in available built-in functions on various systems.  */
 507 static void
 508 __yy_memcpy (to, from, count)
 509      char *to;
 510      char *from;
 511      unsigned int count;
 512 {
 513   register char *f = from;
 514   register char *t = to;
 515   register int i = count;
 516
 517   while (i-- > 0)
 518     *t++ = *f++;
 519 }
 520
 521 #else /* __cplusplus */
 522
 523 /* This is the most reliable way to avoid incompatibilities
 524    in available built-in functions on various systems.  */
 525 static void
 526 __yy_memcpy (char *to, char *from, unsigned int count)
 527 {
 528   register char *t = to;
 529   register char *f = from;
 530   register int i = count;
 531
 532   while (i-- > 0)
 533     *t++ = *f++;
 534 }
 535
 536 #endif
 537 #endif
 538 \f
 539
 540
 541 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 542    into yyparse.  The argument should have type void *.
 543    It should actually point to an object.
 544    Grammar actions can access the variable by casting it
 545    to the proper pointer type.  */
 546
 547 #ifdef YYPARSE_PARAM
 548 #ifdef __cplusplus
 549 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 550 #define YYPARSE_PARAM_DECL
 551 #else /* not __cplusplus */
 552 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
 553 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 554 #endif /* not __cplusplus */
 555 #else /* not YYPARSE_PARAM */
 556 #define YYPARSE_PARAM_ARG
 557 #define YYPARSE_PARAM_DECL
 558 #endif /* not YYPARSE_PARAM */
 559
 560 /* Prevent warning if -Wstrict-prototypes.  */
 561 #ifdef __GNUC__
 562 #ifdef YYPARSE_PARAM
 563 int yyparse (void *);
 564 #else
 565 int yyparse (void);
 566 #endif
 567 #endif
 568
 569 int
 570 yyparse(YYPARSE_PARAM_ARG)
 571      YYPARSE_PARAM_DECL
 572 {
 573   register int yystate;
 574   register int yyn;
 575   register short *yyssp;
 576   register YYSTYPE *yyvsp;
 577   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
 578   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
 579
 580   short yyssa[YYINITDEPTH];     /*  the state stack                     */
 581   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
 582
 583   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
 584   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
 585
 586 #ifdef YYLSP_NEEDED
 587   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
 588   YYLTYPE *yyls = yylsa;
 589   YYLTYPE *yylsp;
 590
 591 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 592 #else
 593 #define YYPOPSTACK   (yyvsp--, yyssp--)
 594 #endif
 595
 596   int yystacksize = YYINITDEPTH;
 597   int yyfree_stacks = 0;
 598
 599 #ifdef YYPURE
 600   int yychar;
 601   YYSTYPE yylval;
 602   int yynerrs;
 603 #ifdef YYLSP_NEEDED
 604   YYLTYPE yylloc;
 605 #endif
 606 #endif
 607
 608   YYSTYPE yyval;                /*  the variable used to return         */
 609                                 /*  semantic values from the action     */
 610                                 /*  routines                            */
 611
 612   int yylen;
 613
 614 #if YYDEBUG != 0
 615   if (yydebug)
 616     fprintf(stderr, "Starting parse\n");
 617 #endif
 618
 619   yystate = 0;
 620   yyerrstatus = 0;
 621   yynerrs = 0;
 622   yychar = YYEMPTY;             /* Cause a token to be read.  */
 623
 624   /* Initialize stack pointers.
 625      Waste one element of value and location stack
 626      so that they stay on the same level as the state stack.
 627      The wasted elements are never initialized.  */
 628
 629   yyssp = yyss - 1;
 630   yyvsp = yyvs;
 631 #ifdef YYLSP_NEEDED
 632   yylsp = yyls;
 633 #endif
 634
 635 /* Push a new state, which is found in  yystate  .  */
 636 /* In all cases, when you get here, the value and location stacks
 637    have just been pushed. so pushing a state here evens the stacks.  */
 638 yynewstate:
 639
 640   *++yyssp = yystate;
 641
 642   if (yyssp >= yyss + yystacksize - 1)
 643     {
 644       /* Give user a chance to reallocate the stack */
 645       /* Use copies of these so that the &'s don't force the real ones into memory. */
 646       YYSTYPE *yyvs1 = yyvs;
 647       short *yyss1 = yyss;
 648 #ifdef YYLSP_NEEDED
 649       YYLTYPE *yyls1 = yyls;
 650 #endif
 651
 652       /* Get the current used size of the three stacks, in elements.  */
 653       int size = yyssp - yyss + 1;
 654
 655 #ifdef yyoverflow
 656       /* Each stack pointer address is followed by the size of
 657          the data in use in that stack, in bytes.  */
 658 #ifdef YYLSP_NEEDED
 659       /* This used to be a conditional around just the two extra args,
 660          but that might be undefined if yyoverflow is a macro.  */
 661       yyoverflow("parser stack overflow",
 662                  &yyss1, size * sizeof (*yyssp),
 663                  &yyvs1, size * sizeof (*yyvsp),
 664                  &yyls1, size * sizeof (*yylsp),
 665                  &yystacksize);
 666 #else
 667       yyoverflow("parser stack overflow",
 668                  &yyss1, size * sizeof (*yyssp),
 669                  &yyvs1, size * sizeof (*yyvsp),
 670                  &yystacksize);
 671 #endif
 672
 673       yyss = yyss1; yyvs = yyvs1;
 674 #ifdef YYLSP_NEEDED
 675       yyls = yyls1;
 676 #endif
 677 #else /* no yyoverflow */
 678       /* Extend the stack our own way.  */
 679       if (yystacksize >= YYMAXDEPTH)
 680         {
 681           yyerror("parser stack overflow");
 682           if (yyfree_stacks)
 683             {
 684               free (yyss);
 685               free (yyvs);
 686 #ifdef YYLSP_NEEDED
 687               free (yyls);
 688 #endif
 689             }
 690           return 2;
 691         }
 692       yystacksize *= 2;
 693       if (yystacksize > YYMAXDEPTH)
 694         yystacksize = YYMAXDEPTH;
 695 #ifndef YYSTACK_USE_ALLOCA
 696       yyfree_stacks = 1;
 697 #endif
 698       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
 699       __yy_memcpy ((char *)yyss, (char *)yyss1,
 700                    size * (unsigned int) sizeof (*yyssp));
 701       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
 702       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
 703                    size * (unsigned int) sizeof (*yyvsp));
 704 #ifdef YYLSP_NEEDED
 705       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
 706       __yy_memcpy ((char *)yyls, (char *)yyls1,
 707                    size * (unsigned int) sizeof (*yylsp));
 708 #endif
 709 #endif /* no yyoverflow */
 710
 711       yyssp = yyss + size - 1;
 712       yyvsp = yyvs + size - 1;
 713 #ifdef YYLSP_NEEDED
 714       yylsp = yyls + size - 1;
 715 #endif
 716
 717 #if YYDEBUG != 0
 718       if (yydebug)
 719         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
 720 #endif
 721
 722       if (yyssp >= yyss + yystacksize - 1)
 723         YYABORT;
 724     }
 725
 726 #if YYDEBUG != 0
 727   if (yydebug)
 728     fprintf(stderr, "Entering state %d\n", yystate);
 729 #endif
 730
 731   goto yybackup;
 732  yybackup:
 733
 734 /* Do appropriate processing given the current state.  */
 735 /* Read a lookahead token if we need one and don't already have one.  */
 736 /* yyresume: */
 737
 738   /* First try to decide what to do without reference to lookahead token.  */
 739
 740   yyn = yypact[yystate];
 741   if (yyn == YYFLAG)
 742     goto yydefault;
 743
 744   /* Not known => get a lookahead token if don't already have one.  */
 745
 746   /* yychar is either YYEMPTY or YYEOF
 747      or a valid token in external form.  */
 748
 749   if (yychar == YYEMPTY)
 750     {
 751 #if YYDEBUG != 0
 752       if (yydebug)
 753         fprintf(stderr, "Reading a token: ");
 754 #endif
 755       yychar = YYLEX;
 756     }
 757
 758   /* Convert token to internal form (in yychar1) for indexing tables with */
 759
 760   if (yychar <= 0)              /* This means end of input. */
 761     {
 762       yychar1 = 0;
 763       yychar = YYEOF;           /* Don't call YYLEX any more */
 764
 765 #if YYDEBUG != 0
 766       if (yydebug)
 767         fprintf(stderr, "Now at end of input.\n");
 768 #endif
 769     }
 770   else
 771     {
 772       yychar1 = YYTRANSLATE(yychar);
 773
 774 #if YYDEBUG != 0
 775       if (yydebug)
 776         {
 777           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
 778           /* Give the individual parser a way to print the precise meaning
 779              of a token, for further debugging info.  */
 780 #ifdef YYPRINT
 781           YYPRINT (stderr, yychar, yylval);
 782 #endif
 783           fprintf (stderr, ")\n");
 784         }
 785 #endif
 786     }
 787
 788   yyn += yychar1;
 789   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 790     goto yydefault;
 791
 792   yyn = yytable[yyn];
 793
 794   /* yyn is what to do for this token type in this state.
 795      Negative => reduce, -yyn is rule number.
 796      Positive => shift, yyn is new state.
 797        New state is final state => don't bother to shift,
 798        just return success.
 799      0, or most negative number => error.  */
 800
 801   if (yyn < 0)
 802     {
 803       if (yyn == YYFLAG)
 804         goto yyerrlab;
 805       yyn = -yyn;
 806       goto yyreduce;
 807     }
 808   else if (yyn == 0)
 809     goto yyerrlab;
 810
 811   if (yyn == YYFINAL)
 812     YYACCEPT;
 813
 814   /* Shift the lookahead token.  */
 815
 816 #if YYDEBUG != 0
 817   if (yydebug)
 818     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
 819 #endif
 820
 821   /* Discard the token being shifted unless it is eof.  */
 822   if (yychar != YYEOF)
 823     yychar = YYEMPTY;
 824
 825   *++yyvsp = yylval;
 826 #ifdef YYLSP_NEEDED
 827   *++yylsp = yylloc;
 828 #endif
 829
 830   /* count tokens shifted since error; after three, turn off error status.  */
 831   if (yyerrstatus) yyerrstatus--;
 832
 833   yystate = yyn;
 834   goto yynewstate;
 835
 836 /* Do the default action for the current state.  */
 837 yydefault:
 838
 839   yyn = yydefact[yystate];
 840   if (yyn == 0)
 841     goto yyerrlab;
 842
 843 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
 844 yyreduce:
 845   yylen = yyr2[yyn];
 846   if (yylen > 0)
 847     yyval = yyvsp[1-yylen]; /* implement default value of the action */
 848
 849 #if YYDEBUG != 0
 850   if (yydebug)
 851     {
 852       int i;
 853
 854       fprintf (stderr, "Reducing via rule %d (line %d), ",
 855                yyn, yyrline[yyn]);
 856
 857       /* Print the symbols being reduced, and their result.  */
 858       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
 859         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
 860       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 861     }
 862 #endif
 863
 864
 865   switch (yyn) {
 866
 867 case 1:
 868 { lslOpList_free (yyvsp[0].operators); ;
 869     break;}
 870 case 2:
 871 { lslOpList x = lslOpList_new ();
 872                 g_importedlslOp = yyvsp[0].operator;
 873                 lslOpList_add (x, yyvsp[0].operator);
 874                 yyval.operators = x; ;
 875     break;}
 876 case 3:
 877 { lslOpList_add (yyvsp[-1].operators, yyvsp[0].operator);
 878                 yyval.operators = yyvsp[-1].operators; ;
 879     break;}
 880 case 4:
 881 { yyval.operator = makelslOpNode (yyvsp[-2].name, yyvsp[0].signature); ;
 882     break;}
 883 case 5:
 884 { yyval.name = makeNameNodeId (yyvsp[0].ltok); ;
 885     break;}
 886 case 6:
 887 { yyval.name = makeNameNodeForm (yyvsp[0].opform); ;
 888     break;}
 889 case 7:
 890 { yyval.opform = makeOpFormNode (yyvsp[-5].ltok, OPF_IF, opFormUnion_createMiddle (0), ltoken_undefined); ;
 891     break;}
 892 case 8:
 893 { yyval.opform = makeOpFormNode (yyvsp[0].ltok, OPF_ANYOP, opFormUnion_createAnyOp (yyvsp[0].ltok), ltoken_undefined); ;
 894     break;}
 895 case 9:
 896 { yyval.opform = makeOpFormNode (yyvsp[-1].ltok, OPF_MANYOP, opFormUnion_createAnyOp (yyvsp[0].ltok), ltoken_undefined); ;
 897     break;}
 898 case 10:
 899 { yyval.opform = makeOpFormNode (yyvsp[-1].ltok, OPF_ANYOPM, opFormUnion_createAnyOp (yyvsp[-1].ltok), ltoken_undefined); ;
 900     break;}
 901 case 11:
 902 { yyval.opform = makeOpFormNode (yyvsp[-2].ltok, OPF_MANYOPM, opFormUnion_createAnyOp (yyvsp[-1].ltok), ltoken_undefined); ;
 903     break;}
 904 case 12:
 905 { yyval.opform = makeOpFormNode (yyvsp[-2].ltok, OPF_MIDDLE, opFormUnion_createMiddle (yyvsp[-1].count), yyvsp[0].ltok); ;
 906     break;}
 907 case 13:
 908 { yyval.opform = makeOpFormNode (yyvsp[-2].ltok, OPF_MMIDDLE, opFormUnion_createMiddle (yyvsp[-1].count), yyvsp[0].ltok); ;
 909     break;}
 910 case 14:
 911 { yyval.opform = makeOpFormNode (yyvsp[-3].ltok, OPF_MIDDLEM, opFormUnion_createMiddle (yyvsp[-2].count), yyvsp[-1].ltok); ;
 912     break;}
 913 case 15:
 914 { yyval.opform = makeOpFormNode (yyvsp[-3].ltok, OPF_MMIDDLEM,
 915                               opFormUnion_createMiddle (yyvsp[-2].count), yyvsp[-1].ltok); ;
 916     break;}
 917 case 16:
 918 { yyval.opform = makeOpFormNode (yyvsp[-2].ltok, OPF_BMIDDLE,
 919                               opFormUnion_createMiddle (yyvsp[-1].count), yyvsp[0].ltok); ;
 920     break;}
 921 case 17:
 922 { yyval.opform = makeOpFormNode (yyvsp[-2].ltok, OPF_BMMIDDLE,
 923                               opFormUnion_createMiddle (yyvsp[-1].count), yyvsp[0].ltok); ;
 924     break;}
 925 case 18:
 926 { yyval.opform = makeOpFormNode (yyvsp[-3].ltok, OPF_BMIDDLEM,
 927                             opFormUnion_createMiddle (yyvsp[-2].count), yyvsp[-1].ltok); ;
 928     break;}
 929 case 19:
 930 { yyval.opform = makeOpFormNode (yyvsp[-3].ltok, OPF_BMMIDDLEM,
 931                             opFormUnion_createMiddle (yyvsp[-2].count), yyvsp[-1].ltok); ;
 932     break;}
 933 case 20:
 934 { yyval.opform = makeOpFormNode (yyvsp[-1].ltok, OPF_SELECT,
 935                             opFormUnion_createAnyOp (yyvsp[0].ltok), ltoken_undefined); ;
 936     break;}
 937 case 21:
 938 { yyval.opform = makeOpFormNode (yyvsp[-2].ltok, OPF_MSELECT,
 939                             opFormUnion_createAnyOp (yyvsp[0].ltok), ltoken_undefined); ;
 940     break;}
 941 case 22:
 942 { yyval.opform = makeOpFormNode (yyvsp[-2].ltok, OPF_MMAP,
 943                             opFormUnion_createAnyOp (yyvsp[0].ltok), ltoken_undefined); ;
 944     break;}
 945 case 23:
 946 { yyval.ltok = yyvsp[0].ltok; ;
 947     break;}
 948 case 24:
 949 { yyval.ltok = yyvsp[0].ltok; ;
 950     break;}
 951 case 25:
 952 { yyval.ltok = yyvsp[0].ltok; ;
 953     break;}
 954 case 26:
 955 { yyval.count = 0; ;
 956     break;}
 957 case 27:
 958 { yyval.count = yyvsp[0].count; ;
 959     break;}
 960 case 28:
 961 { yyval.count = 1; ;
 962     break;}
 963 case 29:
 964 { yyval.count = yyvsp[-2].count + 1; ;
 965     break;}
 966 case 30:
 967 { yyval.ltok = yyvsp[0].ltok; ;
 968     break;}
 969 case 31:
 970 { yyval.ltok = yyvsp[0].ltok; ;
 971     break;}
 972 case 32:
 973 { yyval.signature = makesigNode (yyvsp[-1].ltok, yyvsp[-2].ltokenList, yyvsp[0].ltok); ;
 974     break;}
 975 case 33:
 976 { yyval.ltokenList = ltokenList_new (); ;
 977     break;}
 978 case 34:
 979 { yyval.ltokenList = yyvsp[0].ltokenList; ;
 980     break;}
 981 case 35:
 982 { yyval.ltokenList = ltokenList_singleton (yyvsp[0].ltok); ;
 983     break;}
 984 case 36:
 985 { yyval.ltokenList = ltokenList_push (yyvsp[-2].ltokenList, yyvsp[0].ltok); ;
 986     break;}
 987 case 37:
 988 {
 989           yyval.ltok = yyvsp[0].ltok;
 990           ltoken_setText (yyval.ltok, processTraitSortId (ltoken_getText (yyvsp[0].ltok)));
 991         ;
 992     break;}
 993 case 38:
 994 { yyval.ltok = yyvsp[0].ltok; ;
 995     break;}
 996 }
 997    /* the action file gets copied in in place of this dollarsign */
 998
 999 \f
1000   yyvsp -= yylen;
1001   yyssp -= yylen;
1002 #ifdef YYLSP_NEEDED
1003   yylsp -= yylen;
1004 #endif
1005
1006 #if YYDEBUG != 0
1007   if (yydebug)
1008     {
1009       short *ssp1 = yyss - 1;
1010       fprintf (stderr, "state stack now");
1011       while (ssp1 != yyssp)
1012         fprintf (stderr, " %d", *++ssp1);
1013       fprintf (stderr, "\n");
1014     }
1015 #endif
1016
1017   *++yyvsp = yyval;
1018
1019 #ifdef YYLSP_NEEDED
1020   yylsp++;
1021   if (yylen == 0)
1022     {
1023       yylsp->first_line = yylloc.first_line;
1024       yylsp->first_column = yylloc.first_column;
1025       yylsp->last_line = (yylsp-1)->last_line;
1026       yylsp->last_column = (yylsp-1)->last_column;
1027       yylsp->text = 0;
1028     }
1029   else
1030     {
1031       yylsp->last_line = (yylsp+yylen-1)->last_line;
1032       yylsp->last_column = (yylsp+yylen-1)->last_column;
1033     }
1034 #endif
1035
1036   /* Now "shift" the result of the reduction.
1037      Determine what state that goes to,
1038      based on the state we popped back to
1039      and the rule number reduced by.  */
1040
1041   yyn = yyr1[yyn];
1042
1043   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1044   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1045     yystate = yytable[yystate];
1046   else
1047     yystate = yydefgoto[yyn - YYNTBASE];
1048
1049   goto yynewstate;
1050
1051 yyerrlab:   /* here on detecting error */
1052
1053   if (! yyerrstatus)
1054     /* If not already recovering from an error, report this error.  */
1055     {
1056       ++yynerrs;
1057
1058 #ifdef YYERROR_VERBOSE
1059       yyn = yypact[yystate];
1060
1061       if (yyn > YYFLAG && yyn < YYLAST)
1062         {
1063           int size = 0;
1064           char *msg;
1065           int x, count;
1066
1067           count = 0;
1068           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
1069           for (x = (yyn < 0 ? -yyn : 0);
1070                x < (sizeof(yytname) / sizeof(char *)); x++)
1071             if (yycheck[x + yyn] == x)
1072               size += strlen(yytname[x]) + 15, count++;
1073           msg = (char *) malloc(size + 15);
1074           if (msg != 0)
1075             {
1076               strcpy(msg, "parse error");
1077
1078               if (count < 5)
1079                 {
1080                   count = 0;
1081                   for (x = (yyn < 0 ? -yyn : 0);
1082                        x < (sizeof(yytname) / sizeof(char *)); x++)
1083                     if (yycheck[x + yyn] == x)
1084                       {
1085                         strcat(msg, count == 0 ? ", expecting `" : " or `");
1086                         strcat(msg, yytname[x]);
1087                         strcat(msg, "'");
1088                         count++;
1089                       }
1090                 }
1091               yyerror(msg);
1092               free(msg);
1093             }
1094           else
1095             yyerror ("parse error; also virtual memory exceeded");
1096         }
1097       else
1098 #endif /* YYERROR_VERBOSE */
1099         yyerror("parse error");
1100     }
1101
1102   goto yyerrlab1;
1103 yyerrlab1:   /* here on error raised explicitly by an action */
1104
1105   if (yyerrstatus == 3)
1106     {
1107       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
1108
1109       /* return failure if at end of input */
1110       if (yychar == YYEOF)
1111         YYABORT;
1112
1113 #if YYDEBUG != 0
1114       if (yydebug)
1115         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1116 #endif
1117
1118       yychar = YYEMPTY;
1119     }
1120
1121   /* Else will try to reuse lookahead token
1122      after shifting the error token.  */
1123
1124   yyerrstatus = 3;              /* Each real token shifted decrements this */
1125
1126   goto yyerrhandle;
1127
1128 yyerrdefault:  /* current state does not do anything special for the error token. */
1129
1130 #if 0
1131   /* This is wrong; only states that explicitly want error tokens
1132      should shift them.  */
1133   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
1134   if (yyn) goto yydefault;
1135 #endif
1136
1137 yyerrpop:   /* pop the current state because it cannot handle the error token */
1138
1139   if (yyssp == yyss) YYABORT;
1140   yyvsp--;
1141   yystate = *--yyssp;
1142 #ifdef YYLSP_NEEDED
1143   yylsp--;
1144 #endif
1145
1146 #if YYDEBUG != 0
1147   if (yydebug)
1148     {
1149       short *ssp1 = yyss - 1;
1150       fprintf (stderr, "Error: state stack now");
1151       while (ssp1 != yyssp)
1152         fprintf (stderr, " %d", *++ssp1);
1153       fprintf (stderr, "\n");
1154     }
1155 #endif
1156
1157 yyerrhandle:
1158
1159   yyn = yypact[yystate];
1160   if (yyn == YYFLAG)
1161     goto yyerrdefault;
1162
1163   yyn += YYTERROR;
1164   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1165     goto yyerrdefault;
1166
1167   yyn = yytable[yyn];
1168   if (yyn < 0)
1169     {
1170       if (yyn == YYFLAG)
1171         goto yyerrpop;
1172       yyn = -yyn;
1173       goto yyreduce;
1174     }
1175   else if (yyn == 0)
1176     goto yyerrpop;
1177
1178   if (yyn == YYFINAL)
1179     YYACCEPT;
1180
1181 #if YYDEBUG != 0
1182   if (yydebug)
1183     fprintf(stderr, "Shifting error token, ");
1184 #endif
1185
1186   *++yyvsp = yylval;
1187 #ifdef YYLSP_NEEDED
1188   *++yylsp = yylloc;
1189 #endif
1190
1191   yystate = yyn;
1192   goto yynewstate;
1193
1194  yyacceptlab:
1195   /* YYACCEPT comes here.  */
1196   if (yyfree_stacks)
1197     {
1198       free (yyss);
1199       free (yyvs);
1200 #ifdef YYLSP_NEEDED
1201       free (yyls);
1202 #endif
1203     }
1204   return 0;
1205
1206  yyabortlab:
1207   /* YYABORT comes here.  */
1208   if (yyfree_stacks)
1209     {
1210       free (yyss);
1211       free (yyvs);
1212 #ifdef YYLSP_NEEDED
1213       free (yyls);
1214 #endif
1215     }
1216   return 1;
1217 }
1218
1219
1220 # include "bison.reset"
1221
1222 extern char *yytext;
1223
1224 void lslerror (char *s)
1225 {
1226   llfatalbug
1227     (cstring_makeLiteral
1228      ("There has been a problem in the parser with LSL signatures. This is believed to result "
1229       "from a problem with bison v. 1.25.  Please try rebuidling Splint "
1230       "using the pre-compiled grammar files by commenting out the "
1231       "BISON= line in the top-level Makefile."));
1232 }
1233
1234 static void yyprint (FILE *file, int type, YYSTYPE value)
1235 {
1236   fprintf (file, " (%u:%u type: %d; text: %s) ",
1237            ltoken_getLine (value.ltok),
1238            ltoken_getCol (value.ltok),
1239            type,
1240            ltoken_getRawTextChars (value.ltok));
1241 }
1242
1243 extern void PrintToken (ltoken tok) {
1244   char *codStr;
1245
1246   switch (ltoken_getCode (tok))
1247     {
1248     case NOTTOKEN:          codStr = "*** NOTTOKEN ***"; break;
1249     case LST_QUANTIFIERSYM: codStr = "QUANTIFIERSYM"; break;
1250     case LST_LOGICALOP:     codStr = "LOGICALOP: "; break;
1251     case LST_SELECTSYM:     codStr = "LST_SELECTSYM"; break;
1252     case LST_OPENSYM:       codStr = "LST_OPENSYM"; break;
1253     case LST_SEPSYM:        codStr = "SEPSYM"; break;
1254     case LST_CLOSESYM:      codStr = "LST_CLOSESYM"; break;
1255     case LST_SIMPLEID:      codStr = "LST_SIMPLEID"; break;
1256     case LST_MAPSYM:        codStr = "MAPSYM"; break;
1257     case LST_MARKERSYM:     codStr = "LST_MARKERSYM"; break;
1258     case LST_COMMENTSYM:    codStr = "COMMENTSYM"; break;
1259     case LST_SIMPLEOP:      codStr = "SIMPLEOP"; break;
1260     case LST_COLON:         codStr = "LST_COLON"; break;
1261     case LST_COMMA:         codStr = "COMMA"; break;
1262     case LST_LBRACKET:      codStr = "LST_LBRACKET"; break;
1263     case LST_LPAR:          codStr = "LST_LPAR"; break;
1264     case LST_RBRACKET:      codStr = "LST_RBRACKET"; break;
1265     case LST_RPAR:          codStr = "LST_RPAR"; break;
1266     case LST_EQOP:          codStr = "LST_EQOP"; break;
1267     case LST_WHITESPACE:    codStr = "WHITESPACE,"; break;
1268     case LST_EOL:           codStr = "LST_EOL"; break;
1269     case LST_elseTOKEN:     codStr = "elseTOKEN"; break;
1270     case LST_ifTOKEN:       codStr = "ifTOKEN"; break;
1271     case LST_thenTOKEN:     codStr = "thenTOKEN"; break;
1272     case LST_BADTOKEN:      codStr = "*** BADTOKEN ***"; break;
1273     case LEOFTOKEN: /* can't reach LEOFTOKEN easily */
1274       codStr = "LEOFTOKEN"; break;
1275     default:
1276       codStr = "*** invalid token code ***";
1277       break;
1278     } /* end switch */
1279
1280   /* only used for debugging */
1281   printf ("%u:%u: Token Code (%u): %s",
1282           ltoken_getLine (tok), ltoken_getCol (tok),
1283           ltoken_getCode (tok), codStr);
1284   if (ltoken_getRawText (tok) != 0)
1285     {
1286       printf (", Token String (%lu): %s\n",
1287               ltoken_getRawText (tok), ltoken_getRawTextChars (tok));
1288     }
1289   else printf ("\n");
1290 }
1291
1292
1293
1294
1295 /*
1296 ** Resets all flags in bison.head
1297 */
1298
1299
1300 /*@=allmacros@*/
1301 /*@=boolint@*/
1302 /*@=charint@*/
1303 /*@=macroparams@*/
1304 /*@=macroundef@*/
1305 /*@=unreachable@*/
1306 /*@=macrospec@*/
1307 /*@=varuse@*/
1308 /*@=ignorequals@*/
1309 /*@=macrostmt@*/
1310 /*@=noeffect@*/
1311 /*@=shadow@*/
1312 /*@=exitarg@*/
1313 /*@=macroredef@*/
1314 /*@=uniondef@*/
1315 /*@=compdef@*/
1316 /*@=matchfields@*/
1317 /*@=exportlocal@*/
1318 /*@=evalorderuncon@*/
1319 /*@=exportheader@*/
1320 /*@=typeuse@*/
1321 /*@=redecl@*/
1322 /*@=redef@*/
1323 /*@=noparams@*/
1324 /*@=ansireserved@*/
1325 /*@=fielduse@*/
1326 /*@=ifblock@*/
1327 /*@=elseifcomplete@*/
1328 /*@=whileblock@*/
1329 /*@=forblock@*/
1330 /*@=branchstate@*/
1331 /*@=readonlytrans@*/
1332 /*@=namechecks@*/
1333 /*@=usedef@*/
1334 /*@=systemunrecog@*/
1335 /*@=dependenttrans@*/
1336 /*@=unqualifiedtrans@*/
1337 /*@=declundef@*/
1338
1339
1340 /*drl added 11/27/2001*/
1341 /*@=bounds@*/
1342
1343 /*drl added 12/11/2002*/
1344 /*@=type@*/