src/mtgrammar.c

   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 /* < end of bison.head > */
  52
  53
  54 /*  A Bison parser, made from mtgrammar.y
  55     by GNU Bison version 1.28  */
  56
  57 #define YYBISON 1  /* Identify Bison output.  */
  58
  59 #define yyparse mtparse
  60 #define yylex mtlex
  61 #define yyerror mterror
  62 #define yylval mtlval
  63 #define yychar mtchar
  64 #define yydebug mtdebug
  65 #define yynerrs mtnerrs
  66 #define MT_BADTOK       257
  67 #define MT_END  258
  68 #define MT_STATE        259
  69 #define MT_GLOBAL       260
  70 #define MT_CONTEXT      261
  71 #define MT_ONEOF        262
  72 #define MT_DEFAULTS     263
  73 #define MT_DEFAULT      264
  74 #define MT_REFERENCE    265
  75 #define MT_PARAMETER    266
  76 #define MT_RESULT       267
  77 #define MT_CLAUSE       268
  78 #define MT_LITERAL      269
  79 #define MT_NULL 270
  80 #define MT_ANNOTATIONS  271
  81 #define MT_ARROW        272
  82 #define MT_MERGE        273
  83 #define MT_TRANSFERS    274
  84 #define MT_PRECONDITIONS        275
  85 #define MT_POSTCONDITIONS       276
  86 #define MT_LOSEREFERENCE        277
  87 #define MT_AS   278
  88 #define MT_ERROR        279
  89 #define MT_PLUS 280
  90 #define MT_STAR 281
  91 #define MT_BAR  282
  92 #define MT_LPAREN       283
  93 #define MT_RPAREN       284
  94 #define MT_LBRACKET     285
  95 #define MT_RBRACKET     286
  96 #define MT_LBRACE       287
  97 #define MT_RBRACE       288
  98 #define MT_COMMA        289
  99 #define MT_CHAR 290
 100 #define MT_INT  291
 101 #define MT_FLOAT        292
 102 #define MT_DOUBLE       293
 103 #define MT_VOID 294
 104 #define MT_ANYTYPE      295
 105 #define MT_INTEGRALTYPE 296
 106 #define MT_UNSIGNEDINTEGRALTYPE 297
 107 #define MT_SIGNEDINTEGRALTYPE   298
 108 #define MT_CONST        299
 109 #define MT_VOLATILE     300
 110 #define MT_STRINGLIT    301
 111 #define MT_IDENT        302
 112
 113
 114
 115 # include "bison.reset"
 116 # include "splintMacros.nf"
 117 # include "llbasic.h"
 118
 119 # ifndef S_SPLINT_S
 120 extern ctype mtscanner_lookupType (mttok p_tok) /*@modifies p_tok@*/ ;
 121 # endif
 122
 123   /*@i523@*/ /* can't include these here
 124     # include "mtgrammar.h"
 125     # include "mtscanner.h"
 126   */
 127
 128 static /*@exits@*/ void mterror (char *);
 129
 130 /*@-noparams@*/ /* Can't list params since YYSTYPE isn't defined yet. */
 131 static void yyprint (/*FILE *p_file, int p_type, YYSTYPE p_value */);
 132 /*@=noparams@*/
 133
 134 # define YYPRINT(file, type, value) yyprint (file, type, value)
 135
 136 # define YYDEBUG 1
 137
 138 # include "bison.head"
 139
 140
 141 typedef union {
 142   mttok tok;
 143   mtDeclarationNode mtdecl;
 144   mtDeclarationPiece mtpiece;
 145   mtDeclarationPieces mtpieces;
 146   mtContextNode mtcontext;
 147   mtValuesNode mtvalues;
 148   mtDefaultsNode mtdefaults;
 149   mtDefaultsDeclList mtdeflist;
 150   mtAnnotationsNode mtannotations;
 151   mtAnnotationList mtannotlist;
 152   mtAnnotationDecl mtannotdecl;
 153   mtMergeNode mtmerge;
 154   mtMergeItem mtmergeitem;
 155   mtMergeClauseList mtmergeclauselist;
 156   mtMergeClause mtmergeclause;
 157   mtTransferClauseList mttransferclauselist;
 158   mtTransferClause mttransferclause;
 159   mtTransferAction mttransferaction;
 160   mtLoseReferenceList mtlosereferencelist;
 161   mtLoseReference mtlosereference;
 162
 163   /*@only@*/ cstringList cstringlist;
 164   ctype ctyp;
 165   /*@only@*/ qtype qtyp;
 166   int count;
 167 } YYSTYPE;
 168 #ifndef YYDEBUG
 169 #define YYDEBUG 1
 170 #endif
 171
 172 #include <stdio.h>
 173
 174 #ifndef __cplusplus
 175 #ifndef __STDC__
 176 #define const
 177 #endif
 178 #endif
 179
 180
 181
 182 #define YYFINAL         135
 183 #define YYFLAG          -32768
 184 #define YYNTBASE        49
 185
 186 #define YYTRANSLATE(x) ((unsigned)(x) <= 302 ? yytranslate[x] : 92)
 187
 188 static const char yytranslate[] = {     0,
 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,     2,     2,     2,     2,     2,
 200      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 201      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 202      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 203      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 204      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 205      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 206      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 207      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 208      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 209      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 210      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 211      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 212      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 213      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 214      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
 215      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
 216     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
 217     27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
 218     37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
 219     47,    48
 220 };
 221
 222 #if YYDEBUG != 0
 223 static const short yyprhs[] = {     0,
 224      0,     1,     3,     7,    12,    15,    16,    19,    21,    23,
 225     25,    27,    29,    31,    33,    35,    37,    39,    42,    43,
 226     45,    48,    51,    54,    57,    60,    63,    64,    66,    68,
 227     71,    73,    77,    80,    81,    83,    85,    87,    90,    92,
 228     95,    98,   102,   104,   106,   108,   111,   115,   118,   122,
 229    124,   126,   128,   130,   132,   134,   136,   138,   140,   142,
 230    144,   147,   149,   153,   156,   159,   163,   168,   171,   173,
 231    176,   181,   184,   186,   189,   195,   197,   199,   202,   205,
 232    208,   211,   213,   216,   220,   222,   225,   231,   233,   235,
 233    237,   240
 234 };
 235
 236 static const short yyrhs[] = {    -1,
 237     50,     0,     5,    51,     4,     0,     6,     5,    51,     4,
 238      0,    48,    52,     0,     0,    53,    52,     0,    54,     0,
 239     69,     0,    72,     0,    71,     0,    74,     0,    77,     0,
 240     83,     0,    81,     0,    82,     0,    84,     0,     7,    56,
 241      0,     0,    56,     0,    12,    57,     0,    11,    57,     0,
 242     13,    57,     0,    14,    57,     0,    15,    57,     0,    16,
 243     57,     0,     0,    58,     0,    59,     0,    59,    62,     0,
 244     60,     0,    59,    28,    58,     0,    67,    61,     0,     0,
 245     59,     0,    63,     0,    66,     0,    63,    66,     0,    27,
 246      0,    27,    65,     0,    27,    63,     0,    27,    65,    63,
 247      0,    45,     0,    46,     0,    64,     0,    65,    64,     0,
 248     29,    62,    30,     0,    31,    32,     0,    66,    31,    32,
 249      0,    36,     0,    37,     0,    38,     0,    39,     0,    40,
 250      0,    41,     0,    42,     0,    43,     0,    44,     0,    68,
 251      0,    48,     0,     8,    70,     0,    48,     0,    48,    35,
 252     70,     0,    10,    91,     0,     9,    73,     0,    56,    18,
 253     91,     0,    56,    18,    91,    73,     0,    17,    75,     0,
 254     76,     0,    76,    75,     0,    48,    55,    18,    91,     0,
 255     19,    78,     0,    79,     0,    79,    78,     0,    80,    26,
 256     80,    18,    89,     0,    91,     0,    27,     0,    21,    87,
 257      0,    22,    87,     0,    20,    87,     0,    23,    85,     0,
 258     86,     0,    86,    85,     0,    91,    18,    90,     0,    88,
 259      0,    88,    87,     0,    91,    24,    91,    18,    89,     0,
 260     91,     0,    90,     0,    25,     0,    25,    47,     0,    48,
 261      0
 262 };
 263
 264 #endif
 265
 266 #if YYDEBUG != 0
 267 static const short yyrline[] = { 0,
 268    157,   158,   161,   163,   167,   171,   172,   176,   177,   178,
 269    179,   180,   181,   182,   183,   184,   185,   188,   192,   193,
 270    196,   197,   198,   199,   200,   201,   208,   209,   212,   213,
 271    216,   217,   221,   224,   225,   229,   230,   231,   234,   235,
 272    236,   237,   240,   241,   244,   245,   248,   249,   250,   257,
 273    258,   259,   260,   261,   262,   263,   264,   265,   266,   272,
 274    275,   278,   279,   283,   286,   289,   291,   295,   298,   299,
 275    303,   307,   310,   311,   314,   318,   319,   322,   325,   328,
 276    331,   334,   335,   338,   341,   342,   345,   349,   350,   353,
 277    354,   357
 278 };
 279 #endif
 280
 281
 282 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
 283
 284 static const char * const yytname[] = {   "$","error","$undefined.","MT_BADTOK",
 285 "MT_END","MT_STATE","MT_GLOBAL","MT_CONTEXT","MT_ONEOF","MT_DEFAULTS","MT_DEFAULT",
 286 "MT_REFERENCE","MT_PARAMETER","MT_RESULT","MT_CLAUSE","MT_LITERAL","MT_NULL",
 287 "MT_ANNOTATIONS","MT_ARROW","MT_MERGE","MT_TRANSFERS","MT_PRECONDITIONS","MT_POSTCONDITIONS",
 288 "MT_LOSEREFERENCE","MT_AS","MT_ERROR","MT_PLUS","MT_STAR","MT_BAR","MT_LPAREN",
 289 "MT_RPAREN","MT_LBRACKET","MT_RBRACKET","MT_LBRACE","MT_RBRACE","MT_COMMA","MT_CHAR",
 290 "MT_INT","MT_FLOAT","MT_DOUBLE","MT_VOID","MT_ANYTYPE","MT_INTEGRALTYPE","MT_UNSIGNEDINTEGRALTYPE",
 291 "MT_SIGNEDINTEGRALTYPE","MT_CONST","MT_VOLATILE","MT_STRINGLIT","MT_IDENT","file",
 292 "mtsDeclaration","declarationNode","declarationPieces","declarationPiece","contextDeclaration",
 293 "optContextSelection","contextSelection","optType","typeExpression","completeType",
 294 "completeTypeAux","optCompleteType","abstractDecl","pointers","innerMods","innerModsList",
 295 "abstractDeclBase","typeSpecifier","typeName","valuesDeclaration","valuesList",
 296 "defaultNode","defaultsDeclaration","defaultDeclarationList","annotationsDeclaration",
 297 "annotationsDeclarationList","annotationDeclaration","mergeDeclaration","mergeClauses",
 298 "mergeClause","mergeItem","preconditionsDeclaration","postconditionsDeclaration",
 299 "transfersDeclaration","loseReferenceDeclaration","lostClauses","lostClause",
 300 "transferClauses","transferClause","transferAction","errorAction","valueChoice", NULL
 301 };
 302 #endif
 303
 304 static const short yyr1[] = {     0,
 305     49,    49,    50,    50,    51,    52,    52,    53,    53,    53,
 306     53,    53,    53,    53,    53,    53,    53,    54,    55,    55,
 307     56,    56,    56,    56,    56,    56,    57,    57,    58,    58,
 308     59,    59,    60,    61,    61,    62,    62,    62,    63,    63,
 309     63,    63,    64,    64,    65,    65,    66,    66,    66,    67,
 310     67,    67,    67,    67,    67,    67,    67,    67,    67,    68,
 311     69,    70,    70,    71,    72,    73,    73,    74,    75,    75,
 312     76,    77,    78,    78,    79,    80,    80,    81,    82,    83,
 313     84,    85,    85,    86,    87,    87,    88,    89,    89,    90,
 314     90,    91
 315 };
 316
 317 static const short yyr2[] = {     0,
 318      0,     1,     3,     4,     2,     0,     2,     1,     1,     1,
 319      1,     1,     1,     1,     1,     1,     1,     2,     0,     1,
 320      2,     2,     2,     2,     2,     2,     0,     1,     1,     2,
 321      1,     3,     2,     0,     1,     1,     1,     2,     1,     2,
 322      2,     3,     1,     1,     1,     2,     3,     2,     3,     1,
 323      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
 324      2,     1,     3,     2,     2,     3,     4,     2,     1,     2,
 325      4,     2,     1,     2,     5,     1,     1,     2,     2,     2,
 326      2,     1,     2,     3,     1,     2,     5,     1,     1,     1,
 327      2,     1
 328 };
 329
 330 static const short yydefact[] = {     1,
 331      0,     0,     2,     6,     0,     0,     0,     0,     0,     0,
 332      0,     0,     0,     0,     0,     0,     5,     6,     8,     9,
 333     11,    10,    12,    13,    15,    16,    14,    17,     3,     0,
 334     27,    27,    27,    27,    27,    27,    18,    62,    61,     0,
 335     65,    92,    64,    19,    68,    69,    77,    72,    73,     0,
 336     76,    80,    85,     0,    78,    79,    81,    82,     0,     7,
 337      4,    50,    51,    52,    53,    54,    55,    56,    57,    58,
 338     60,    22,    28,    29,    31,    34,    59,    21,    23,    24,
 339     25,    26,     0,     0,     0,    20,    70,    74,     0,    86,
 340      0,    83,     0,    39,     0,     0,     0,    30,    36,    37,
 341     35,    33,    63,    66,     0,     0,     0,    90,    84,    43,
 342     44,    41,    45,    40,    32,     0,    48,    38,     0,    67,
 343     71,     0,     0,    91,    42,    46,    47,    49,    75,    89,
 344     88,    87,     0,     0,     0
 345 };
 346
 347 static const short yydefgoto[] = {   133,
 348      3,     5,    17,    18,    19,    85,    40,    72,    73,    74,
 349     75,   102,    98,    99,   113,   114,   100,    76,    77,    20,
 350     39,    21,    22,    41,    23,    45,    46,    24,    48,    49,
 351     50,    25,    26,    27,    28,    57,    58,    52,    53,   129,
 352    130,    54
 353 };
 354
 355 static const short yypact[] = {     4,
 356    -37,    35,-32768,    36,    37,   -37,    21,     2,    21,    17,
 357     18,   -19,    17,    17,    17,    17,-32768,    36,-32768,-32768,
 358 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    63,
 359    -23,   -23,   -23,   -23,   -23,   -23,-32768,    33,-32768,    51,
 360 -32768,-32768,-32768,    21,-32768,    18,-32768,-32768,   -19,    44,
 361 -32768,-32768,    17,    47,-32768,-32768,-32768,    17,    54,-32768,
 362 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
 363 -32768,-32768,-32768,    -5,-32768,   -23,-32768,-32768,-32768,-32768,
 364 -32768,-32768,     2,    17,    55,-32768,-32768,-32768,   -19,-32768,
 365     17,-32768,    50,   -15,   -23,    20,    45,-32768,    23,    49,
 366     48,-32768,-32768,    21,    17,    60,    64,    38,-32768,-32768,
 367 -32768,-32768,-32768,   -15,-32768,    53,-32768,    49,    52,-32768,
 368 -32768,   -20,   -20,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
 369 -32768,-32768,    86,    87,-32768
 370 };
 371
 372 static const short yypgoto[] = {-32768,
 373 -32768,    82,    71,-32768,-32768,-32768,    -6,    28,    -4,    14,
 374 -32768,-32768,    -3,   -87,   -22,-32768,    -2,-32768,-32768,-32768,
 375     11,-32768,-32768,    -8,-32768,    56,-32768,-32768,    57,-32768,
 376      9,-32768,-32768,-32768,-32768,    41,-32768,   -11,-32768,   -18,
 377      7,   -10
 378 };
 379
 380
 381 #define YYLAST          113
 382
 383
 384 static const short yytable[] = {    43,
 385     37,    51,    55,    56,   108,    59,   112,    47,     1,     2,
 386      4,    94,    62,    63,    64,    65,    66,    67,    68,    69,
 387     70,    94,    95,    96,    71,    97,   125,    42,    42,   110,
 388    111,    31,    32,    33,    34,    35,    36,    86,    51,     6,
 389     29,    90,     7,     8,     9,    10,    94,    59,    96,    38,
 390     97,    96,    11,    97,    12,    13,    14,    15,    16,    78,
 391     79,    80,    81,    82,    42,    44,    61,    83,    84,    89,
 392     91,    93,   105,   104,   108,    95,   117,   122,    51,   119,
 393    107,   123,   127,   128,   124,   134,   135,    30,    60,   101,
 394    115,   126,   116,   103,   121,   120,   118,   106,    92,   109,
 395      0,    87,     0,     0,   132,    88,     0,     0,     0,     0,
 396      0,   131,   131
 397 };
 398
 399 static const short yycheck[] = {    10,
 400      7,    12,    14,    15,    25,    16,    94,    27,     5,     6,
 401     48,    27,    36,    37,    38,    39,    40,    41,    42,    43,
 402     44,    27,    28,    29,    48,    31,   114,    48,    48,    45,
 403     46,    11,    12,    13,    14,    15,    16,    44,    49,     5,
 404      4,    53,     7,     8,     9,    10,    27,    58,    29,    48,
 405     31,    29,    17,    31,    19,    20,    21,    22,    23,    32,
 406     33,    34,    35,    36,    48,    48,     4,    35,    18,    26,
 407     24,    18,    18,    84,    25,    28,    32,    18,    89,    31,
 408     91,    18,    30,    32,    47,     0,     0,     6,    18,    76,
 409     95,   114,    96,    83,   105,   104,    99,    89,    58,    93,
 410     -1,    46,    -1,    -1,   123,    49,    -1,    -1,    -1,    -1,
 411     -1,   122,   123
 412 };
 413 #define YYPURE 1
 414
 415 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 416
 417 /* This file comes from bison-1.28.  */
 418
 419 /* Skeleton output parser for bison,
 420    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 421
 422    This program is free software; you can redistribute it and/or modify
 423    it under the terms of the GNU General Public License as published by
 424    the Free Software Foundation; either version 2, or (at your option)
 425    any later version.
 426
 427    This program is distributed in the hope that it will be useful,
 428    but WITHOUT ANY WARRANTY; without even the implied warranty of
 429    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 430    GNU General Public License for more details.
 431
 432    You should have received a copy of the GNU General Public License
 433    along with this program; if not, write to the Free Software
 434    Foundation, Inc., 59 Temple Place - Suite 330,
 435    Boston, MA 02111-1307, USA.  */
 436
 437 /* As a special exception, when this file is copied by Bison into a
 438    Bison output file, you may use that output file without restriction.
 439    This special exception was added by the Free Software Foundation
 440    in version 1.24 of Bison.  */
 441
 442 /* This is the parser code that is written into each bison parser
 443   when the %semantic_parser declaration is not specified in the grammar.
 444   It was written by Richard Stallman by simplifying the hairy parser
 445   used when %semantic_parser is specified.  */
 446
 447 #ifndef YYSTACK_USE_ALLOCA
 448 #ifdef alloca
 449 #define YYSTACK_USE_ALLOCA
 450 #else /* alloca not defined */
 451 #ifdef __GNUC__
 452 #define YYSTACK_USE_ALLOCA
 453 #define alloca __builtin_alloca
 454 #else /* not GNU C.  */
 455 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
 456 #define YYSTACK_USE_ALLOCA
 457 #include <alloca.h>
 458 #else /* not sparc */
 459 /* We think this test detects Watcom and Microsoft C.  */
 460 /* This used to test MSDOS, but that is a bad idea
 461    since that symbol is in the user namespace.  */
 462 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
 463 #if 0 /* No need for malloc.h, which pollutes the namespace;
 464          instead, just don't use alloca.  */
 465 #include <malloc.h>
 466 #endif
 467 #else /* not MSDOS, or __TURBOC__ */
 468 #if defined(_AIX)
 469 /* I don't know what this was needed for, but it pollutes the namespace.
 470    So I turned it off.   rms, 2 May 1997.  */
 471 /* #include <malloc.h>  */
 472  #pragma alloca
 473 #define YYSTACK_USE_ALLOCA
 474 #else /* not MSDOS, or __TURBOC__, or _AIX */
 475 #if 0
 476 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
 477                  and on HPUX 10.  Eventually we can turn this on.  */
 478 #define YYSTACK_USE_ALLOCA
 479 #define alloca __builtin_alloca
 480 #endif /* __hpux */
 481 #endif
 482 #endif /* not _AIX */
 483 #endif /* not MSDOS, or __TURBOC__ */
 484 #endif /* not sparc */
 485 #endif /* not GNU C */
 486 #endif /* alloca not defined */
 487 #endif /* YYSTACK_USE_ALLOCA not defined */
 488
 489 #ifdef YYSTACK_USE_ALLOCA
 490 #define YYSTACK_ALLOC alloca
 491 #else
 492 #define YYSTACK_ALLOC malloc
 493 #endif
 494
 495 /* Note: there must be only one dollar sign in this file.
 496    It is replaced by the list of actions, each action
 497    as one case of the switch.  */
 498
 499 #define yyerrok         (yyerrstatus = 0)
 500 #define yyclearin       (yychar = YYEMPTY)
 501 #define YYEMPTY         -2
 502 #define YYEOF           0
 503 #define YYACCEPT        goto yyacceptlab
 504 #define YYABORT         goto yyabortlab
 505 #define YYERROR         goto yyerrlab1
 506 /* Like YYERROR except do call yyerror.
 507    This remains here temporarily to ease the
 508    transition to the new meaning of YYERROR, for GCC.
 509    Once GCC version 2 has supplanted version 1, this can go.  */
 510 #define YYFAIL          goto yyerrlab
 511 #define YYRECOVERING()  (!!yyerrstatus)
 512 #define YYBACKUP(token, value) \
 513 do                                                              \
 514   if (yychar == YYEMPTY && yylen == 1)                          \
 515     { yychar = (token), yylval = (value);                       \
 516       yychar1 = YYTRANSLATE (yychar);                           \
 517       YYPOPSTACK;                                               \
 518       goto yybackup;                                            \
 519     }                                                           \
 520   else                                                          \
 521     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
 522 while (0)
 523
 524 #define YYTERROR        1
 525 #define YYERRCODE       256
 526
 527 #ifndef YYPURE
 528 #define YYLEX           yylex()
 529 #endif
 530
 531 #ifdef YYPURE
 532 #ifdef YYLSP_NEEDED
 533 #ifdef YYLEX_PARAM
 534 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
 535 #else
 536 #define YYLEX           yylex(&yylval, &yylloc)
 537 #endif
 538 #else /* not YYLSP_NEEDED */
 539 #ifdef YYLEX_PARAM
 540 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
 541 #else
 542 #define YYLEX           yylex(&yylval)
 543 #endif
 544 #endif /* not YYLSP_NEEDED */
 545 #endif
 546
 547 /* If nonreentrant, generate the variables here */
 548
 549 #ifndef YYPURE
 550
 551 int     yychar;                 /*  the lookahead symbol                */
 552 YYSTYPE yylval;                 /*  the semantic value of the           */
 553                                 /*  lookahead symbol                    */
 554
 555 #ifdef YYLSP_NEEDED
 556 YYLTYPE yylloc;                 /*  location data for the lookahead     */
 557                                 /*  symbol                              */
 558 #endif
 559
 560 int yynerrs;                    /*  number of parse errors so far       */
 561 #endif  /* not YYPURE */
 562
 563 #if YYDEBUG != 0
 564 int yydebug;                    /*  nonzero means print parse trace     */
 565 /* Since this is uninitialized, it does not stop multiple parsers
 566    from coexisting.  */
 567 #endif
 568
 569 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
 570
 571 #ifndef YYINITDEPTH
 572 #define YYINITDEPTH 200
 573 #endif
 574
 575 /*  YYMAXDEPTH is the maximum size the stacks can grow to
 576     (effective only if the built-in stack extension method is used).  */
 577
 578 #if YYMAXDEPTH == 0
 579 #undef YYMAXDEPTH
 580 #endif
 581
 582 #ifndef YYMAXDEPTH
 583 #define YYMAXDEPTH 10000
 584 #endif
 585 \f
 586 /* Define __yy_memcpy.  Note that the size argument
 587    should be passed with type unsigned int, because that is what the non-GCC
 588    definitions require.  With GCC, __builtin_memcpy takes an arg
 589    of type size_t, but it can handle unsigned int.  */
 590
 591 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
 592 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
 593 #else                           /* not GNU C or C++ */
 594 #ifndef __cplusplus
 595
 596 /* This is the most reliable way to avoid incompatibilities
 597    in available built-in functions on various systems.  */
 598 static void
 599 __yy_memcpy (to, from, count)
 600      char *to;
 601      char *from;
 602      unsigned int count;
 603 {
 604   register char *f = from;
 605   register char *t = to;
 606   register int i = count;
 607
 608   while (i-- > 0)
 609     *t++ = *f++;
 610 }
 611
 612 #else /* __cplusplus */
 613
 614 /* This is the most reliable way to avoid incompatibilities
 615    in available built-in functions on various systems.  */
 616 static void
 617 __yy_memcpy (char *to, char *from, unsigned int count)
 618 {
 619   register char *t = to;
 620   register char *f = from;
 621   register int i = count;
 622
 623   while (i-- > 0)
 624     *t++ = *f++;
 625 }
 626
 627 #endif
 628 #endif
 629 \f
 630
 631
 632 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 633    into yyparse.  The argument should have type void *.
 634    It should actually point to an object.
 635    Grammar actions can access the variable by casting it
 636    to the proper pointer type.  */
 637
 638 #ifdef YYPARSE_PARAM
 639 #ifdef __cplusplus
 640 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 641 #define YYPARSE_PARAM_DECL
 642 #else /* not __cplusplus */
 643 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
 644 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 645 #endif /* not __cplusplus */
 646 #else /* not YYPARSE_PARAM */
 647 #define YYPARSE_PARAM_ARG
 648 #define YYPARSE_PARAM_DECL
 649 #endif /* not YYPARSE_PARAM */
 650
 651 /* Prevent warning if -Wstrict-prototypes.  */
 652 #ifdef __GNUC__
 653 #ifdef YYPARSE_PARAM
 654 int yyparse (void *);
 655 #else
 656 int yyparse (void);
 657 #endif
 658 #endif
 659
 660 int
 661 yyparse(YYPARSE_PARAM_ARG)
 662      YYPARSE_PARAM_DECL
 663 {
 664   register int yystate;
 665   register int yyn;
 666   register short *yyssp;
 667   register YYSTYPE *yyvsp;
 668   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
 669   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
 670
 671   short yyssa[YYINITDEPTH];     /*  the state stack                     */
 672   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
 673
 674   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
 675   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
 676
 677 #ifdef YYLSP_NEEDED
 678   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
 679   YYLTYPE *yyls = yylsa;
 680   YYLTYPE *yylsp;
 681
 682 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 683 #else
 684 #define YYPOPSTACK   (yyvsp--, yyssp--)
 685 #endif
 686
 687   int yystacksize = YYINITDEPTH;
 688   int yyfree_stacks = 0;
 689
 690 #ifdef YYPURE
 691   int yychar;
 692   YYSTYPE yylval;
 693   int yynerrs;
 694 #ifdef YYLSP_NEEDED
 695   YYLTYPE yylloc;
 696 #endif
 697 #endif
 698
 699   YYSTYPE yyval;                /*  the variable used to return         */
 700                                 /*  semantic values from the action     */
 701                                 /*  routines                            */
 702
 703   int yylen;
 704
 705 #if YYDEBUG != 0
 706   if (yydebug)
 707     fprintf(stderr, "Starting parse\n");
 708 #endif
 709
 710   yystate = 0;
 711   yyerrstatus = 0;
 712   yynerrs = 0;
 713   yychar = YYEMPTY;             /* Cause a token to be read.  */
 714
 715   /* Initialize stack pointers.
 716      Waste one element of value and location stack
 717      so that they stay on the same level as the state stack.
 718      The wasted elements are never initialized.  */
 719
 720   yyssp = yyss - 1;
 721   yyvsp = yyvs;
 722 #ifdef YYLSP_NEEDED
 723   yylsp = yyls;
 724 #endif
 725
 726 /* Push a new state, which is found in  yystate  .  */
 727 /* In all cases, when you get here, the value and location stacks
 728    have just been pushed. so pushing a state here evens the stacks.  */
 729 yynewstate:
 730
 731   *++yyssp = yystate;
 732
 733   if (yyssp >= yyss + yystacksize - 1)
 734     {
 735       /* Give user a chance to reallocate the stack */
 736       /* Use copies of these so that the &'s don't force the real ones into memory. */
 737       YYSTYPE *yyvs1 = yyvs;
 738       short *yyss1 = yyss;
 739 #ifdef YYLSP_NEEDED
 740       YYLTYPE *yyls1 = yyls;
 741 #endif
 742
 743       /* Get the current used size of the three stacks, in elements.  */
 744       int size = yyssp - yyss + 1;
 745
 746 #ifdef yyoverflow
 747       /* Each stack pointer address is followed by the size of
 748          the data in use in that stack, in bytes.  */
 749 #ifdef YYLSP_NEEDED
 750       /* This used to be a conditional around just the two extra args,
 751          but that might be undefined if yyoverflow is a macro.  */
 752       yyoverflow("parser stack overflow",
 753                  &yyss1, size * sizeof (*yyssp),
 754                  &yyvs1, size * sizeof (*yyvsp),
 755                  &yyls1, size * sizeof (*yylsp),
 756                  &yystacksize);
 757 #else
 758       yyoverflow("parser stack overflow",
 759                  &yyss1, size * sizeof (*yyssp),
 760                  &yyvs1, size * sizeof (*yyvsp),
 761                  &yystacksize);
 762 #endif
 763
 764       yyss = yyss1; yyvs = yyvs1;
 765 #ifdef YYLSP_NEEDED
 766       yyls = yyls1;
 767 #endif
 768 #else /* no yyoverflow */
 769       /* Extend the stack our own way.  */
 770       if (yystacksize >= YYMAXDEPTH)
 771         {
 772           yyerror("parser stack overflow");
 773           if (yyfree_stacks)
 774             {
 775               free (yyss);
 776               free (yyvs);
 777 #ifdef YYLSP_NEEDED
 778               free (yyls);
 779 #endif
 780             }
 781           return 2;
 782         }
 783       yystacksize *= 2;
 784       if (yystacksize > YYMAXDEPTH)
 785         yystacksize = YYMAXDEPTH;
 786 #ifndef YYSTACK_USE_ALLOCA
 787       yyfree_stacks = 1;
 788 #endif
 789       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
 790       __yy_memcpy ((char *)yyss, (char *)yyss1,
 791                    size * (unsigned int) sizeof (*yyssp));
 792       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
 793       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
 794                    size * (unsigned int) sizeof (*yyvsp));
 795 #ifdef YYLSP_NEEDED
 796       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
 797       __yy_memcpy ((char *)yyls, (char *)yyls1,
 798                    size * (unsigned int) sizeof (*yylsp));
 799 #endif
 800 #endif /* no yyoverflow */
 801
 802       yyssp = yyss + size - 1;
 803       yyvsp = yyvs + size - 1;
 804 #ifdef YYLSP_NEEDED
 805       yylsp = yyls + size - 1;
 806 #endif
 807
 808 #if YYDEBUG != 0
 809       if (yydebug)
 810         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
 811 #endif
 812
 813       if (yyssp >= yyss + yystacksize - 1)
 814         YYABORT;
 815     }
 816
 817 #if YYDEBUG != 0
 818   if (yydebug)
 819     fprintf(stderr, "Entering state %d\n", yystate);
 820 #endif
 821
 822   goto yybackup;
 823  yybackup:
 824
 825 /* Do appropriate processing given the current state.  */
 826 /* Read a lookahead token if we need one and don't already have one.  */
 827 /* yyresume: */
 828
 829   /* First try to decide what to do without reference to lookahead token.  */
 830
 831   yyn = yypact[yystate];
 832   if (yyn == YYFLAG)
 833     goto yydefault;
 834
 835   /* Not known => get a lookahead token if don't already have one.  */
 836
 837   /* yychar is either YYEMPTY or YYEOF
 838      or a valid token in external form.  */
 839
 840   if (yychar == YYEMPTY)
 841     {
 842 #if YYDEBUG != 0
 843       if (yydebug)
 844         fprintf(stderr, "Reading a token: ");
 845 #endif
 846       yychar = YYLEX;
 847     }
 848
 849   /* Convert token to internal form (in yychar1) for indexing tables with */
 850
 851   if (yychar <= 0)              /* This means end of input. */
 852     {
 853       yychar1 = 0;
 854       yychar = YYEOF;           /* Don't call YYLEX any more */
 855
 856 #if YYDEBUG != 0
 857       if (yydebug)
 858         fprintf(stderr, "Now at end of input.\n");
 859 #endif
 860     }
 861   else
 862     {
 863       yychar1 = YYTRANSLATE(yychar);
 864
 865 #if YYDEBUG != 0
 866       if (yydebug)
 867         {
 868           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
 869           /* Give the individual parser a way to print the precise meaning
 870              of a token, for further debugging info.  */
 871 #ifdef YYPRINT
 872           YYPRINT (stderr, yychar, yylval);
 873 #endif
 874           fprintf (stderr, ")\n");
 875         }
 876 #endif
 877     }
 878
 879   yyn += yychar1;
 880   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 881     goto yydefault;
 882
 883   yyn = yytable[yyn];
 884
 885   /* yyn is what to do for this token type in this state.
 886      Negative => reduce, -yyn is rule number.
 887      Positive => shift, yyn is new state.
 888        New state is final state => don't bother to shift,
 889        just return success.
 890      0, or most negative number => error.  */
 891
 892   if (yyn < 0)
 893     {
 894       if (yyn == YYFLAG)
 895         goto yyerrlab;
 896       yyn = -yyn;
 897       goto yyreduce;
 898     }
 899   else if (yyn == 0)
 900     goto yyerrlab;
 901
 902   if (yyn == YYFINAL)
 903     YYACCEPT;
 904
 905   /* Shift the lookahead token.  */
 906
 907 #if YYDEBUG != 0
 908   if (yydebug)
 909     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
 910 #endif
 911
 912   /* Discard the token being shifted unless it is eof.  */
 913   if (yychar != YYEOF)
 914     yychar = YYEMPTY;
 915
 916   *++yyvsp = yylval;
 917 #ifdef YYLSP_NEEDED
 918   *++yylsp = yylloc;
 919 #endif
 920
 921   /* count tokens shifted since error; after three, turn off error status.  */
 922   if (yyerrstatus) yyerrstatus--;
 923
 924   yystate = yyn;
 925   goto yynewstate;
 926
 927 /* Do the default action for the current state.  */
 928 yydefault:
 929
 930   yyn = yydefact[yystate];
 931   if (yyn == 0)
 932     goto yyerrlab;
 933
 934 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
 935 yyreduce:
 936   yylen = yyr2[yyn];
 937   if (yylen > 0)
 938     yyval = yyvsp[1-yylen]; /* implement default value of the action */
 939
 940 #if YYDEBUG != 0
 941   if (yydebug)
 942     {
 943       int i;
 944
 945       fprintf (stderr, "Reducing via rule %d (line %d), ",
 946                yyn, yyrline[yyn]);
 947
 948       /* Print the symbols being reduced, and their result.  */
 949       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
 950         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
 951       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 952     }
 953 #endif
 954
 955
 956   switch (yyn) {
 957
 958 case 1:
 959 {;
 960     break;}
 961 case 2:
 962 {;
 963     break;}
 964 case 3:
 965 { mtreader_processDeclaration (yyvsp[-1].mtdecl); ;
 966     break;}
 967 case 4:
 968 { mtreader_processGlobalDeclaration (yyvsp[-1].mtdecl); ;
 969     break;}
 970 case 5:
 971 { yyval.mtdecl = mtDeclarationNode_create (yyvsp[-1].tok, yyvsp[0].mtpieces); ;
 972     break;}
 973 case 6:
 974 { yyval.mtpieces = mtDeclarationPieces_create (); ;
 975     break;}
 976 case 7:
 977 { yyval.mtpieces = mtDeclarationPieces_append (yyvsp[0].mtpieces, yyvsp[-1].mtpiece); ;
 978     break;}
 979 case 8:
 980 { yyval.mtpiece = mtDeclarationPiece_createContext (yyvsp[0].mtcontext); ;
 981     break;}
 982 case 9:
 983 { yyval.mtpiece = mtDeclarationPiece_createValues (yyvsp[0].mtvalues); ;
 984     break;}
 985 case 10:
 986 { yyval.mtpiece = mtDeclarationPiece_createDefaults (yyvsp[0].mtdefaults); ;
 987     break;}
 988 case 11:
 989 { yyval.mtpiece = mtDeclarationPiece_createValueDefault (yyvsp[0].tok); ;
 990     break;}
 991 case 12:
 992 { yyval.mtpiece = mtDeclarationPiece_createAnnotations (yyvsp[0].mtannotations); ;
 993     break;}
 994 case 13:
 995 { yyval.mtpiece = mtDeclarationPiece_createMerge (yyvsp[0].mtmerge); ;
 996     break;}
 997 case 14:
 998 { yyval.mtpiece = mtDeclarationPiece_createTransfers (yyvsp[0].mttransferclauselist); ;
 999     break;}
1000 case 15:
1001 { yyval.mtpiece = mtDeclarationPiece_createPreconditions (yyvsp[0].mttransferclauselist); ;
1002     break;}
1003 case 16:
1004 { yyval.mtpiece = mtDeclarationPiece_createPostconditions (yyvsp[0].mttransferclauselist); ;
1005     break;}
1006 case 17:
1007 { yyval.mtpiece = mtDeclarationPiece_createLosers (yyvsp[0].mtlosereferencelist); ;
1008     break;}
1009 case 18:
1010 { yyval.mtcontext = yyvsp[0].mtcontext; ;
1011     break;}
1012 case 19:
1013 { yyval.mtcontext = mtContextNode_createAny (); ;
1014     break;}
1015 case 21:
1016 { yyval.mtcontext = mtContextNode_createParameter (yyvsp[0].ctyp); ;
1017     break;}
1018 case 22:
1019 { yyval.mtcontext = mtContextNode_createReference (yyvsp[0].ctyp); ;
1020     break;}
1021 case 23:
1022 { yyval.mtcontext = mtContextNode_createResult (yyvsp[0].ctyp); ;
1023     break;}
1024 case 24:
1025 { yyval.mtcontext = mtContextNode_createClause (yyvsp[0].ctyp); ;
1026     break;}
1027 case 25:
1028 { yyval.mtcontext = mtContextNode_createLiteral (yyvsp[0].ctyp); ;
1029     break;}
1030 case 26:
1031 { yyval.mtcontext = mtContextNode_createNull (yyvsp[0].ctyp); ;
1032     break;}
1033 case 27:
1034 { yyval.ctyp = ctype_unknown; ;
1035     break;}
1036 case 28:
1037 { DPRINTF (("Type: %s", qtype_unparse (yyvsp[0].qtyp))); yyval.ctyp = qtype_getType (yyvsp[0].qtyp); ;
1038     break;}
1039 case 30:
1040 { yyval.qtyp = qtype_newBase (yyvsp[-1].qtyp, yyvsp[0].ctyp); ;
1041     break;}
1042 case 31:
1043 { yyval.qtyp = yyvsp[0].qtyp; ;
1044     break;}
1045 case 32:
1046 { yyval.qtyp = qtype_mergeAlt (yyvsp[-2].qtyp, yyvsp[0].qtyp); ;
1047     break;}
1048 case 33:
1049 { yyval.qtyp = qtype_combine (yyvsp[0].qtyp, yyvsp[-1].ctyp); ;
1050     break;}
1051 case 34:
1052 { yyval.qtyp = qtype_unknown (); ;
1053     break;}
1054 case 35:
1055 { yyval.qtyp = yyvsp[0].qtyp; ;
1056     break;}
1057 case 36:
1058 { yyval.ctyp = ctype_adjustPointers (yyvsp[0].count, ctype_unknown); ;
1059     break;}
1060 case 38:
1061 { yyval.ctyp = ctype_adjustPointers (yyvsp[-1].count, yyvsp[0].ctyp); ;
1062     break;}
1063 case 39:
1064 { yyval.count = 1; ;
1065     break;}
1066 case 40:
1067 { yyval.count = 1; ;
1068     break;}
1069 case 41:
1070 { yyval.count = 1 + yyvsp[0].count; ;
1071     break;}
1072 case 42:
1073 { yyval.count = 1 + yyvsp[0].count; ;
1074     break;}
1075 case 43:
1076 { /* ignored for now */; ;
1077     break;}
1078 case 44:
1079 { ; ;
1080     break;}
1081 case 45:
1082 { ; ;
1083     break;}
1084 case 46:
1085 { ; ;
1086     break;}
1087 case 47:
1088 { yyval.ctyp = ctype_expectFunction (yyvsp[-1].ctyp); ;
1089     break;}
1090 case 48:
1091 { yyval.ctyp = ctype_makeArray (ctype_unknown); ;
1092     break;}
1093 case 49:
1094 { yyval.ctyp = ctype_makeArray (yyvsp[-2].ctyp); ;
1095     break;}
1096 case 50:
1097 { yyval.ctyp = ctype_char; ;
1098     break;}
1099 case 51:
1100 { yyval.ctyp = ctype_int; ;
1101     break;}
1102 case 52:
1103 { yyval.ctyp = ctype_float; ;
1104     break;}
1105 case 53:
1106 { yyval.ctyp = ctype_double; ;
1107     break;}
1108 case 54:
1109 { yyval.ctyp = ctype_void; ;
1110     break;}
1111 case 55:
1112 { yyval.ctyp = ctype_unknown; ;
1113     break;}
1114 case 56:
1115 { yyval.ctyp = ctype_anyintegral; ;
1116     break;}
1117 case 57:
1118 { yyval.ctyp = ctype_unsignedintegral; ;
1119     break;}
1120 case 58:
1121 { yyval.ctyp = ctype_signedintegral; ;
1122     break;}
1123 case 60:
1124 { yyval.ctyp = mtscanner_lookupType (yyvsp[0].tok); ;
1125     break;}
1126 case 61:
1127 { yyval.mtvalues = mtValuesNode_create (yyvsp[0].cstringlist); ;
1128     break;}
1129 case 62:
1130 { yyval.cstringlist = cstringList_single (mttok_getText (yyvsp[0].tok)); ;
1131     break;}
1132 case 63:
1133 { yyval.cstringlist = cstringList_prepend (yyvsp[0].cstringlist, mttok_getText (yyvsp[-2].tok)); ;
1134     break;}
1135 case 64:
1136 { yyval.tok = yyvsp[0].tok; ;
1137     break;}
1138 case 65:
1139 { yyval.mtdefaults = mtDefaultsNode_create (yyvsp[-1].tok, yyvsp[0].mtdeflist); ;
1140     break;}
1141 case 66:
1142 { yyval.mtdeflist = mtDefaultsDeclList_single (mtDefaultsDecl_create (yyvsp[-2].mtcontext, yyvsp[0].tok)); ;
1143     break;}
1144 case 67:
1145 { yyval.mtdeflist = mtDefaultsDeclList_prepend (yyvsp[0].mtdeflist, mtDefaultsDecl_create (yyvsp[-3].mtcontext, yyvsp[-1].tok)); ;
1146     break;}
1147 case 68:
1148 { yyval.mtannotations = mtAnnotationsNode_create (yyvsp[0].mtannotlist); ;
1149     break;}
1150 case 69:
1151 { yyval.mtannotlist = mtAnnotationList_single (yyvsp[0].mtannotdecl); ;
1152     break;}
1153 case 70:
1154 { yyval.mtannotlist = mtAnnotationList_prepend (yyvsp[0].mtannotlist, yyvsp[-1].mtannotdecl); ;
1155     break;}
1156 case 71:
1157 { yyval.mtannotdecl = mtAnnotationDecl_create (yyvsp[-3].tok, yyvsp[-2].mtcontext, yyvsp[0].tok); ;
1158     break;}
1159 case 72:
1160 { yyval.mtmerge = mtMergeNode_create (yyvsp[0].mtmergeclauselist); ;
1161     break;}
1162 case 73:
1163 { yyval.mtmergeclauselist = mtMergeClauseList_single (yyvsp[0].mtmergeclause); ;
1164     break;}
1165 case 74:
1166 { yyval.mtmergeclauselist = mtMergeClauseList_prepend (yyvsp[0].mtmergeclauselist, yyvsp[-1].mtmergeclause); ;
1167     break;}
1168 case 75:
1169 { yyval.mtmergeclause = mtMergeClause_create (yyvsp[-4].mtmergeitem, yyvsp[-2].mtmergeitem, yyvsp[0].mttransferaction); ;
1170     break;}
1171 case 76:
1172 { yyval.mtmergeitem = mtMergeItem_createValue (yyvsp[0].tok); ;
1173     break;}
1174 case 77:
1175 { yyval.mtmergeitem = mtMergeItem_createStar (yyvsp[0].tok); ;
1176     break;}
1177 case 78:
1178 { yyval.mttransferclauselist = yyvsp[0].mttransferclauselist; ;
1179     break;}
1180 case 79:
1181 { yyval.mttransferclauselist = yyvsp[0].mttransferclauselist; ;
1182     break;}
1183 case 80:
1184 { yyval.mttransferclauselist = yyvsp[0].mttransferclauselist; ;
1185     break;}
1186 case 81:
1187 { yyval.mtlosereferencelist = yyvsp[0].mtlosereferencelist; ;
1188     break;}
1189 case 82:
1190 { yyval.mtlosereferencelist = mtLoseReferenceList_single (yyvsp[0].mtlosereference); ;
1191     break;}
1192 case 83:
1193 { yyval.mtlosereferencelist = mtLoseReferenceList_prepend (yyvsp[0].mtlosereferencelist, yyvsp[-1].mtlosereference); ;
1194     break;}
1195 case 84:
1196 { yyval.mtlosereference = mtLoseReference_create (yyvsp[-2].tok, yyvsp[0].mttransferaction); ;
1197     break;}
1198 case 85:
1199 { yyval.mttransferclauselist = mtTransferClauseList_single (yyvsp[0].mttransferclause); ;
1200     break;}
1201 case 86:
1202 { yyval.mttransferclauselist = mtTransferClauseList_prepend (yyvsp[0].mttransferclauselist, yyvsp[-1].mttransferclause); ;
1203     break;}
1204 case 87:
1205 { yyval.mttransferclause = mtTransferClause_create (yyvsp[-4].tok, yyvsp[-2].tok, yyvsp[0].mttransferaction); ;
1206     break;}
1207 case 88:
1208 { yyval.mttransferaction = mtTransferAction_createValue (yyvsp[0].tok); ;
1209     break;}
1210 case 89:
1211 { yyval.mttransferaction = yyvsp[0].mttransferaction; ;
1212     break;}
1213 case 90:
1214 { yyval.mttransferaction = mtTransferAction_createError (yyvsp[0].tok); ;
1215     break;}
1216 case 91:
1217 { yyval.mttransferaction = mtTransferAction_createErrorMessage (yyvsp[0].tok); ;
1218     break;}
1219 }
1220    /* the action file gets copied in in place of this dollarsign */
1221
1222 \f
1223   yyvsp -= yylen;
1224   yyssp -= yylen;
1225 #ifdef YYLSP_NEEDED
1226   yylsp -= yylen;
1227 #endif
1228
1229 #if YYDEBUG != 0
1230   if (yydebug)
1231     {
1232       short *ssp1 = yyss - 1;
1233       fprintf (stderr, "state stack now");
1234       while (ssp1 != yyssp)
1235         fprintf (stderr, " %d", *++ssp1);
1236       fprintf (stderr, "\n");
1237     }
1238 #endif
1239
1240   *++yyvsp = yyval;
1241
1242 #ifdef YYLSP_NEEDED
1243   yylsp++;
1244   if (yylen == 0)
1245     {
1246       yylsp->first_line = yylloc.first_line;
1247       yylsp->first_column = yylloc.first_column;
1248       yylsp->last_line = (yylsp-1)->last_line;
1249       yylsp->last_column = (yylsp-1)->last_column;
1250       yylsp->text = 0;
1251     }
1252   else
1253     {
1254       yylsp->last_line = (yylsp+yylen-1)->last_line;
1255       yylsp->last_column = (yylsp+yylen-1)->last_column;
1256     }
1257 #endif
1258
1259   /* Now "shift" the result of the reduction.
1260      Determine what state that goes to,
1261      based on the state we popped back to
1262      and the rule number reduced by.  */
1263
1264   yyn = yyr1[yyn];
1265
1266   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1267   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1268     yystate = yytable[yystate];
1269   else
1270     yystate = yydefgoto[yyn - YYNTBASE];
1271
1272   goto yynewstate;
1273
1274 yyerrlab:   /* here on detecting error */
1275
1276   if (! yyerrstatus)
1277     /* If not already recovering from an error, report this error.  */
1278     {
1279       ++yynerrs;
1280
1281 #ifdef YYERROR_VERBOSE
1282       yyn = yypact[yystate];
1283
1284       if (yyn > YYFLAG && yyn < YYLAST)
1285         {
1286           int size = 0;
1287           char *msg;
1288           int x, count;
1289
1290           count = 0;
1291           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
1292           for (x = (yyn < 0 ? -yyn : 0);
1293                x < (sizeof(yytname) / sizeof(char *)); x++)
1294             if (yycheck[x + yyn] == x)
1295               size += strlen(yytname[x]) + 15, count++;
1296           msg = (char *) malloc(size + 15);
1297           if (msg != 0)
1298             {
1299               strcpy(msg, "parse error");
1300
1301               if (count < 5)
1302                 {
1303                   count = 0;
1304                   for (x = (yyn < 0 ? -yyn : 0);
1305                        x < (sizeof(yytname) / sizeof(char *)); x++)
1306                     if (yycheck[x + yyn] == x)
1307                       {
1308                         strcat(msg, count == 0 ? ", expecting `" : " or `");
1309                         strcat(msg, yytname[x]);
1310                         strcat(msg, "'");
1311                         count++;
1312                       }
1313                 }
1314               yyerror(msg);
1315               free(msg);
1316             }
1317           else
1318             yyerror ("parse error; also virtual memory exceeded");
1319         }
1320       else
1321 #endif /* YYERROR_VERBOSE */
1322         yyerror("parse error");
1323     }
1324
1325   goto yyerrlab1;
1326 yyerrlab1:   /* here on error raised explicitly by an action */
1327
1328   if (yyerrstatus == 3)
1329     {
1330       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
1331
1332       /* return failure if at end of input */
1333       if (yychar == YYEOF)
1334         YYABORT;
1335
1336 #if YYDEBUG != 0
1337       if (yydebug)
1338         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1339 #endif
1340
1341       yychar = YYEMPTY;
1342     }
1343
1344   /* Else will try to reuse lookahead token
1345      after shifting the error token.  */
1346
1347   yyerrstatus = 3;              /* Each real token shifted decrements this */
1348
1349   goto yyerrhandle;
1350
1351 yyerrdefault:  /* current state does not do anything special for the error token. */
1352
1353 #if 0
1354   /* This is wrong; only states that explicitly want error tokens
1355      should shift them.  */
1356   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
1357   if (yyn) goto yydefault;
1358 #endif
1359
1360 yyerrpop:   /* pop the current state because it cannot handle the error token */
1361
1362   if (yyssp == yyss) YYABORT;
1363   yyvsp--;
1364   yystate = *--yyssp;
1365 #ifdef YYLSP_NEEDED
1366   yylsp--;
1367 #endif
1368
1369 #if YYDEBUG != 0
1370   if (yydebug)
1371     {
1372       short *ssp1 = yyss - 1;
1373       fprintf (stderr, "Error: state stack now");
1374       while (ssp1 != yyssp)
1375         fprintf (stderr, " %d", *++ssp1);
1376       fprintf (stderr, "\n");
1377     }
1378 #endif
1379
1380 yyerrhandle:
1381
1382   yyn = yypact[yystate];
1383   if (yyn == YYFLAG)
1384     goto yyerrdefault;
1385
1386   yyn += YYTERROR;
1387   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1388     goto yyerrdefault;
1389
1390   yyn = yytable[yyn];
1391   if (yyn < 0)
1392     {
1393       if (yyn == YYFLAG)
1394         goto yyerrpop;
1395       yyn = -yyn;
1396       goto yyreduce;
1397     }
1398   else if (yyn == 0)
1399     goto yyerrpop;
1400
1401   if (yyn == YYFINAL)
1402     YYACCEPT;
1403
1404 #if YYDEBUG != 0
1405   if (yydebug)
1406     fprintf(stderr, "Shifting error token, ");
1407 #endif
1408
1409   *++yyvsp = yylval;
1410 #ifdef YYLSP_NEEDED
1411   *++yylsp = yylloc;
1412 #endif
1413
1414   yystate = yyn;
1415   goto yynewstate;
1416
1417  yyacceptlab:
1418   /* YYACCEPT comes here.  */
1419   if (yyfree_stacks)
1420     {
1421       free (yyss);
1422       free (yyvs);
1423 #ifdef YYLSP_NEEDED
1424       free (yyls);
1425 #endif
1426     }
1427   return 0;
1428
1429  yyabortlab:
1430   /* YYABORT comes here.  */
1431   if (yyfree_stacks)
1432     {
1433       free (yyss);
1434       free (yyvs);
1435 #ifdef YYLSP_NEEDED
1436       free (yyls);
1437 #endif
1438     }
1439   return 1;
1440 }
1441
1442
1443 # include "bison.reset"
1444
1445 extern char *yytext;
1446
1447 static void mterror (char *s)
1448 {
1449
1450   if (s != NULL)
1451     {
1452       llparseerror
1453         (message ("Parse error in meta-state file: %s", cstring_fromChars (s)));
1454     }
1455   else
1456     {
1457       llparseerror
1458         (message ("Parse error in meta-state file"));
1459     }
1460
1461 }
1462
1463 static void yyprint (FILE *file, int type, YYSTYPE value)
1464 {
1465   cstring tname = mttok_unparse (value.tok);
1466   fprintf (file, " (%s)", cstring_toCharsSafe (tname));
1467   cstring_free (tname);
1468 }
1469
1470
1471
1472
1473 /*
1474 ** Resets all flags in bison.head
1475 */
1476
1477
1478 /*@=allmacros@*/
1479 /*@=boolint@*/
1480 /*@=charint@*/
1481 /*@=macroparams@*/
1482 /*@=macroundef@*/
1483 /*@=unreachable@*/
1484 /*@=macrospec@*/
1485 /*@=varuse@*/
1486 /*@=ignorequals@*/
1487 /*@=macrostmt@*/
1488 /*@=noeffect@*/
1489 /*@=shadow@*/
1490 /*@=exitarg@*/
1491 /*@=macroredef@*/
1492 /*@=uniondef@*/
1493 /*@=compdef@*/
1494 /*@=matchfields@*/
1495 /*@=exportlocal@*/
1496 /*@=evalorderuncon@*/
1497 /*@=exportheader@*/
1498 /*@=typeuse@*/
1499 /*@=redecl@*/
1500 /*@=redef@*/
1501 /*@=noparams@*/
1502 /*@=ansireserved@*/
1503 /*@=fielduse@*/
1504 /*@=ifblock@*/
1505 /*@=elseifcomplete@*/
1506 /*@=whileblock@*/
1507 /*@=forblock@*/
1508 /*@=branchstate@*/
1509 /*@=readonlytrans@*/
1510 /*@=namechecks@*/
1511 /*@=usedef@*/
1512 /*@=systemunrecog@*/
1513 /*@=dependenttrans@*/
1514 /*@=unqualifiedtrans@*/
1515 /*@=declundef@*/
1516
1517
1518 /*drl added 11/27/2001*/
1519 /*@=bounds@*/