src/xbt/automaton/parserPromela.tab.cacc

   1 /* A Bison parser, made by GNU Bison 2.7.12-4996.  */
   2
   3 /* Bison implementation for Yacc-like parsers in C
   4
   5       Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
   6
   7    This program is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation, either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* As a special exception, you may create a larger work that contains
  21    part or all of the Bison parser skeleton and distribute that work
  22    under terms of your choice, so long as that work isn't itself a
  23    parser generator using the skeleton or a modified version thereof
  24    as a parser skeleton.  Alternatively, if you modify or redistribute
  25    the parser skeleton itself, you may (at your option) remove this
  26    special exception, which will cause the skeleton and the resulting
  27    Bison output files to be licensed under the GNU General Public
  28    License without this special exception.
  29
  30    This special exception was added by the Free Software Foundation in
  31    version 2.2 of Bison.  */
  32
  33 /* C LALR(1) parser skeleton written by Richard Stallman, by
  34    simplifying the original so-called "semantic" parser.  */
  35
  36 /* All symbols defined below should begin with yy or YY, to avoid
  37    infringing on user name space.  This should be done even for local
  38    variables, as they might otherwise be expanded by user macros.
  39    There are some unavoidable exceptions within include files to
  40    define necessary library symbols; they are noted "INFRINGES ON
  41    USER NAME SPACE" below.  */
  42
  43 /* Identify Bison output.  */
  44 #define YYBISON 1
  45
  46 /* Bison version.  */
  47 #define YYBISON_VERSION "2.7.12-4996"
  48
  49 /* Skeleton name.  */
  50 #define YYSKELETON_NAME "yacc.c"
  51
  52 /* Pure parsers.  */
  53 #define YYPURE 0
  54
  55 /* Push parsers.  */
  56 #define YYPUSH 0
  57
  58 /* Pull parsers.  */
  59 #define YYPULL 1
  60
  61
  62 /* Substitute the variable and function names.  */
  63 #define yyparse         xbt_automaton_parser_parse
  64 #define yylex           xbt_automaton_parser_lex
  65 #define yyerror         xbt_automaton_parser_error
  66 #define yylval          xbt_automaton_parser_lval
  67 #define yychar          xbt_automaton_parser_char
  68 #define yydebug         xbt_automaton_parser_debug
  69 #define yynerrs         xbt_automaton_parser_nerrs
  70
  71 /* Copy the first part of user declarations.  */
  72 /* Line 371 of yacc.c  */
  73 #line 1 "parserPromela.yacc"
  74
  75
  76 #include "automaton_lexer.yy.c"
  77 #include <xbt/automaton.h>
  78
  79 void yyerror(const char *s);
  80
  81
  82 /* Line 371 of yacc.c  */
  83 #line 84 "parserPromela.tab.cacc"
  84
  85 # ifndef YY_NULL
  86 #  if defined __cplusplus && 201103L <= __cplusplus
  87 #   define YY_NULL nullptr
  88 #  else
  89 #   define YY_NULL 0
  90 #  endif
  91 # endif
  92
  93 /* Enabling verbose error messages.  */
  94 #ifdef YYERROR_VERBOSE
  95 # undef YYERROR_VERBOSE
  96 # define YYERROR_VERBOSE 1
  97 #else
  98 # define YYERROR_VERBOSE 0
  99 #endif
 100
 101 /* In a future release of Bison, this section will be replaced
 102    by #include "parserPromela.tab.hacc".  */
 103 #ifndef YY_XBT_AUTOMATON_PARSER_PARSERPROMELA_TAB_HACC_INCLUDED
 104 # define YY_XBT_AUTOMATON_PARSER_PARSERPROMELA_TAB_HACC_INCLUDED
 105 /* Enabling traces.  */
 106 #ifndef YYDEBUG
 107 # define YYDEBUG 0
 108 #endif
 109 #if YYDEBUG
 110 extern int xbt_automaton_parser_debug;
 111 #endif
 112
 113 /* Tokens.  */
 114 #ifndef YYTOKENTYPE
 115 # define YYTOKENTYPE
 116    /* Put the tokens into the symbol table, so that GDB and other debuggers
 117       know about them.  */
 118    enum yytokentype {
 119      NEVER = 258,
 120      IF = 259,
 121      FI = 260,
 122      IMPLIES = 261,
 123      GOTO = 262,
 124      AND = 263,
 125      OR = 264,
 126      NOT = 265,
 127      LEFT_PAR = 266,
 128      RIGHT_PAR = 267,
 129      CASE = 268,
 130      COLON = 269,
 131      SEMI_COLON = 270,
 132      CASE_TRUE = 271,
 133      LEFT_BRACE = 272,
 134      RIGHT_BRACE = 273,
 135      LITT_ENT = 274,
 136      LITT_CHAINE = 275,
 137      LITT_REEL = 276,
 138      ID = 277
 139    };
 140 #endif
 141
 142
 143 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 144 typedef union YYSTYPE
 145 {
 146 /* Line 387 of yacc.c  */
 147 #line 10 "parserPromela.yacc"
 148
 149   double real;
 150   int integer;
 151   char* string;
 152   xbt_automaton_exp_label_t label;
 153
 154
 155 /* Line 387 of yacc.c  */
 156 #line 157 "parserPromela.tab.cacc"
 157 } YYSTYPE;
 158 # define YYSTYPE_IS_TRIVIAL 1
 159 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 160 # define YYSTYPE_IS_DECLARED 1
 161 #endif
 162
 163 extern YYSTYPE xbt_automaton_parser_lval;
 164
 165 #ifdef YYPARSE_PARAM
 166 #if defined __STDC__ || defined __cplusplus
 167 int xbt_automaton_parser_parse (void *YYPARSE_PARAM);
 168 #else
 169 int xbt_automaton_parser_parse ();
 170 #endif
 171 #else /* ! YYPARSE_PARAM */
 172 #if defined __STDC__ || defined __cplusplus
 173 int xbt_automaton_parser_parse (void);
 174 #else
 175 int xbt_automaton_parser_parse ();
 176 #endif
 177 #endif /* ! YYPARSE_PARAM */
 178
 179 #endif /* !YY_XBT_AUTOMATON_PARSER_PARSERPROMELA_TAB_HACC_INCLUDED  */
 180
 181 /* Copy the second part of user declarations.  */
 182
 183 /* Line 390 of yacc.c  */
 184 #line 185 "parserPromela.tab.cacc"
 185
 186 #ifdef short
 187 # undef short
 188 #endif
 189
 190 #ifdef YYTYPE_UINT8
 191 typedef YYTYPE_UINT8 yytype_uint8;
 192 #else
 193 typedef unsigned char yytype_uint8;
 194 #endif
 195
 196 #ifdef YYTYPE_INT8
 197 typedef YYTYPE_INT8 yytype_int8;
 198 #elif (defined __STDC__ || defined __C99__FUNC__ \
 199      || defined __cplusplus || defined _MSC_VER)
 200 typedef signed char yytype_int8;
 201 #else
 202 typedef short int yytype_int8;
 203 #endif
 204
 205 #ifdef YYTYPE_UINT16
 206 typedef YYTYPE_UINT16 yytype_uint16;
 207 #else
 208 typedef unsigned short int yytype_uint16;
 209 #endif
 210
 211 #ifdef YYTYPE_INT16
 212 typedef YYTYPE_INT16 yytype_int16;
 213 #else
 214 typedef short int yytype_int16;
 215 #endif
 216
 217 #ifndef YYSIZE_T
 218 # ifdef __SIZE_TYPE__
 219 #  define YYSIZE_T __SIZE_TYPE__
 220 # elif defined size_t
 221 #  define YYSIZE_T size_t
 222 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 223      || defined __cplusplus || defined _MSC_VER)
 224 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 225 #  define YYSIZE_T size_t
 226 # else
 227 #  define YYSIZE_T unsigned int
 228 # endif
 229 #endif
 230
 231 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 232
 233 #ifndef YY_
 234 # if defined YYENABLE_NLS && YYENABLE_NLS
 235 #  if ENABLE_NLS
 236 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 237 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
 238 #  endif
 239 # endif
 240 # ifndef YY_
 241 #  define YY_(Msgid) Msgid
 242 # endif
 243 #endif
 244
 245 #ifndef __attribute__
 246 /* This feature is available in gcc versions 2.5 and later.  */
 247 # if (! defined __GNUC__ || __GNUC__ < 2 \
 248       || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
 249 #  define __attribute__(Spec) /* empty */
 250 # endif
 251 #endif
 252
 253 /* Suppress unused-variable warnings by "using" E.  */
 254 #if ! defined lint || defined __GNUC__
 255 # define YYUSE(E) ((void) (E))
 256 #else
 257 # define YYUSE(E) /* empty */
 258 #endif
 259
 260
 261 /* Identity function, used to suppress warnings about constant conditions.  */
 262 #ifndef lint
 263 # define YYID(N) (N)
 264 #else
 265 #if (defined __STDC__ || defined __C99__FUNC__ \
 266      || defined __cplusplus || defined _MSC_VER)
 267 static int
 268 YYID (int yyi)
 269 #else
 270 static int
 271 YYID (yyi)
 272     int yyi;
 273 #endif
 274 {
 275   return yyi;
 276 }
 277 #endif
 278
 279 #if ! defined yyoverflow || YYERROR_VERBOSE
 280
 281 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 282
 283 # ifdef YYSTACK_USE_ALLOCA
 284 #  if YYSTACK_USE_ALLOCA
 285 #   ifdef __GNUC__
 286 #    define YYSTACK_ALLOC __builtin_alloca
 287 #   elif defined __BUILTIN_VA_ARG_INCR
 288 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 289 #   elif defined _AIX
 290 #    define YYSTACK_ALLOC __alloca
 291 #   elif defined _MSC_VER
 292 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 293 #    define alloca _alloca
 294 #   else
 295 #    define YYSTACK_ALLOC alloca
 296 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 297      || defined __cplusplus || defined _MSC_VER)
 298 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 299       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
 300 #     ifndef EXIT_SUCCESS
 301 #      define EXIT_SUCCESS 0
 302 #     endif
 303 #    endif
 304 #   endif
 305 #  endif
 306 # endif
 307
 308 # ifdef YYSTACK_ALLOC
 309    /* Pacify GCC's `empty if-body' warning.  */
 310 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 311 #  ifndef YYSTACK_ALLOC_MAXIMUM
 312     /* The OS might guarantee only one guard page at the bottom of the stack,
 313        and a page size can be as small as 4096 bytes.  So we cannot safely
 314        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 315        to allow for a few compiler-allocated temporary stack slots.  */
 316 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 317 #  endif
 318 # else
 319 #  define YYSTACK_ALLOC YYMALLOC
 320 #  define YYSTACK_FREE YYFREE
 321 #  ifndef YYSTACK_ALLOC_MAXIMUM
 322 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 323 #  endif
 324 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
 325        && ! ((defined YYMALLOC || defined malloc) \
 326              && (defined YYFREE || defined free)))
 327 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 328 #   ifndef EXIT_SUCCESS
 329 #    define EXIT_SUCCESS 0
 330 #   endif
 331 #  endif
 332 #  ifndef YYMALLOC
 333 #   define YYMALLOC malloc
 334 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 335      || defined __cplusplus || defined _MSC_VER)
 336 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 337 #   endif
 338 #  endif
 339 #  ifndef YYFREE
 340 #   define YYFREE free
 341 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
 342      || defined __cplusplus || defined _MSC_VER)
 343 void free (void *); /* INFRINGES ON USER NAME SPACE */
 344 #   endif
 345 #  endif
 346 # endif
 347 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 348
 349
 350 #if (! defined yyoverflow \
 351      && (! defined __cplusplus \
 352          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 353
 354 /* A type that is properly aligned for any stack member.  */
 355 union yyalloc
 356 {
 357   yytype_int16 yyss_alloc;
 358   YYSTYPE yyvs_alloc;
 359 };
 360
 361 /* The size of the maximum gap between one aligned stack and the next.  */
 362 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 363
 364 /* The size of an array large to enough to hold all stacks, each with
 365    N elements.  */
 366 # define YYSTACK_BYTES(N) \
 367      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 368       + YYSTACK_GAP_MAXIMUM)
 369
 370 # define YYCOPY_NEEDED 1
 371
 372 /* Relocate STACK from its old location to the new one.  The
 373    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 374    elements in the stack, and YYPTR gives the new location of the
 375    stack.  Advance YYPTR to a properly aligned location for the next
 376    stack.  */
 377 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
 378     do                                                                  \
 379       {                                                                 \
 380         YYSIZE_T yynewbytes;                                            \
 381         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 382         Stack = &yyptr->Stack_alloc;                                    \
 383         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 384         yyptr += yynewbytes / sizeof (*yyptr);                          \
 385       }                                                                 \
 386     while (YYID (0))
 387
 388 #endif
 389
 390 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
 391 /* Copy COUNT objects from SRC to DST.  The source and destination do
 392    not overlap.  */
 393 # ifndef YYCOPY
 394 #  if defined __GNUC__ && 1 < __GNUC__
 395 #   define YYCOPY(Dst, Src, Count) \
 396       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
 397 #  else
 398 #   define YYCOPY(Dst, Src, Count)              \
 399       do                                        \
 400         {                                       \
 401           YYSIZE_T yyi;                         \
 402           for (yyi = 0; yyi < (Count); yyi++)   \
 403             (Dst)[yyi] = (Src)[yyi];            \
 404         }                                       \
 405       while (YYID (0))
 406 #  endif
 407 # endif
 408 #endif /* !YYCOPY_NEEDED */
 409
 410 /* YYFINAL -- State number of the termination state.  */
 411 #define YYFINAL  4
 412 /* YYLAST -- Last index in YYTABLE.  */
 413 #define YYLAST   28
 414
 415 /* YYNTOKENS -- Number of terminals.  */
 416 #define YYNTOKENS  23
 417 /* YYNNTS -- Number of nonterminals.  */
 418 #define YYNNTS  6
 419 /* YYNRULES -- Number of rules.  */
 420 #define YYNRULES  13
 421 /* YYNRULES -- Number of states.  */
 422 #define YYNSTATES  32
 423
 424 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 425 #define YYUNDEFTOK  2
 426 #define YYMAXUTOK   277
 427
 428 #define YYTRANSLATE(YYX)                                                \
 429   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 430
 431 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 432 static const yytype_uint8 yytranslate[] =
 433 {
 434        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 435        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 436        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 437        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 438        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 439        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 440        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 441        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 442        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 443        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 444        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 445        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 446        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 447        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 448        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 449        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 450        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 451        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 452        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 453        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 454        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 455        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 456        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 457        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 458        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 459        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 460        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 461       15,    16,    17,    18,    19,    20,    21,    22
 462 };
 463
 464 #if YYDEBUG
 465 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 466    YYRHS.  */
 467 static const yytype_uint8 yyprhs[] =
 468 {
 469        0,     0,     3,     8,     9,    10,    19,    20,    27,    31,
 470       35,    39,    42,    44
 471 };
 472
 473 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 474 static const yytype_int8 yyrhs[] =
 475 {
 476       24,     0,    -1,     3,    17,    25,    18,    -1,    -1,    -1,
 477       22,    14,    26,     4,    27,     5,    15,    25,    -1,    -1,
 478       13,    28,     6,     7,    22,    27,    -1,    11,    28,    12,
 479       -1,    28,     9,    28,    -1,    28,     8,    28,    -1,    10,
 480       28,    -1,    16,    -1,    22,    -1
 481 };
 482
 483 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 484 static const yytype_uint8 yyrline[] =
 485 {
 486        0,    47,    47,    50,    51,    51,    54,    55,    58,    59,
 487       60,    61,    62,    63
 488 };
 489 #endif
 490
 491 #if YYDEBUG || YYERROR_VERBOSE || 0
 492 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 493    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 494 static const char *const yytname[] =
 495 {
 496   "$end", "error", "$undefined", "NEVER", "IF", "FI", "IMPLIES", "GOTO",
 497   "AND", "OR", "NOT", "LEFT_PAR", "RIGHT_PAR", "CASE", "COLON",
 498   "SEMI_COLON", "CASE_TRUE", "LEFT_BRACE", "RIGHT_BRACE", "LITT_ENT",
 499   "LITT_CHAINE", "LITT_REEL", "ID", "$accept", "automaton", "stateseq",
 500   "$@1", "option", "exp", YY_NULL
 501 };
 502 #endif
 503
 504 # ifdef YYPRINT
 505 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 506    token YYLEX-NUM.  */
 507 static const yytype_uint16 yytoknum[] =
 508 {
 509        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 510      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
 511      275,   276,   277
 512 };
 513 # endif
 514
 515 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 516 static const yytype_uint8 yyr1[] =
 517 {
 518        0,    23,    24,    25,    26,    25,    27,    27,    28,    28,
 519       28,    28,    28,    28
 520 };
 521
 522 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 523 static const yytype_uint8 yyr2[] =
 524 {
 525        0,     2,     4,     0,     0,     8,     0,     6,     3,     3,
 526        3,     2,     1,     1
 527 };
 528
 529 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
 530    Performed when YYTABLE doesn't specify something else to do.  Zero
 531    means the default is an error.  */
 532 static const yytype_uint8 yydefact[] =
 533 {
 534        0,     0,     0,     3,     1,     0,     0,     4,     2,     0,
 535        6,     0,     0,     0,     0,    12,    13,     0,     0,    11,
 536        0,     0,     0,     0,     3,     8,     0,    10,     9,     5,
 537        6,     7
 538 };
 539
 540 /* YYDEFGOTO[NTERM-NUM].  */
 541 static const yytype_int8 yydefgoto[] =
 542 {
 543       -1,     2,     6,     9,    12,    17
 544 };
 545
 546 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 547    STATE-NUM.  */
 548 #define YYPACT_NINF -16
 549 static const yytype_int8 yypact[] =
 550 {
 551        0,   -15,    10,   -13,   -16,     2,     1,   -16,   -16,    16,
 552        8,   -10,    17,   -10,   -10,   -16,   -16,     9,    11,   -16,
 553       -1,    18,   -10,   -10,   -13,   -16,     5,   -16,   -16,   -16,
 554        8,   -16
 555 };
 556
 557 /* YYPGOTO[NTERM-NUM].  */
 558 static const yytype_int8 yypgoto[] =
 559 {
 560      -16,   -16,     4,   -16,    -7,    -9
 561 };
 562
 563 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 564    positive, shift that token.  If negative, reduce the rule which
 565    number is the opposite.  If YYTABLE_NINF, syntax error.  */
 566 #define YYTABLE_NINF -1
 567 static const yytype_uint8 yytable[] =
 568 {
 569       13,    14,     3,     1,    19,    20,    15,    22,    23,     5,
 570        4,    25,    16,    27,    28,    21,     7,    22,    23,     8,
 571       10,    11,    18,    31,     0,    26,    24,    30,    29
 572 };
 573
 574 #define yypact_value_is_default(Yystate) \
 575   (!!((Yystate) == (-16)))
 576
 577 #define yytable_value_is_error(Yytable_value) \
 578   YYID (0)
 579
 580 static const yytype_int8 yycheck[] =
 581 {
 582       10,    11,    17,     3,    13,    14,    16,     8,     9,    22,
 583        0,    12,    22,    22,    23,     6,    14,     8,     9,    18,
 584        4,    13,     5,    30,    -1,     7,    15,    22,    24
 585 };
 586
 587 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 588    symbol of state STATE-NUM.  */
 589 static const yytype_uint8 yystos[] =
 590 {
 591        0,     3,    24,    17,     0,    22,    25,    14,    18,    26,
 592        4,    13,    27,    10,    11,    16,    22,    28,     5,    28,
 593       28,     6,     8,     9,    15,    12,     7,    28,    28,    25,
 594       22,    27
 595 };
 596
 597 #define yyerrok         (yyerrstatus = 0)
 598 #define yyclearin       (yychar = YYEMPTY)
 599 #define YYEMPTY         (-2)
 600 #define YYEOF           0
 601
 602 #define YYACCEPT        goto yyacceptlab
 603 #define YYABORT         goto yyabortlab
 604 #define YYERROR         goto yyerrorlab
 605
 606
 607 /* Like YYERROR except do call yyerror.  This remains here temporarily
 608    to ease the transition to the new meaning of YYERROR, for GCC.
 609    Once GCC version 2 has supplanted version 1, this can go.  However,
 610    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
 611    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
 612    discussed.  */
 613
 614 #define YYFAIL          goto yyerrlab
 615 #if defined YYFAIL
 616   /* This is here to suppress warnings from the GCC cpp's
 617      -Wunused-macros.  Normally we don't worry about that warning, but
 618      some users do, and we want to make it easy for users to remove
 619      YYFAIL uses, which will produce warnings from Bison 2.5.  */
 620 #endif
 621
 622 #define YYRECOVERING()  (!!yyerrstatus)
 623
 624 #define YYBACKUP(Token, Value)                                  \
 625 do                                                              \
 626   if (yychar == YYEMPTY)                                        \
 627     {                                                           \
 628       yychar = (Token);                                         \
 629       yylval = (Value);                                         \
 630       YYPOPSTACK (yylen);                                       \
 631       yystate = *yyssp;                                         \
 632       goto yybackup;                                            \
 633     }                                                           \
 634   else                                                          \
 635     {                                                           \
 636       yyerror (YY_("syntax error: cannot back up")); \
 637       YYERROR;                                                  \
 638     }                                                           \
 639 while (YYID (0))
 640
 641 /* Error token number */
 642 #define YYTERROR        1
 643 #define YYERRCODE       256
 644
 645
 646 /* This macro is provided for backward compatibility. */
 647 #ifndef YY_LOCATION_PRINT
 648 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 649 #endif
 650
 651
 652 /* YYLEX -- calling `yylex' with the right arguments.  */
 653 #ifdef YYLEX_PARAM
 654 # define YYLEX yylex (YYLEX_PARAM)
 655 #else
 656 # define YYLEX yylex ()
 657 #endif
 658
 659 /* Enable debugging if requested.  */
 660 #if YYDEBUG
 661
 662 # ifndef YYFPRINTF
 663 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 664 #  define YYFPRINTF fprintf
 665 # endif
 666
 667 # define YYDPRINTF(Args)                        \
 668 do {                                            \
 669   if (yydebug)                                  \
 670     YYFPRINTF Args;                             \
 671 } while (YYID (0))
 672
 673 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
 674 do {                                                                      \
 675   if (yydebug)                                                            \
 676     {                                                                     \
 677       YYFPRINTF (stderr, "%s ", Title);                                   \
 678       yy_symbol_print (stderr,                                            \
 679                   Type, Value); \
 680       YYFPRINTF (stderr, "\n");                                           \
 681     }                                                                     \
 682 } while (YYID (0))
 683
 684
 685 /*--------------------------------.
 686 | Print this symbol on YYOUTPUT.  |
 687 `--------------------------------*/
 688
 689 /*ARGSUSED*/
 690 #if (defined __STDC__ || defined __C99__FUNC__ \
 691      || defined __cplusplus || defined _MSC_VER)
 692 static void
 693 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 694 #else
 695 static void
 696 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
 697     FILE *yyoutput;
 698     int yytype;
 699     YYSTYPE const * const yyvaluep;
 700 #endif
 701 {
 702   FILE *yyo = yyoutput;
 703   YYUSE (yyo);
 704   if (!yyvaluep)
 705     return;
 706 # ifdef YYPRINT
 707   if (yytype < YYNTOKENS)
 708     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 709 # else
 710   YYUSE (yyoutput);
 711 # endif
 712   YYUSE (yytype);
 713 }
 714
 715
 716 /*--------------------------------.
 717 | Print this symbol on YYOUTPUT.  |
 718 `--------------------------------*/
 719
 720 #if (defined __STDC__ || defined __C99__FUNC__ \
 721      || defined __cplusplus || defined _MSC_VER)
 722 static void
 723 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 724 #else
 725 static void
 726 yy_symbol_print (yyoutput, yytype, yyvaluep)
 727     FILE *yyoutput;
 728     int yytype;
 729     YYSTYPE const * const yyvaluep;
 730 #endif
 731 {
 732   if (yytype < YYNTOKENS)
 733     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 734   else
 735     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 736
 737   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
 738   YYFPRINTF (yyoutput, ")");
 739 }
 740
 741 /*------------------------------------------------------------------.
 742 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 743 | TOP (included).                                                   |
 744 `------------------------------------------------------------------*/
 745
 746 #if (defined __STDC__ || defined __C99__FUNC__ \
 747      || defined __cplusplus || defined _MSC_VER)
 748 static void
 749 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
 750 #else
 751 static void
 752 yy_stack_print (yybottom, yytop)
 753     yytype_int16 *yybottom;
 754     yytype_int16 *yytop;
 755 #endif
 756 {
 757   YYFPRINTF (stderr, "Stack now");
 758   for (; yybottom <= yytop; yybottom++)
 759     {
 760       int yybot = *yybottom;
 761       YYFPRINTF (stderr, " %d", yybot);
 762     }
 763   YYFPRINTF (stderr, "\n");
 764 }
 765
 766 # define YY_STACK_PRINT(Bottom, Top)                            \
 767 do {                                                            \
 768   if (yydebug)                                                  \
 769     yy_stack_print ((Bottom), (Top));                           \
 770 } while (YYID (0))
 771
 772
 773 /*------------------------------------------------.
 774 | Report that the YYRULE is going to be reduced.  |
 775 `------------------------------------------------*/
 776
 777 #if (defined __STDC__ || defined __C99__FUNC__ \
 778      || defined __cplusplus || defined _MSC_VER)
 779 static void
 780 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
 781 #else
 782 static void
 783 yy_reduce_print (yyvsp, yyrule)
 784     YYSTYPE *yyvsp;
 785     int yyrule;
 786 #endif
 787 {
 788   int yynrhs = yyr2[yyrule];
 789   int yyi;
 790   unsigned long int yylno = yyrline[yyrule];
 791   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
 792              yyrule - 1, yylno);
 793   /* The symbols being reduced.  */
 794   for (yyi = 0; yyi < yynrhs; yyi++)
 795     {
 796       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
 797       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 798                        &(yyvsp[(yyi + 1) - (yynrhs)])
 799                                        );
 800       YYFPRINTF (stderr, "\n");
 801     }
 802 }
 803
 804 # define YY_REDUCE_PRINT(Rule)          \
 805 do {                                    \
 806   if (yydebug)                          \
 807     yy_reduce_print (yyvsp, Rule); \
 808 } while (YYID (0))
 809
 810 /* Nonzero means print parse trace.  It is left uninitialized so that
 811    multiple parsers can coexist.  */
 812 int yydebug;
 813 #else /* !YYDEBUG */
 814 # define YYDPRINTF(Args)
 815 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 816 # define YY_STACK_PRINT(Bottom, Top)
 817 # define YY_REDUCE_PRINT(Rule)
 818 #endif /* !YYDEBUG */
 819
 820
 821 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 822 #ifndef YYINITDEPTH
 823 # define YYINITDEPTH 200
 824 #endif
 825
 826 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 827    if the built-in stack extension method is used).
 828
 829    Do not make this value too large; the results are undefined if
 830    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
 831    evaluated with infinite-precision integer arithmetic.  */
 832
 833 #ifndef YYMAXDEPTH
 834 # define YYMAXDEPTH 10000
 835 #endif
 836
 837
 838 #if YYERROR_VERBOSE
 839
 840 # ifndef yystrlen
 841 #  if defined __GLIBC__ && defined _STRING_H
 842 #   define yystrlen strlen
 843 #  else
 844 /* Return the length of YYSTR.  */
 845 #if (defined __STDC__ || defined __C99__FUNC__ \
 846      || defined __cplusplus || defined _MSC_VER)
 847 static YYSIZE_T
 848 yystrlen (const char *yystr)
 849 #else
 850 static YYSIZE_T
 851 yystrlen (yystr)
 852     const char *yystr;
 853 #endif
 854 {
 855   YYSIZE_T yylen;
 856   for (yylen = 0; yystr[yylen]; yylen++)
 857     continue;
 858   return yylen;
 859 }
 860 #  endif
 861 # endif
 862
 863 # ifndef yystpcpy
 864 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
 865 #   define yystpcpy stpcpy
 866 #  else
 867 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 868    YYDEST.  */
 869 #if (defined __STDC__ || defined __C99__FUNC__ \
 870      || defined __cplusplus || defined _MSC_VER)
 871 static char *
 872 yystpcpy (char *yydest, const char *yysrc)
 873 #else
 874 static char *
 875 yystpcpy (yydest, yysrc)
 876     char *yydest;
 877     const char *yysrc;
 878 #endif
 879 {
 880   char *yyd = yydest;
 881   const char *yys = yysrc;
 882
 883   while ((*yyd++ = *yys++) != '\0')
 884     continue;
 885
 886   return yyd - 1;
 887 }
 888 #  endif
 889 # endif
 890
 891 # ifndef yytnamerr
 892 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
 893    quotes and backslashes, so that it's suitable for yyerror.  The
 894    heuristic is that double-quoting is unnecessary unless the string
 895    contains an apostrophe, a comma, or backslash (other than
 896    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
 897    null, do not copy; instead, return the length of what the result
 898    would have been.  */
 899 static YYSIZE_T
 900 yytnamerr (char *yyres, const char *yystr)
 901 {
 902   if (*yystr == '"')
 903     {
 904       YYSIZE_T yyn = 0;
 905       char const *yyp = yystr;
 906
 907       for (;;)
 908         switch (*++yyp)
 909           {
 910           case '\'':
 911           case ',':
 912             goto do_not_strip_quotes;
 913
 914           case '\\':
 915             if (*++yyp != '\\')
 916               goto do_not_strip_quotes;
 917             /* Fall through.  */
 918           default:
 919             if (yyres)
 920               yyres[yyn] = *yyp;
 921             yyn++;
 922             break;
 923
 924           case '"':
 925             if (yyres)
 926               yyres[yyn] = '\0';
 927             return yyn;
 928           }
 929     do_not_strip_quotes: ;
 930     }
 931
 932   if (! yyres)
 933     return yystrlen (yystr);
 934
 935   return yystpcpy (yyres, yystr) - yyres;
 936 }
 937 # endif
 938
 939 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
 940    about the unexpected token YYTOKEN for the state stack whose top is
 941    YYSSP.
 942
 943    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
 944    not large enough to hold the message.  In that case, also set
 945    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
 946    required number of bytes is too large to store.  */
 947 static int
 948 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
 949                 yytype_int16 *yyssp, int yytoken)
 950 {
 951   YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
 952   YYSIZE_T yysize = yysize0;
 953   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
 954   /* Internationalized format string. */
 955   const char *yyformat = YY_NULL;
 956   /* Arguments of yyformat. */
 957   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
 958   /* Number of reported tokens (one for the "unexpected", one per
 959      "expected"). */
 960   int yycount = 0;
 961
 962   /* There are many possibilities here to consider:
 963      - Assume YYFAIL is not used.  It's too flawed to consider.  See
 964        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
 965        for details.  YYERROR is fine as it does not invoke this
 966        function.
 967      - If this state is a consistent state with a default action, then
 968        the only way this function was invoked is if the default action
 969        is an error action.  In that case, don't check for expected
 970        tokens because there are none.
 971      - The only way there can be no lookahead present (in yychar) is if
 972        this state is a consistent state with a default action.  Thus,
 973        detecting the absence of a lookahead is sufficient to determine
 974        that there is no unexpected or expected token to report.  In that
 975        case, just report a simple "syntax error".
 976      - Don't assume there isn't a lookahead just because this state is a
 977        consistent state with a default action.  There might have been a
 978        previous inconsistent state, consistent state with a non-default
 979        action, or user semantic action that manipulated yychar.
 980      - Of course, the expected token list depends on states to have
 981        correct lookahead information, and it depends on the parser not
 982        to perform extra reductions after fetching a lookahead from the
 983        scanner and before detecting a syntax error.  Thus, state merging
 984        (from LALR or IELR) and default reductions corrupt the expected
 985        token list.  However, the list is correct for canonical LR with
 986        one exception: it will still contain any token that will not be
 987        accepted due to an error action in a later state.
 988   */
 989   if (yytoken != YYEMPTY)
 990     {
 991       int yyn = yypact[*yyssp];
 992       yyarg[yycount++] = yytname[yytoken];
 993       if (!yypact_value_is_default (yyn))
 994         {
 995           /* Start YYX at -YYN if negative to avoid negative indexes in
 996              YYCHECK.  In other words, skip the first -YYN actions for
 997              this state because they are default actions.  */
 998           int yyxbegin = yyn < 0 ? -yyn : 0;
 999           /* Stay within bounds of both yycheck and yytname.  */
1000           int yychecklim = YYLAST - yyn + 1;
1001           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1002           int yyx;
1003
1004           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1005             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1006                 && !yytable_value_is_error (yytable[yyx + yyn]))
1007               {
1008                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1009                   {
1010                     yycount = 1;
1011                     yysize = yysize0;
1012                     break;
1013                   }
1014                 yyarg[yycount++] = yytname[yyx];
1015                 {
1016                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
1017                   if (! (yysize <= yysize1
1018                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1019                     return 2;
1020                   yysize = yysize1;
1021                 }
1022               }
1023         }
1024     }
1025
1026   switch (yycount)
1027     {
1028 # define YYCASE_(N, S)                      \
1029       case N:                               \
1030         yyformat = S;                       \
1031       break
1032       YYCASE_(0, YY_("syntax error"));
1033       YYCASE_(1, YY_("syntax error, unexpected %s"));
1034       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1035       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1036       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1037       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1038 # undef YYCASE_
1039     }
1040
1041   {
1042     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1043     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1044       return 2;
1045     yysize = yysize1;
1046   }
1047
1048   if (*yymsg_alloc < yysize)
1049     {
1050       *yymsg_alloc = 2 * yysize;
1051       if (! (yysize <= *yymsg_alloc
1052              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1053         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1054       return 1;
1055     }
1056
1057   /* Avoid sprintf, as that infringes on the user's name space.
1058      Don't have undefined behavior even if the translation
1059      produced a string with the wrong number of "%s"s.  */
1060   {
1061     char *yyp = *yymsg;
1062     int yyi = 0;
1063     while ((*yyp = *yyformat) != '\0')
1064       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1065         {
1066           yyp += yytnamerr (yyp, yyarg[yyi++]);
1067           yyformat += 2;
1068         }
1069       else
1070         {
1071           yyp++;
1072           yyformat++;
1073         }
1074   }
1075   return 0;
1076 }
1077 #endif /* YYERROR_VERBOSE */
1078
1079 /*-----------------------------------------------.
1080 | Release the memory associated to this symbol.  |
1081 `-----------------------------------------------*/
1082
1083 /*ARGSUSED*/
1084 #if (defined __STDC__ || defined __C99__FUNC__ \
1085      || defined __cplusplus || defined _MSC_VER)
1086 static void
1087 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1088 #else
1089 static void
1090 yydestruct (yymsg, yytype, yyvaluep)
1091     const char *yymsg;
1092     int yytype;
1093     YYSTYPE *yyvaluep;
1094 #endif
1095 {
1096   YYUSE (yyvaluep);
1097
1098   if (!yymsg)
1099     yymsg = "Deleting";
1100   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1101
1102   YYUSE (yytype);
1103 }
1104
1105
1106
1107
1108 /* The lookahead symbol.  */
1109 int yychar;
1110
1111
1112 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1113 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1114 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
1115 #endif
1116 #ifndef YY_INITIAL_VALUE
1117 # define YY_INITIAL_VALUE(Value) /* Nothing. */
1118 #endif
1119
1120 /* The semantic value of the lookahead symbol.  */
1121 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
1122
1123 /* Number of syntax errors so far.  */
1124 int yynerrs;
1125
1126
1127 /*----------.
1128 | yyparse.  |
1129 `----------*/
1130
1131 #ifdef YYPARSE_PARAM
1132 #if (defined __STDC__ || defined __C99__FUNC__ \
1133      || defined __cplusplus || defined _MSC_VER)
1134 int
1135 yyparse (void *YYPARSE_PARAM)
1136 #else
1137 int
1138 yyparse (YYPARSE_PARAM)
1139     void *YYPARSE_PARAM;
1140 #endif
1141 #else /* ! YYPARSE_PARAM */
1142 #if (defined __STDC__ || defined __C99__FUNC__ \
1143      || defined __cplusplus || defined _MSC_VER)
1144 int
1145 yyparse (void)
1146 #else
1147 int
1148 yyparse ()
1149
1150 #endif
1151 #endif
1152 {
1153     int yystate;
1154     /* Number of tokens to shift before error messages enabled.  */
1155     int yyerrstatus;
1156
1157     /* The stacks and their tools:
1158        `yyss': related to states.
1159        `yyvs': related to semantic values.
1160
1161        Refer to the stacks through separate pointers, to allow yyoverflow
1162        to reallocate them elsewhere.  */
1163
1164     /* The state stack.  */
1165     yytype_int16 yyssa[YYINITDEPTH];
1166     yytype_int16 *yyss;
1167     yytype_int16 *yyssp;
1168
1169     /* The semantic value stack.  */
1170     YYSTYPE yyvsa[YYINITDEPTH];
1171     YYSTYPE *yyvs;
1172     YYSTYPE *yyvsp;
1173
1174     YYSIZE_T yystacksize;
1175
1176   int yyn;
1177   int yyresult;
1178   /* Lookahead token as an internal (translated) token number.  */
1179   int yytoken = 0;
1180   /* The variables used to return semantic value and location from the
1181      action routines.  */
1182   YYSTYPE yyval;
1183
1184 #if YYERROR_VERBOSE
1185   /* Buffer for error messages, and its allocated size.  */
1186   char yymsgbuf[128];
1187   char *yymsg = yymsgbuf;
1188   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1189 #endif
1190
1191 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1192
1193   /* The number of symbols on the RHS of the reduced rule.
1194      Keep to zero when no symbol should be popped.  */
1195   int yylen = 0;
1196
1197   yyssp = yyss = yyssa;
1198   yyvsp = yyvs = yyvsa;
1199   yystacksize = YYINITDEPTH;
1200
1201   YYDPRINTF ((stderr, "Starting parse\n"));
1202
1203   yystate = 0;
1204   yyerrstatus = 0;
1205   yynerrs = 0;
1206   yychar = YYEMPTY; /* Cause a token to be read.  */
1207   goto yysetstate;
1208
1209 /*------------------------------------------------------------.
1210 | yynewstate -- Push a new state, which is found in yystate.  |
1211 `------------------------------------------------------------*/
1212  yynewstate:
1213   /* In all cases, when you get here, the value and location stacks
1214      have just been pushed.  So pushing a state here evens the stacks.  */
1215   yyssp++;
1216
1217  yysetstate:
1218   *yyssp = yystate;
1219
1220   if (yyss + yystacksize - 1 <= yyssp)
1221     {
1222       /* Get the current used size of the three stacks, in elements.  */
1223       YYSIZE_T yysize = yyssp - yyss + 1;
1224
1225 #ifdef yyoverflow
1226       {
1227         /* Give user a chance to reallocate the stack.  Use copies of
1228            these so that the &'s don't force the real ones into
1229            memory.  */
1230         YYSTYPE *yyvs1 = yyvs;
1231         yytype_int16 *yyss1 = yyss;
1232
1233         /* Each stack pointer address is followed by the size of the
1234            data in use in that stack, in bytes.  This used to be a
1235            conditional around just the two extra args, but that might
1236            be undefined if yyoverflow is a macro.  */
1237         yyoverflow (YY_("memory exhausted"),
1238                     &yyss1, yysize * sizeof (*yyssp),
1239                     &yyvs1, yysize * sizeof (*yyvsp),
1240                     &yystacksize);
1241
1242         yyss = yyss1;
1243         yyvs = yyvs1;
1244       }
1245 #else /* no yyoverflow */
1246 # ifndef YYSTACK_RELOCATE
1247       goto yyexhaustedlab;
1248 # else
1249       /* Extend the stack our own way.  */
1250       if (YYMAXDEPTH <= yystacksize)
1251         goto yyexhaustedlab;
1252       yystacksize *= 2;
1253       if (YYMAXDEPTH < yystacksize)
1254         yystacksize = YYMAXDEPTH;
1255
1256       {
1257         yytype_int16 *yyss1 = yyss;
1258         union yyalloc *yyptr =
1259           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1260         if (! yyptr)
1261           goto yyexhaustedlab;
1262         YYSTACK_RELOCATE (yyss_alloc, yyss);
1263         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1264 #  undef YYSTACK_RELOCATE
1265         if (yyss1 != yyssa)
1266           YYSTACK_FREE (yyss1);
1267       }
1268 # endif
1269 #endif /* no yyoverflow */
1270
1271       yyssp = yyss + yysize - 1;
1272       yyvsp = yyvs + yysize - 1;
1273
1274       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1275                   (unsigned long int) yystacksize));
1276
1277       if (yyss + yystacksize - 1 <= yyssp)
1278         YYABORT;
1279     }
1280
1281   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1282
1283   if (yystate == YYFINAL)
1284     YYACCEPT;
1285
1286   goto yybackup;
1287
1288 /*-----------.
1289 | yybackup.  |
1290 `-----------*/
1291 yybackup:
1292
1293   /* Do appropriate processing given the current state.  Read a
1294      lookahead token if we need one and don't already have one.  */
1295
1296   /* First try to decide what to do without reference to lookahead token.  */
1297   yyn = yypact[yystate];
1298   if (yypact_value_is_default (yyn))
1299     goto yydefault;
1300
1301   /* Not known => get a lookahead token if don't already have one.  */
1302
1303   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1304   if (yychar == YYEMPTY)
1305     {
1306       YYDPRINTF ((stderr, "Reading a token: "));
1307       yychar = YYLEX;
1308     }
1309
1310   if (yychar <= YYEOF)
1311     {
1312       yychar = yytoken = YYEOF;
1313       YYDPRINTF ((stderr, "Now at end of input.\n"));
1314     }
1315   else
1316     {
1317       yytoken = YYTRANSLATE (yychar);
1318       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1319     }
1320
1321   /* If the proper action on seeing token YYTOKEN is to reduce or to
1322      detect an error, take that action.  */
1323   yyn += yytoken;
1324   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1325     goto yydefault;
1326   yyn = yytable[yyn];
1327   if (yyn <= 0)
1328     {
1329       if (yytable_value_is_error (yyn))
1330         goto yyerrlab;
1331       yyn = -yyn;
1332       goto yyreduce;
1333     }
1334
1335   /* Count tokens shifted since error; after three, turn off error
1336      status.  */
1337   if (yyerrstatus)
1338     yyerrstatus--;
1339
1340   /* Shift the lookahead token.  */
1341   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1342
1343   /* Discard the shifted token.  */
1344   yychar = YYEMPTY;
1345
1346   yystate = yyn;
1347   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1348   *++yyvsp = yylval;
1349   YY_IGNORE_MAYBE_UNINITIALIZED_END
1350
1351   goto yynewstate;
1352
1353
1354 /*-----------------------------------------------------------.
1355 | yydefault -- do the default action for the current state.  |
1356 `-----------------------------------------------------------*/
1357 yydefault:
1358   yyn = yydefact[yystate];
1359   if (yyn == 0)
1360     goto yyerrlab;
1361   goto yyreduce;
1362
1363
1364 /*-----------------------------.
1365 | yyreduce -- Do a reduction.  |
1366 `-----------------------------*/
1367 yyreduce:
1368   /* yyn is the number of a rule to reduce with.  */
1369   yylen = yyr2[yyn];
1370
1371   /* If YYLEN is nonzero, implement the default value of the action:
1372      `$$ = $1'.
1373
1374      Otherwise, the following line sets YYVAL to garbage.
1375      This behavior is undocumented and Bison
1376      users should not rely upon it.  Assigning to YYVAL
1377      unconditionally makes the parser a bit smaller, and it avoids a
1378      GCC warning that YYVAL may be used uninitialized.  */
1379   yyval = yyvsp[1-yylen];
1380
1381
1382   YY_REDUCE_PRINT (yyn);
1383   switch (yyn)
1384     {
1385         case 4:
1386 /* Line 1787 of yacc.c  */
1387 #line 51 "parserPromela.yacc"
1388     { new_state((yyvsp[(1) - (2)].string), 1);}
1389     break;
1390
1391   case 7:
1392 /* Line 1787 of yacc.c  */
1393 #line 55 "parserPromela.yacc"
1394     { new_transition((yyvsp[(5) - (6)].string), (yyvsp[(2) - (6)].label));}
1395     break;
1396
1397   case 8:
1398 /* Line 1787 of yacc.c  */
1399 #line 58 "parserPromela.yacc"
1400     { (yyval.label) = (yyvsp[(2) - (3)].label); }
1401     break;
1402
1403   case 9:
1404 /* Line 1787 of yacc.c  */
1405 #line 59 "parserPromela.yacc"
1406     { (yyval.label) = new_label(0, (yyvsp[(1) - (3)].label), (yyvsp[(3) - (3)].label)); }
1407     break;
1408
1409   case 10:
1410 /* Line 1787 of yacc.c  */
1411 #line 60 "parserPromela.yacc"
1412     { (yyval.label) = new_label(1, (yyvsp[(1) - (3)].label), (yyvsp[(3) - (3)].label)); }
1413     break;
1414
1415   case 11:
1416 /* Line 1787 of yacc.c  */
1417 #line 61 "parserPromela.yacc"
1418     { (yyval.label) = new_label(2, (yyvsp[(2) - (2)].label)); }
1419     break;
1420
1421   case 12:
1422 /* Line 1787 of yacc.c  */
1423 #line 62 "parserPromela.yacc"
1424     { (yyval.label) = new_label(4); }
1425     break;
1426
1427   case 13:
1428 /* Line 1787 of yacc.c  */
1429 #line 63 "parserPromela.yacc"
1430     { (yyval.label) = new_label(3, (yyvsp[(1) - (1)].string)); }
1431     break;
1432
1433
1434 /* Line 1787 of yacc.c  */
1435 #line 1436 "parserPromela.tab.cacc"
1436       default: break;
1437     }
1438   /* User semantic actions sometimes alter yychar, and that requires
1439      that yytoken be updated with the new translation.  We take the
1440      approach of translating immediately before every use of yytoken.
1441      One alternative is translating here after every semantic action,
1442      but that translation would be missed if the semantic action invokes
1443      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1444      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
1445      incorrect destructor might then be invoked immediately.  In the
1446      case of YYERROR or YYBACKUP, subsequent parser actions might lead
1447      to an incorrect destructor call or verbose syntax error message
1448      before the lookahead is translated.  */
1449   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1450
1451   YYPOPSTACK (yylen);
1452   yylen = 0;
1453   YY_STACK_PRINT (yyss, yyssp);
1454
1455   *++yyvsp = yyval;
1456
1457   /* Now `shift' the result of the reduction.  Determine what state
1458      that goes to, based on the state we popped back to and the rule
1459      number reduced by.  */
1460
1461   yyn = yyr1[yyn];
1462
1463   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1464   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1465     yystate = yytable[yystate];
1466   else
1467     yystate = yydefgoto[yyn - YYNTOKENS];
1468
1469   goto yynewstate;
1470
1471
1472 /*------------------------------------.
1473 | yyerrlab -- here on detecting error |
1474 `------------------------------------*/
1475 yyerrlab:
1476   /* Make sure we have latest lookahead translation.  See comments at
1477      user semantic actions for why this is necessary.  */
1478   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1479
1480   /* If not already recovering from an error, report this error.  */
1481   if (!yyerrstatus)
1482     {
1483       ++yynerrs;
1484 #if ! YYERROR_VERBOSE
1485       yyerror (YY_("syntax error"));
1486 #else
1487 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1488                                         yyssp, yytoken)
1489       {
1490         char const *yymsgp = YY_("syntax error");
1491         int yysyntax_error_status;
1492         yysyntax_error_status = YYSYNTAX_ERROR;
1493         if (yysyntax_error_status == 0)
1494           yymsgp = yymsg;
1495         else if (yysyntax_error_status == 1)
1496           {
1497             if (yymsg != yymsgbuf)
1498               YYSTACK_FREE (yymsg);
1499             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1500             if (!yymsg)
1501               {
1502                 yymsg = yymsgbuf;
1503                 yymsg_alloc = sizeof yymsgbuf;
1504                 yysyntax_error_status = 2;
1505               }
1506             else
1507               {
1508                 yysyntax_error_status = YYSYNTAX_ERROR;
1509                 yymsgp = yymsg;
1510               }
1511           }
1512         yyerror (yymsgp);
1513         if (yysyntax_error_status == 2)
1514           goto yyexhaustedlab;
1515       }
1516 # undef YYSYNTAX_ERROR
1517 #endif
1518     }
1519
1520
1521
1522   if (yyerrstatus == 3)
1523     {
1524       /* If just tried and failed to reuse lookahead token after an
1525          error, discard it.  */
1526
1527       if (yychar <= YYEOF)
1528         {
1529           /* Return failure if at end of input.  */
1530           if (yychar == YYEOF)
1531             YYABORT;
1532         }
1533       else
1534         {
1535           yydestruct ("Error: discarding",
1536                       yytoken, &yylval);
1537           yychar = YYEMPTY;
1538         }
1539     }
1540
1541   /* Else will try to reuse lookahead token after shifting the error
1542      token.  */
1543   goto yyerrlab1;
1544
1545
1546 /*---------------------------------------------------.
1547 | yyerrorlab -- error raised explicitly by YYERROR.  |
1548 `---------------------------------------------------*/
1549 yyerrorlab:
1550
1551   /* Pacify compilers like GCC when the user code never invokes
1552      YYERROR and the label yyerrorlab therefore never appears in user
1553      code.  */
1554   if (/*CONSTCOND*/ 0)
1555      goto yyerrorlab;
1556
1557   /* Do not reclaim the symbols of the rule which action triggered
1558      this YYERROR.  */
1559   YYPOPSTACK (yylen);
1560   yylen = 0;
1561   YY_STACK_PRINT (yyss, yyssp);
1562   yystate = *yyssp;
1563   goto yyerrlab1;
1564
1565
1566 /*-------------------------------------------------------------.
1567 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1568 `-------------------------------------------------------------*/
1569 yyerrlab1:
1570   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1571
1572   for (;;)
1573     {
1574       yyn = yypact[yystate];
1575       if (!yypact_value_is_default (yyn))
1576         {
1577           yyn += YYTERROR;
1578           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1579             {
1580               yyn = yytable[yyn];
1581               if (0 < yyn)
1582                 break;
1583             }
1584         }
1585
1586       /* Pop the current state because it cannot handle the error token.  */
1587       if (yyssp == yyss)
1588         YYABORT;
1589
1590
1591       yydestruct ("Error: popping",
1592                   yystos[yystate], yyvsp);
1593       YYPOPSTACK (1);
1594       yystate = *yyssp;
1595       YY_STACK_PRINT (yyss, yyssp);
1596     }
1597
1598   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1599   *++yyvsp = yylval;
1600   YY_IGNORE_MAYBE_UNINITIALIZED_END
1601
1602
1603   /* Shift the error token.  */
1604   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1605
1606   yystate = yyn;
1607   goto yynewstate;
1608
1609
1610 /*-------------------------------------.
1611 | yyacceptlab -- YYACCEPT comes here.  |
1612 `-------------------------------------*/
1613 yyacceptlab:
1614   yyresult = 0;
1615   goto yyreturn;
1616
1617 /*-----------------------------------.
1618 | yyabortlab -- YYABORT comes here.  |
1619 `-----------------------------------*/
1620 yyabortlab:
1621   yyresult = 1;
1622   goto yyreturn;
1623
1624 #if !defined yyoverflow || YYERROR_VERBOSE
1625 /*-------------------------------------------------.
1626 | yyexhaustedlab -- memory exhaustion comes here.  |
1627 `-------------------------------------------------*/
1628 yyexhaustedlab:
1629   yyerror (YY_("memory exhausted"));
1630   yyresult = 2;
1631   /* Fall through.  */
1632 #endif
1633
1634 yyreturn:
1635   if (yychar != YYEMPTY)
1636     {
1637       /* Make sure we have latest lookahead translation.  See comments at
1638          user semantic actions for why this is necessary.  */
1639       yytoken = YYTRANSLATE (yychar);
1640       yydestruct ("Cleanup: discarding lookahead",
1641                   yytoken, &yylval);
1642     }
1643   /* Do not reclaim the symbols of the rule which action triggered
1644      this YYABORT or YYACCEPT.  */
1645   YYPOPSTACK (yylen);
1646   YY_STACK_PRINT (yyss, yyssp);
1647   while (yyssp != yyss)
1648     {
1649       yydestruct ("Cleanup: popping",
1650                   yystos[*yyssp], yyvsp);
1651       YYPOPSTACK (1);
1652     }
1653 #ifndef yyoverflow
1654   if (yyss != yyssa)
1655     YYSTACK_FREE (yyss);
1656 #endif
1657 #if YYERROR_VERBOSE
1658   if (yymsg != yymsgbuf)
1659     YYSTACK_FREE (yymsg);
1660 #endif
1661   /* Make sure YYID is used.  */
1662   return YYID (yyresult);
1663 }
1664
1665
1666 /* Line 2050 of yacc.c  */
1667 #line 66 "parserPromela.yacc"
1668
1669
1670
1671
1672 void yyerror(const char *s){
1673   fprintf (stderr, "%s\n", s);
1674 }
1675
1676
1677