src/ftacmp/nic.tab.cc

   1 /* A Bison parser, made from nic.y, by GNU bison 1.75.  */\r
   2 \r
   3 /* Skeleton parser for Yacc-like parsing with Bison,\r
   4    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.\r
   5 \r
   6    This program is free software; you can redistribute it and/or modify\r
   7    it under the terms of the GNU General Public License as published by\r
   8    the Free Software Foundation; either version 2, or (at your option)\r
   9    any later version.\r
  10 \r
  11    This program is distributed in the hope that it will be useful,\r
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14    GNU General Public License for more details.\r
  15 \r
  16    You should have received a copy of the GNU General Public License\r
  17    along with this program; if not, write to the Free Software\r
  18    Foundation, Inc., 59 Temple Place - Suite 330,\r
  19    Boston, MA 02111-1307, USA.  */\r
  20 \r
  21 /* As a special exception, when this file is copied by Bison into a\r
  22    Bison output file, you may use that output file without restriction.\r
  23    This special exception was added by the Free Software Foundation\r
  24    in version 1.24 of Bison.  */\r
  25 \r
  26 /* Written by Richard Stallman by simplifying the original so called\r
  27    ``semantic'' parser.  */\r
  28 \r
  29 /* All symbols defined below should begin with yy or YY, to avoid\r
  30    infringing on user name space.  This should be done even for local\r
  31    variables, as they might otherwise be expanded by user macros.\r
  32    There are some unavoidable exceptions within include files to\r
  33    define necessary library symbols; they are noted "INFRINGES ON\r
  34    USER NAME SPACE" below.  */\r
  35 \r
  36 /* Identify Bison output.  */\r
  37 #define YYBISON 1\r
  38 \r
  39 /* Pure parsers.  */\r
  40 #define YYPURE  0\r
  41 \r
  42 /* Using locations.  */\r
  43 #define YYLSP_NEEDED 0\r
  44 \r
  45 /* If NAME_PREFIX is specified substitute the variables and functions\r
  46    names.  */\r
  47 #define yyparse NicParserparse\r
  48 #define yylex   NicParserlex\r
  49 #define yyerror NicParsererror\r
  50 #define yylval  NicParserlval\r
  51 #define yychar  NicParserchar\r
  52 #define yydebug NicParserdebug\r
  53 #define yynerrs NicParsernerrs\r
  54 \r
  55 \r
  56 /* Tokens.  */\r
  57 #ifndef YYTOKENTYPE\r
  58 # define YYTOKENTYPE\r
  59    /* Put the tokens into the symbol table, so that GDB and other debuggers\r
  60       know about them.  */\r
  61    enum yytokentype {\r
  62      NAME = 258,\r
  63      STRING_TOKEN = 259,\r
  64      FUNC = 260,\r
  65      TYPES = 261,\r
  66      UNARY_OPS = 262,\r
  67      BINARY_OPS = 263,\r
  68      FIELDS = 264,\r
  69      OPTIONS = 265\r
  70    };\r
  71 #endif\r
  72 #define NAME 258\r
  73 #define STRING_TOKEN 259\r
  74 #define FUNC 260\r
  75 #define TYPES 261\r
  76 #define UNARY_OPS 262\r
  77 #define BINARY_OPS 263\r
  78 #define FIELDS 264\r
  79 #define OPTIONS 265\r
  80 \r
  81 \r
  82 \r
  83 \r
  84 /* Copy the first part of user declarations.  */\r
  85 #line 8 "nic.y"\r
  86 \r
  87 \r
  88 \r
  89 #include <stdio.h>\r
  90 \r
  91 /*              Some addn'l includes, necessary but not included by the\r
  92                 bison generated code.\r
  93 */\r
  94 \r
  95 #include <stdlib.h>\r
  96 \r
  97 /*              prototypes for the parser callbacks.\r
  98 */\r
  99 \r
 100 #include "nic_def.h"\r
 101 \r
 102 extern int NicParserlex();\r
 103 void NicParsererror(char *s);\r
 104 \r
 105 \r
 106 extern nic_property *nicp;\r
 107 extern std::vector<std::string> nic_attr_vec;\r
 108 extern std::vector<std::string> nic_val_vec;\r
 109 extern std::string nic_a, nic_v;\r
 110 \r
 111 \r
 112 \r
 113 #define YYDEBUG 1\r
 114 \r
 115 \r
 116 \r
 117 /* Enabling traces.  */\r
 118 #ifndef YYDEBUG\r
 119 # define YYDEBUG 0\r
 120 #endif\r
 121 \r
 122 /* Enabling verbose error messages.  */\r
 123 #ifdef YYERROR_VERBOSE\r
 124 # undef YYERROR_VERBOSE\r
 125 # define YYERROR_VERBOSE 1\r
 126 #else\r
 127 # define YYERROR_VERBOSE 0\r
 128 #endif\r
 129 \r
 130 #ifndef YYSTYPE\r
 131 #line 42 "nic.y"\r
 132 typedef union {\r
 133         int intval;\r
 134         double floatval;\r
 135         char *strval;\r
 136         int subtok;\r
 137 \r
 138         /*                      for FTA definition.     */\r
 139 \r
 140 } yystype;\r
 141 /* Line 193 of /usr/local/share/bison/yacc.c.  */\r
 142 #line 143 "nic.tab.cc"\r
 143 # define YYSTYPE yystype\r
 144 # define YYSTYPE_IS_TRIVIAL 1\r
 145 #endif\r
 146 \r
 147 #ifndef YYLTYPE\r
 148 typedef struct yyltype\r
 149 {\r
 150   int first_line;\r
 151   int first_column;\r
 152   int last_line;\r
 153   int last_column;\r
 154 } yyltype;\r
 155 # define YYLTYPE yyltype\r
 156 # define YYLTYPE_IS_TRIVIAL 1\r
 157 #endif\r
 158 \r
 159 /* Copy the second part of user declarations.  */\r
 160 \r
 161 \r
 162 /* Line 213 of /usr/local/share/bison/yacc.c.  */\r
 163 #line 164 "nic.tab.cc"\r
 164 \r
 165 #if ! defined (yyoverflow) || YYERROR_VERBOSE\r
 166 \r
 167 /* The parser invokes alloca or malloc; define the necessary symbols.  */\r
 168 \r
 169 # if YYSTACK_USE_ALLOCA\r
 170 #  define YYSTACK_ALLOC alloca\r
 171 # else\r
 172 #  ifndef YYSTACK_USE_ALLOCA\r
 173 #   if defined (alloca) || defined (_ALLOCA_H)\r
 174 #    define YYSTACK_ALLOC alloca\r
 175 #   else\r
 176 #    ifdef __GNUC__\r
 177 #     define YYSTACK_ALLOC __builtin_alloca\r
 178 #    endif\r
 179 #   endif\r
 180 #  endif\r
 181 # endif\r
 182 \r
 183 # ifdef YYSTACK_ALLOC\r
 184    /* Pacify GCC's `empty if-body' warning. */\r
 185 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)\r
 186 # else\r
 187 #  if defined (__STDC__) || defined (__cplusplus)\r
 188 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */\r
 189 #   define YYSIZE_T size_t\r
 190 #  endif\r
 191 #  define YYSTACK_ALLOC malloc\r
 192 #  define YYSTACK_FREE free\r
 193 # endif\r
 194 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */\r
 195 \r
 196 \r
 197 #if (! defined (yyoverflow) \\r
 198      && (! defined (__cplusplus) \\r
 199          || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))\r
 200 \r
 201 /* A type that is properly aligned for any stack member.  */\r
 202 union yyalloc\r
 203 {\r
 204   short yyss;\r
 205   YYSTYPE yyvs;\r
 206   };\r
 207 \r
 208 /* The size of the maximum gap between one aligned stack and the next.  */\r
 209 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)\r
 210 \r
 211 /* The size of an array large to enough to hold all stacks, each with\r
 212    N elements.  */\r
 213 # define YYSTACK_BYTES(N) \\r
 214      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \\r
 215       + YYSTACK_GAP_MAX)\r
 216 \r
 217 /* Copy COUNT objects from FROM to TO.  The source and destination do\r
 218    not overlap.  */\r
 219 # ifndef YYCOPY\r
 220 #  if 1 < __GNUC__\r
 221 #   define YYCOPY(To, From, Count) \\r
 222       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))\r
 223 #  else\r
 224 #   define YYCOPY(To, From, Count)              \\r
 225       do                                        \\r
 226         {                                       \\r
 227           register YYSIZE_T yyi;                \\r
 228           for (yyi = 0; yyi < (Count); yyi++)   \\r
 229             (To)[yyi] = (From)[yyi];    \\r
 230         }                                       \\r
 231       while (0)\r
 232 #  endif\r
 233 # endif\r
 234 \r
 235 /* Relocate STACK from its old location to the new one.  The\r
 236    local variables YYSIZE and YYSTACKSIZE give the old and new number of\r
 237    elements in the stack, and YYPTR gives the new location of the\r
 238    stack.  Advance YYPTR to a properly aligned location for the next\r
 239    stack.  */\r
 240 # define YYSTACK_RELOCATE(Stack)                                        \\r
 241     do                                                                  \\r
 242       {                                                                 \\r
 243         YYSIZE_T yynewbytes;                                            \\r
 244         YYCOPY (&yyptr->Stack, Stack, yysize);                          \\r
 245         Stack = &yyptr->Stack;                                          \\r
 246         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \\r
 247         yyptr += yynewbytes / sizeof (*yyptr);                          \\r
 248       }                                                                 \\r
 249     while (0)\r
 250 \r
 251 #endif\r
 252 \r
 253 #if defined (__STDC__) || defined (__cplusplus)\r
 254    typedef signed char yysigned_char;\r
 255 #else\r
 256    typedef short yysigned_char;\r
 257 #endif\r
 258 \r
 259 /* YYFINAL -- State number of the termination state. */\r
 260 #define YYFINAL  8\r
 261 #define YYLAST   30\r
 262 \r
 263 /* YYNTOKENS -- Number of terminals. */\r
 264 #define YYNTOKENS  14\r
 265 /* YYNNTS -- Number of nonterminals. */\r
 266 #define YYNNTS  13\r
 267 /* YYNRULES -- Number of rules. */\r
 268 #define YYNRULES  20\r
 269 /* YYNRULES -- Number of states. */\r
 270 #define YYNSTATES  41\r
 271 \r
 272 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */\r
 273 #define YYUNDEFTOK  2\r
 274 #define YYMAXUTOK   265\r
 275 \r
 276 #define YYTRANSLATE(X) \\r
 277   ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK)\r
 278 \r
 279 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */\r
 280 static const unsigned char yytranslate[] =\r
 281 {\r
 282        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 283        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 284        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 285        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 286        2,     2,     2,     2,    12,     2,     2,     2,     2,     2,\r
 287        2,     2,     2,     2,     2,     2,     2,     2,     2,    11,\r
 288        2,    13,     2,     2,     2,     2,     2,     2,     2,     2,\r
 289        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 290        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 291        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 292        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 293        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 294        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 295        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 296        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 297        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 298        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 299        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 300        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 301        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 302        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 303        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 304        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 305        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 306        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 307        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,\r
 308        5,     6,     7,     8,     9,    10\r
 309 };\r
 310 \r
 311 #if YYDEBUG\r
 312 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in\r
 313    YYRHS.  */\r
 314 static const unsigned char yyprhs[] =\r
 315 {\r
 316        0,     0,     3,    10,    14,    18,    22,    26,    30,    34,\r
 317       36,    37,    39,    41,    45,    49,    51,    52,    54,    58,\r
 318       62\r
 319 };\r
 320 \r
 321 /* YYRHS -- A `-1'-separated list of the rules' RHS. */\r
 322 static const yysigned_char yyrhs[] =\r
 323 {\r
 324       15,     0,    -1,    16,    17,    18,    19,    20,    21,    -1,\r
 325       10,    24,    11,    -1,     6,    22,    11,    -1,     7,    22,\r
 326       11,    -1,     8,    22,    11,    -1,     9,    22,    11,    -1,\r
 327        5,    22,    11,    -1,    23,    -1,    -1,     3,    -1,     4,\r
 328       -1,    23,    12,     3,    -1,    23,    12,     4,    -1,    25,\r
 329       -1,    -1,    26,    -1,    25,    12,    26,    -1,     3,    13,\r
 330        4,    -1,     3,    13,     3,    -1\r
 331 };\r
 332 \r
 333 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */\r
 334 static const unsigned char yyrline[] =\r
 335 {\r
 336        0,    61,    61,    65,    69,    73,    77,    81,    85,    89,\r
 337       91,    94,    96,    97,    98,   101,   103,   106,   109,   113,\r
 338      115\r
 339 };\r
 340 #endif\r
 341 \r
 342 #if YYDEBUG || YYERROR_VERBOSE\r
 343 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.\r
 344    First, the terminals, then, starting at YYNTOKENS, nonterminals. */\r
 345 static const char *const yytname[] =\r
 346 {\r
 347   "$end", "error", "$undefined", "NAME", "STRING_TOKEN", "FUNC", "TYPES", \r
 348   "UNARY_OPS", "BINARY_OPS", "FIELDS", "OPTIONS", "';'", "','", "'='", \r
 349   "$accept", "parse_result", "opts", "types", "unary_ops", "binary_ops", \r
 350   "fields", "fcns", "opt_attr_list", "attr_list", "opt_val_list", \r
 351   "val_list", "val", 0\r
 352 };\r
 353 #endif\r
 354 \r
 355 # ifdef YYPRINT\r
 356 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to\r
 357    token YYLEX-NUM.  */\r
 358 static const unsigned short yytoknum[] =\r
 359 {\r
 360        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,\r
 361      265,    59,    44,    61\r
 362 };\r
 363 # endif\r
 364 \r
 365 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */\r
 366 static const unsigned char yyr1[] =\r
 367 {\r
 368        0,    14,    15,    16,    17,    18,    19,    20,    21,    22,\r
 369       22,    23,    23,    23,    23,    24,    24,    25,    25,    26,\r
 370       26\r
 371 };\r
 372 \r
 373 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */\r
 374 static const unsigned char yyr2[] =\r
 375 {\r
 376        0,     2,     6,     3,     3,     3,     3,     3,     3,     1,\r
 377        0,     1,     1,     3,     3,     1,     0,     1,     3,     3,\r
 378        3\r
 379 };\r
 380 \r
 381 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state\r
 382    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero\r
 383    means the default is an error.  */\r
 384 static const unsigned char yydefact[] =\r
 385 {\r
 386        0,    16,     0,     0,     0,     0,    15,    17,     1,    10,\r
 387        0,     0,     3,     0,    11,    12,     0,     9,    10,     0,\r
 388       20,    19,    18,     4,     0,     0,    10,     0,    13,    14,\r
 389        5,     0,    10,     0,     6,     0,    10,     2,     7,     0,\r
 390        8\r
 391 };\r
 392 \r
 393 /* YYDEFGOTO[NTERM-NUM]. */\r
 394 static const yysigned_char yydefgoto[] =\r
 395 {\r
 396       -1,     2,     3,    10,    19,    27,    33,    37,    16,    17,\r
 397        5,     6,     7\r
 398 };\r
 399 \r
 400 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing\r
 401    STATE-NUM.  */\r
 402 #define YYPACT_NINF -19\r
 403 static const yysigned_char yypact[] =\r
 404 {\r
 405       -3,     6,    10,     5,    -1,     4,     1,   -19,   -19,    -2,\r
 406        9,     0,   -19,     6,   -19,   -19,     8,    11,    -2,    12,\r
 407      -19,   -19,   -19,   -19,     2,    13,    -2,    16,   -19,   -19,\r
 408      -19,    15,    -2,    17,   -19,    18,    -2,   -19,   -19,    19,\r
 409      -19\r
 410 };\r
 411 \r
 412 /* YYPGOTO[NTERM-NUM].  */\r
 413 static const yysigned_char yypgoto[] =\r
 414 {\r
 415      -19,   -19,   -19,   -19,   -19,   -19,   -19,   -19,   -18,   -19,\r
 416      -19,   -19,    14\r
 417 };\r
 418 \r
 419 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If\r
 420    positive, shift that token.  If negative, reduce the rule which\r
 421    number is the opposite.  If zero, do what YYDEFACT says.\r
 422    If YYTABLE_NINF, parse error.  */\r
 423 #define YYTABLE_NINF -1\r
 424 static const unsigned char yytable[] =\r
 425 {\r
 426       25,    14,    15,    20,    21,    28,    29,     1,    31,     4,\r
 427        8,     9,    11,    13,    35,    12,    18,     0,    39,    23,\r
 428       26,     0,    36,    24,    30,    32,    34,    22,     0,    38,\r
 429       40\r
 430 };\r
 431 \r
 432 static const yysigned_char yycheck[] =\r
 433 {\r
 434       18,     3,     4,     3,     4,     3,     4,    10,    26,     3,\r
 435        0,     6,    13,    12,    32,    11,     7,    -1,    36,    11,\r
 436        8,    -1,     5,    12,    11,     9,    11,    13,    -1,    11,\r
 437       11\r
 438 };\r
 439 \r
 440 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing\r
 441    symbol of state STATE-NUM.  */\r
 442 static const unsigned char yystos[] =\r
 443 {\r
 444        0,    10,    15,    16,     3,    24,    25,    26,     0,     6,\r
 445       17,    13,    11,    12,     3,     4,    22,    23,     7,    18,\r
 446        3,     4,    26,    11,    12,    22,     8,    19,     3,     4,\r
 447       11,    22,     9,    20,    11,    22,     5,    21,    11,    22,\r
 448       11\r
 449 };\r
 450 \r
 451 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)\r
 452 # define YYSIZE_T __SIZE_TYPE__\r
 453 #endif\r
 454 #if ! defined (YYSIZE_T) && defined (size_t)\r
 455 # define YYSIZE_T size_t\r
 456 #endif\r
 457 #if ! defined (YYSIZE_T)\r
 458 # if defined (__STDC__) || defined (__cplusplus)\r
 459 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */\r
 460 #  define YYSIZE_T size_t\r
 461 # endif\r
 462 #endif\r
 463 #if ! defined (YYSIZE_T)\r
 464 # define YYSIZE_T unsigned int\r
 465 #endif\r
 466 \r
 467 #define yyerrok         (yyerrstatus = 0)\r
 468 #define yyclearin       (yychar = YYEMPTY)\r
 469 #define YYEMPTY         -2\r
 470 #define YYEOF           0\r
 471 \r
 472 #define YYACCEPT        goto yyacceptlab\r
 473 #define YYABORT         goto yyabortlab\r
 474 #define YYERROR         goto yyerrlab1\r
 475 \r
 476 /* Like YYERROR except do call yyerror.  This remains here temporarily\r
 477    to ease the transition to the new meaning of YYERROR, for GCC.\r
 478    Once GCC version 2 has supplanted version 1, this can go.  */\r
 479 \r
 480 #define YYFAIL          goto yyerrlab\r
 481 \r
 482 #define YYRECOVERING()  (!!yyerrstatus)\r
 483 \r
 484 #define YYBACKUP(Token, Value)                                  \\r
 485 do                                                              \\r
 486   if (yychar == YYEMPTY && yylen == 1)                          \\r
 487     {                                                           \\r
 488       yychar = (Token);                                         \\r
 489       yylval = (Value);                                         \\r
 490       yychar1 = YYTRANSLATE (yychar);                           \\r
 491       YYPOPSTACK;                                               \\r
 492       goto yybackup;                                            \\r
 493     }                                                           \\r
 494   else                                                          \\r
 495     {                                                           \\r
 496       yyerror ("syntax error: cannot back up");                 \\r
 497       YYERROR;                                                  \\r
 498     }                                                           \\r
 499 while (0)\r
 500 \r
 501 #define YYTERROR        1\r
 502 #define YYERRCODE       256\r
 503 \r
 504 /* YYLLOC_DEFAULT -- Compute the default location (before the actions\r
 505    are run).  */\r
 506 \r
 507 #ifndef YYLLOC_DEFAULT\r
 508 # define YYLLOC_DEFAULT(Current, Rhs, N)           \\r
 509   Current.first_line   = Rhs[1].first_line;      \\r
 510   Current.first_column = Rhs[1].first_column;    \\r
 511   Current.last_line    = Rhs[N].last_line;       \\r
 512   Current.last_column  = Rhs[N].last_column;\r
 513 #endif\r
 514 \r
 515 /* YYLEX -- calling `yylex' with the right arguments.  */\r
 516 \r
 517 #define YYLEX   yylex ()\r
 518 \r
 519 /* Enable debugging if requested.  */\r
 520 #if YYDEBUG\r
 521 \r
 522 # ifndef YYFPRINTF\r
 523 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */\r
 524 #  define YYFPRINTF fprintf\r
 525 # endif\r
 526 \r
 527 # define YYDPRINTF(Args)                        \\r
 528 do {                                            \\r
 529   if (yydebug)                                  \\r
 530     YYFPRINTF Args;                             \\r
 531 } while (0)\r
 532 # define YYDSYMPRINT(Args)                      \\r
 533 do {                                            \\r
 534   if (yydebug)                                  \\r
 535     yysymprint Args;                            \\r
 536 } while (0)\r
 537 /* Nonzero means print parse trace.  It is left uninitialized so that\r
 538    multiple parsers can coexist.  */\r
 539 int yydebug;\r
 540 #else /* !YYDEBUG */\r
 541 # define YYDPRINTF(Args)\r
 542 # define YYDSYMPRINT(Args)\r
 543 #endif /* !YYDEBUG */\r
 544 \r
 545 /* YYINITDEPTH -- initial size of the parser's stacks.  */\r
 546 #ifndef YYINITDEPTH\r
 547 # define YYINITDEPTH 200\r
 548 #endif\r
 549 \r
 550 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only\r
 551    if the built-in stack extension method is used).\r
 552 \r
 553    Do not make this value too large; the results are undefined if\r
 554    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)\r
 555    evaluated with infinite-precision integer arithmetic.  */\r
 556 \r
 557 #if YYMAXDEPTH == 0\r
 558 # undef YYMAXDEPTH\r
 559 #endif\r
 560 \r
 561 #ifndef YYMAXDEPTH\r
 562 # define YYMAXDEPTH 10000\r
 563 #endif\r
 564 \r
 565 \f\r
 566 \r
 567 #if YYERROR_VERBOSE\r
 568 \r
 569 # ifndef yystrlen\r
 570 #  if defined (__GLIBC__) && defined (_STRING_H)\r
 571 #   define yystrlen strlen\r
 572 #  else\r
 573 /* Return the length of YYSTR.  */\r
 574 static YYSIZE_T\r
 575 #   if defined (__STDC__) || defined (__cplusplus)\r
 576 yystrlen (const char *yystr)\r
 577 #   else\r
 578 yystrlen (yystr)\r
 579      const char *yystr;\r
 580 #   endif\r
 581 {\r
 582   register const char *yys = yystr;\r
 583 \r
 584   while (*yys++ != '\0')\r
 585     continue;\r
 586 \r
 587   return yys - yystr - 1;\r
 588 }\r
 589 #  endif\r
 590 # endif\r
 591 \r
 592 # ifndef yystpcpy\r
 593 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)\r
 594 #   define yystpcpy stpcpy\r
 595 #  else\r
 596 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in\r
 597    YYDEST.  */\r
 598 static char *\r
 599 #   if defined (__STDC__) || defined (__cplusplus)\r
 600 yystpcpy (char *yydest, const char *yysrc)\r
 601 #   else\r
 602 yystpcpy (yydest, yysrc)\r
 603      char *yydest;\r
 604      const char *yysrc;\r
 605 #   endif\r
 606 {\r
 607   register char *yyd = yydest;\r
 608   register const char *yys = yysrc;\r
 609 \r
 610   while ((*yyd++ = *yys++) != '\0')\r
 611     continue;\r
 612 \r
 613   return yyd - 1;\r
 614 }\r
 615 #  endif\r
 616 # endif\r
 617 \r
 618 #endif /* !YYERROR_VERBOSE */\r
 619 \r
 620 \f\r
 621 \r
 622 #if YYDEBUG\r
 623 /*-----------------------------.\r
 624 | Print this symbol on YYOUT.  |\r
 625 `-----------------------------*/\r
 626 \r
 627 static void\r
 628 #if defined (__STDC__) || defined (__cplusplus)\r
 629 yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue)\r
 630 #else\r
 631 yysymprint (yyout, yytype, yyvalue)\r
 632     FILE* yyout;\r
 633     int yytype;\r
 634     YYSTYPE yyvalue;\r
 635 #endif\r
 636 {\r
 637   /* Pacify ``unused variable'' warnings.  */\r
 638   (void) yyvalue;\r
 639 \r
 640   if (yytype < YYNTOKENS)\r
 641     {\r
 642       YYFPRINTF (yyout, "token %s (", yytname[yytype]);\r
 643 # ifdef YYPRINT\r
 644       YYPRINT (yyout, yytoknum[yytype], yyvalue);\r
 645 # endif\r
 646     }\r
 647   else\r
 648     YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);\r
 649 \r
 650   switch (yytype)\r
 651     {\r
 652       default:\r
 653         break;\r
 654     }\r
 655   YYFPRINTF (yyout, ")");\r
 656 }\r
 657 #endif /* YYDEBUG. */\r
 658 \r
 659 \r
 660 /*-----------------------------------------------.\r
 661 | Release the memory associated to this symbol.  |\r
 662 `-----------------------------------------------*/\r
 663 \r
 664 static void\r
 665 #if defined (__STDC__) || defined (__cplusplus)\r
 666 yydestruct (int yytype, YYSTYPE yyvalue)\r
 667 #else\r
 668 yydestruct (yytype, yyvalue)\r
 669     int yytype;\r
 670     YYSTYPE yyvalue;\r
 671 #endif\r
 672 {\r
 673   /* Pacify ``unused variable'' warnings.  */\r
 674   (void) yyvalue;\r
 675 \r
 676   switch (yytype)\r
 677     {\r
 678       default:\r
 679         break;\r
 680     }\r
 681 }\r
 682 \r
 683 \f\r
 684 \r
 685 /* The user can define YYPARSE_PARAM as the name of an argument to be passed\r
 686    into yyparse.  The argument should have type void *.\r
 687    It should actually point to an object.\r
 688    Grammar actions can access the variable by casting it\r
 689    to the proper pointer type.  */\r
 690 \r
 691 #ifdef YYPARSE_PARAM\r
 692 # if defined (__STDC__) || defined (__cplusplus)\r
 693 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM\r
 694 #  define YYPARSE_PARAM_DECL\r
 695 # else\r
 696 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM\r
 697 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;\r
 698 # endif\r
 699 #else /* !YYPARSE_PARAM */\r
 700 # define YYPARSE_PARAM_ARG\r
 701 # define YYPARSE_PARAM_DECL\r
 702 #endif /* !YYPARSE_PARAM */\r
 703 \r
 704 /* Prevent warning if -Wstrict-prototypes.  */\r
 705 #ifdef __GNUC__\r
 706 # ifdef YYPARSE_PARAM\r
 707 int yyparse (void *);\r
 708 # else\r
 709 int yyparse (void);\r
 710 # endif\r
 711 #endif\r
 712 \r
 713 \r
 714 /* The lookahead symbol.  */\r
 715 int yychar;\r
 716 \r
 717 /* The semantic value of the lookahead symbol.  */\r
 718 YYSTYPE yylval;\r
 719 \r
 720 /* Number of parse errors so far.  */\r
 721 int yynerrs;\r
 722 \r
 723 \r
 724 int\r
 725 yyparse (YYPARSE_PARAM_ARG)\r
 726      YYPARSE_PARAM_DECL\r
 727 {\r
 728   \r
 729   register int yystate;\r
 730   register int yyn;\r
 731   int yyresult;\r
 732   /* Number of tokens to shift before error messages enabled.  */\r
 733   int yyerrstatus;\r
 734   /* Lookahead token as an internal (translated) token number.  */\r
 735   int yychar1 = 0;\r
 736 \r
 737   /* Three stacks and their tools:\r
 738      `yyss': related to states,\r
 739      `yyvs': related to semantic values,\r
 740      `yyls': related to locations.\r
 741 \r
 742      Refer to the stacks thru separate pointers, to allow yyoverflow\r
 743      to reallocate them elsewhere.  */\r
 744 \r
 745   /* The state stack.  */\r
 746   short yyssa[YYINITDEPTH];\r
 747   short *yyss = yyssa;\r
 748   register short *yyssp;\r
 749 \r
 750   /* The semantic value stack.  */\r
 751   YYSTYPE yyvsa[YYINITDEPTH];\r
 752   YYSTYPE *yyvs = yyvsa;\r
 753   register YYSTYPE *yyvsp;\r
 754 \r
 755 \r
 756 \r
 757 #define YYPOPSTACK   (yyvsp--, yyssp--)\r
 758 \r
 759   YYSIZE_T yystacksize = YYINITDEPTH;\r
 760 \r
 761   /* The variables used to return semantic value and location from the\r
 762      action routines.  */\r
 763   YYSTYPE yyval;\r
 764 \r
 765 \r
 766   /* When reducing, the number of symbols on the RHS of the reduced\r
 767      rule.  */\r
 768   int yylen;\r
 769 \r
 770   YYDPRINTF ((stderr, "Starting parse\n"));\r
 771 \r
 772   yystate = 0;\r
 773   yyerrstatus = 0;\r
 774   yynerrs = 0;\r
 775   yychar = YYEMPTY;             /* Cause a token to be read.  */\r
 776 \r
 777   /* Initialize stack pointers.\r
 778      Waste one element of value and location stack\r
 779      so that they stay on the same level as the state stack.\r
 780      The wasted elements are never initialized.  */\r
 781 \r
 782   yyssp = yyss;\r
 783   yyvsp = yyvs;\r
 784 \r
 785   goto yysetstate;\r
 786 \r
 787 /*------------------------------------------------------------.\r
 788 | yynewstate -- Push a new state, which is found in yystate.  |\r
 789 `------------------------------------------------------------*/\r
 790  yynewstate:\r
 791   /* In all cases, when you get here, the value and location stacks\r
 792      have just been pushed. so pushing a state here evens the stacks.\r
 793      */\r
 794   yyssp++;\r
 795 \r
 796  yysetstate:\r
 797   *yyssp = yystate;\r
 798 \r
 799   if (yyssp >= yyss + yystacksize - 1)\r
 800     {\r
 801       /* Get the current used size of the three stacks, in elements.  */\r
 802       YYSIZE_T yysize = yyssp - yyss + 1;\r
 803 \r
 804 #ifdef yyoverflow\r
 805       {\r
 806         /* Give user a chance to reallocate the stack. Use copies of\r
 807            these so that the &'s don't force the real ones into\r
 808            memory.  */\r
 809         YYSTYPE *yyvs1 = yyvs;\r
 810         short *yyss1 = yyss;\r
 811 \r
 812 \r
 813         /* Each stack pointer address is followed by the size of the\r
 814            data in use in that stack, in bytes.  This used to be a\r
 815            conditional around just the two extra args, but that might\r
 816            be undefined if yyoverflow is a macro.  */\r
 817         yyoverflow ("parser stack overflow",\r
 818                     &yyss1, yysize * sizeof (*yyssp),\r
 819                     &yyvs1, yysize * sizeof (*yyvsp),\r
 820 \r
 821                     &yystacksize);\r
 822 \r
 823         yyss = yyss1;\r
 824         yyvs = yyvs1;\r
 825       }\r
 826 #else /* no yyoverflow */\r
 827 # ifndef YYSTACK_RELOCATE\r
 828       goto yyoverflowlab;\r
 829 # else\r
 830       /* Extend the stack our own way.  */\r
 831       if (yystacksize >= YYMAXDEPTH)\r
 832         goto yyoverflowlab;\r
 833       yystacksize *= 2;\r
 834       if (yystacksize > YYMAXDEPTH)\r
 835         yystacksize = YYMAXDEPTH;\r
 836 \r
 837       {\r
 838         short *yyss1 = yyss;\r
 839         union yyalloc *yyptr =\r
 840           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));\r
 841         if (! yyptr)\r
 842           goto yyoverflowlab;\r
 843         YYSTACK_RELOCATE (yyss);\r
 844         YYSTACK_RELOCATE (yyvs);\r
 845 \r
 846 #  undef YYSTACK_RELOCATE\r
 847         if (yyss1 != yyssa)\r
 848           YYSTACK_FREE (yyss1);\r
 849       }\r
 850 # endif\r
 851 #endif /* no yyoverflow */\r
 852 \r
 853       yyssp = yyss + yysize - 1;\r
 854       yyvsp = yyvs + yysize - 1;\r
 855 \r
 856 \r
 857       YYDPRINTF ((stderr, "Stack size increased to %lu\n",\r
 858                   (unsigned long int) yystacksize));\r
 859 \r
 860       if (yyssp >= yyss + yystacksize - 1)\r
 861         YYABORT;\r
 862     }\r
 863 \r
 864   YYDPRINTF ((stderr, "Entering state %d\n", yystate));\r
 865 \r
 866   goto yybackup;\r
 867 \r
 868 /*-----------.\r
 869 | yybackup.  |\r
 870 `-----------*/\r
 871 yybackup:\r
 872 \r
 873 /* Do appropriate processing given the current state.  */\r
 874 /* Read a lookahead token if we need one and don't already have one.  */\r
 875 /* yyresume: */\r
 876 \r
 877   /* First try to decide what to do without reference to lookahead token.  */\r
 878 \r
 879   yyn = yypact[yystate];\r
 880   if (yyn == YYPACT_NINF)\r
 881     goto yydefault;\r
 882 \r
 883   /* Not known => get a lookahead token if don't already have one.  */\r
 884 \r
 885   /* yychar is either YYEMPTY or YYEOF\r
 886      or a valid token in external form.  */\r
 887 \r
 888   if (yychar == YYEMPTY)\r
 889     {\r
 890       YYDPRINTF ((stderr, "Reading a token: "));\r
 891       yychar = YYLEX;\r
 892     }\r
 893 \r
 894   /* Convert token to internal form (in yychar1) for indexing tables with.  */\r
 895 \r
 896   if (yychar <= 0)              /* This means end of input.  */\r
 897     {\r
 898       yychar1 = 0;\r
 899       yychar = YYEOF;           /* Don't call YYLEX any more.  */\r
 900 \r
 901       YYDPRINTF ((stderr, "Now at end of input.\n"));\r
 902     }\r
 903   else\r
 904     {\r
 905       yychar1 = YYTRANSLATE (yychar);\r
 906 \r
 907       /* We have to keep this `#if YYDEBUG', since we use variables\r
 908          which are defined only if `YYDEBUG' is set.  */\r
 909       YYDPRINTF ((stderr, "Next token is "));\r
 910       YYDSYMPRINT ((stderr, yychar1, yylval));\r
 911       YYDPRINTF ((stderr, "\n"));\r
 912     }\r
 913 \r
 914   /* If the proper action on seeing token YYCHAR1 is to reduce or to\r
 915      detect an error, take that action.  */\r
 916   yyn += yychar1;\r
 917   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)\r
 918     goto yydefault;\r
 919   yyn = yytable[yyn];\r
 920   if (yyn <= 0)\r
 921     {\r
 922       if (yyn == 0 || yyn == YYTABLE_NINF)\r
 923         goto yyerrlab;\r
 924       yyn = -yyn;\r
 925       goto yyreduce;\r
 926     }\r
 927 \r
 928   if (yyn == YYFINAL)\r
 929     YYACCEPT;\r
 930 \r
 931   /* Shift the lookahead token.  */\r
 932   YYDPRINTF ((stderr, "Shifting token %d (%s), ",\r
 933               yychar, yytname[yychar1]));\r
 934 \r
 935   /* Discard the token being shifted unless it is eof.  */\r
 936   if (yychar != YYEOF)\r
 937     yychar = YYEMPTY;\r
 938 \r
 939   *++yyvsp = yylval;\r
 940 \r
 941 \r
 942   /* Count tokens shifted since error; after three, turn off error\r
 943      status.  */\r
 944   if (yyerrstatus)\r
 945     yyerrstatus--;\r
 946 \r
 947   yystate = yyn;\r
 948   goto yynewstate;\r
 949 \r
 950 \r
 951 /*-----------------------------------------------------------.\r
 952 | yydefault -- do the default action for the current state.  |\r
 953 `-----------------------------------------------------------*/\r
 954 yydefault:\r
 955   yyn = yydefact[yystate];\r
 956   if (yyn == 0)\r
 957     goto yyerrlab;\r
 958   goto yyreduce;\r
 959 \r
 960 \r
 961 /*-----------------------------.\r
 962 | yyreduce -- Do a reduction.  |\r
 963 `-----------------------------*/\r
 964 yyreduce:\r
 965   /* yyn is the number of a rule to reduce with.  */\r
 966   yylen = yyr2[yyn];\r
 967 \r
 968   /* If YYLEN is nonzero, implement the default value of the action:\r
 969      `$$ = $1'.\r
 970 \r
 971      Otherwise, the following line sets YYVAL to garbage.\r
 972      This behavior is undocumented and Bison\r
 973      users should not rely upon it.  Assigning to YYVAL\r
 974      unconditionally makes the parser a bit smaller, and it avoids a\r
 975      GCC warning that YYVAL may be used uninitialized.  */\r
 976   yyval = yyvsp[1-yylen];\r
 977 \r
 978 \r
 979 \r
 980 #if YYDEBUG\r
 981   /* We have to keep this `#if YYDEBUG', since we use variables which\r
 982      are defined only if `YYDEBUG' is set.  */\r
 983   if (yydebug)\r
 984     {\r
 985       int yyi;\r
 986 \r
 987       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",\r
 988                  yyn - 1, yyrline[yyn]);\r
 989 \r
 990       /* Print the symbols being reduced, and their result.  */\r
 991       for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)\r
 992         YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);\r
 993       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);\r
 994     }\r
 995 #endif\r
 996   switch (yyn)\r
 997     {\r
 998         case 3:\r
 999 #line 66 "nic.y"\r
1000     {nicp->opta=nic_attr_vec; nicp->optv=nic_val_vec;}\r
1001     break;\r
1002 \r
1003   case 4:\r
1004 #line 70 "nic.y"\r
1005     {nicp->typea=nic_attr_vec;}\r
1006     break;\r
1007 \r
1008   case 5:\r
1009 #line 74 "nic.y"\r
1010     {nicp->opua=nic_attr_vec;}\r
1011     break;\r
1012 \r
1013   case 6:\r
1014 #line 78 "nic.y"\r
1015     {nicp->opba=nic_attr_vec;}\r
1016     break;\r
1017 \r
1018   case 7:\r
1019 #line 82 "nic.y"\r
1020     {nicp->fieldsa=nic_attr_vec;}\r
1021     break;\r
1022 \r
1023   case 8:\r
1024 #line 86 "nic.y"\r
1025     {nicp->funca=nic_attr_vec;}\r
1026     break;\r
1027 \r
1028   case 10:\r
1029 #line 91 "nic.y"\r
1030     {nic_attr_vec.clear(); }\r
1031     break;\r
1032 \r
1033   case 11:\r
1034 #line 95 "nic.y"\r
1035     {nic_attr_vec.clear();  nic_attr_vec.push_back(yyvsp[0].strval); }\r
1036     break;\r
1037 \r
1038   case 12:\r
1039 #line 96 "nic.y"\r
1040     {nic_attr_vec.clear();  nic_attr_vec.push_back(yyvsp[0].strval); }\r
1041     break;\r
1042 \r
1043   case 13:\r
1044 #line 97 "nic.y"\r
1045     {nic_attr_vec.push_back(yyvsp[0].strval);}\r
1046     break;\r
1047 \r
1048   case 14:\r
1049 #line 98 "nic.y"\r
1050     {nic_attr_vec.push_back(yyvsp[0].strval);}\r
1051     break;\r
1052 \r
1053   case 16:\r
1054 #line 103 "nic.y"\r
1055     {nic_attr_vec.clear(); nic_val_vec.clear();}\r
1056     break;\r
1057 \r
1058   case 17:\r
1059 #line 107 "nic.y"\r
1060     {nic_attr_vec.clear();  nic_attr_vec.push_back(nic_a);\r
1061                          nic_val_vec.clear(); nic_val_vec.push_back(nic_v); }\r
1062     break;\r
1063 \r
1064   case 18:\r
1065 #line 109 "nic.y"\r
1066     {nic_attr_vec.push_back(nic_a);\r
1067                                         nic_val_vec.push_back(nic_v); }\r
1068     break;\r
1069 \r
1070   case 19:\r
1071 #line 114 "nic.y"\r
1072     {nic_a = yyvsp[-2].strval; nic_v = yyvsp[0].strval;}\r
1073     break;\r
1074 \r
1075   case 20:\r
1076 #line 115 "nic.y"\r
1077     {nic_a = yyvsp[-2].strval; nic_v = yyvsp[0].strval;}\r
1078     break;\r
1079 \r
1080 \r
1081     }\r
1082 \r
1083 /* Line 1016 of /usr/local/share/bison/yacc.c.  */\r
1084 #line 1085 "nic.tab.cc"\r
1085 \f\r
1086   yyvsp -= yylen;\r
1087   yyssp -= yylen;\r
1088 \r
1089 \r
1090 #if YYDEBUG\r
1091   if (yydebug)\r
1092     {\r
1093       short *yyssp1 = yyss - 1;\r
1094       YYFPRINTF (stderr, "state stack now");\r
1095       while (yyssp1 != yyssp)\r
1096         YYFPRINTF (stderr, " %d", *++yyssp1);\r
1097       YYFPRINTF (stderr, "\n");\r
1098     }\r
1099 #endif\r
1100 \r
1101   *++yyvsp = yyval;\r
1102 \r
1103 \r
1104   /* Now `shift' the result of the reduction.  Determine what state\r
1105      that goes to, based on the state we popped back to and the rule\r
1106      number reduced by.  */\r
1107 \r
1108   yyn = yyr1[yyn];\r
1109 \r
1110   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;\r
1111   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)\r
1112     yystate = yytable[yystate];\r
1113   else\r
1114     yystate = yydefgoto[yyn - YYNTOKENS];\r
1115 \r
1116   goto yynewstate;\r
1117 \r
1118 \r
1119 /*------------------------------------.\r
1120 | yyerrlab -- here on detecting error |\r
1121 `------------------------------------*/\r
1122 yyerrlab:\r
1123   /* If not already recovering from an error, report this error.  */\r
1124   if (!yyerrstatus)\r
1125     {\r
1126       ++yynerrs;\r
1127 #if YYERROR_VERBOSE\r
1128       yyn = yypact[yystate];\r
1129 \r
1130       if (YYPACT_NINF < yyn && yyn < YYLAST)\r
1131         {\r
1132           YYSIZE_T yysize = 0;\r
1133           int yytype = YYTRANSLATE (yychar);\r
1134           char *yymsg;\r
1135           int yyx, yycount;\r
1136 \r
1137           yycount = 0;\r
1138           /* Start YYX at -YYN if negative to avoid negative indexes in\r
1139              YYCHECK.  */\r
1140           for (yyx = yyn < 0 ? -yyn : 0;\r
1141                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)\r
1142             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)\r
1143               yysize += yystrlen (yytname[yyx]) + 15, yycount++;\r
1144           yysize += yystrlen ("parse error, unexpected ") + 1;\r
1145           yysize += yystrlen (yytname[yytype]);\r
1146           yymsg = (char *) YYSTACK_ALLOC (yysize);\r
1147           if (yymsg != 0)\r
1148             {\r
1149               char *yyp = yystpcpy (yymsg, "parse error, unexpected ");\r
1150               yyp = yystpcpy (yyp, yytname[yytype]);\r
1151 \r
1152               if (yycount < 5)\r
1153                 {\r
1154                   yycount = 0;\r
1155                   for (yyx = yyn < 0 ? -yyn : 0;\r
1156                        yyx < (int) (sizeof (yytname) / sizeof (char *));\r
1157                        yyx++)\r
1158                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)\r
1159                       {\r
1160                         const char *yyq = ! yycount ? ", expecting " : " or ";\r
1161                         yyp = yystpcpy (yyp, yyq);\r
1162                         yyp = yystpcpy (yyp, yytname[yyx]);\r
1163                         yycount++;\r
1164                       }\r
1165                 }\r
1166               yyerror (yymsg);\r
1167               YYSTACK_FREE (yymsg);\r
1168             }\r
1169           else\r
1170             yyerror ("parse error; also virtual memory exhausted");\r
1171         }\r
1172       else\r
1173 #endif /* YYERROR_VERBOSE */\r
1174         yyerror ("parse error");\r
1175     }\r
1176   goto yyerrlab1;\r
1177 \r
1178 \r
1179 /*----------------------------------------------------.\r
1180 | yyerrlab1 -- error raised explicitly by an action.  |\r
1181 `----------------------------------------------------*/\r
1182 yyerrlab1:\r
1183   if (yyerrstatus == 3)\r
1184     {\r
1185       /* If just tried and failed to reuse lookahead token after an\r
1186          error, discard it.  */\r
1187 \r
1188       /* Return failure if at end of input.  */\r
1189       if (yychar == YYEOF)\r
1190         {\r
1191           /* Pop the error token.  */\r
1192           YYPOPSTACK;\r
1193           /* Pop the rest of the stack.  */\r
1194           while (yyssp > yyss)\r
1195             {\r
1196               YYDPRINTF ((stderr, "Error: popping "));\r
1197               YYDSYMPRINT ((stderr,\r
1198                             yystos[*yyssp],\r
1199                             *yyvsp));\r
1200               YYDPRINTF ((stderr, "\n"));\r
1201               yydestruct (yystos[*yyssp], *yyvsp);\r
1202               YYPOPSTACK;\r
1203             }\r
1204           YYABORT;\r
1205         }\r
1206 \r
1207       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",\r
1208                   yychar, yytname[yychar1]));\r
1209       yydestruct (yychar1, yylval);\r
1210       yychar = YYEMPTY;\r
1211     }\r
1212 \r
1213   /* Else will try to reuse lookahead token after shifting the error\r
1214      token.  */\r
1215 \r
1216   yyerrstatus = 3;      /* Each real token shifted decrements this.  */\r
1217 \r
1218   for (;;)\r
1219     {\r
1220       yyn = yypact[yystate];\r
1221       if (yyn != YYPACT_NINF)\r
1222         {\r
1223           yyn += YYTERROR;\r
1224           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)\r
1225             {\r
1226               yyn = yytable[yyn];\r
1227               if (0 < yyn)\r
1228                 break;\r
1229             }\r
1230         }\r
1231 \r
1232       /* Pop the current state because it cannot handle the error token.  */\r
1233       if (yyssp == yyss)\r
1234         YYABORT;\r
1235 \r
1236       YYDPRINTF ((stderr, "Error: popping "));\r
1237       YYDSYMPRINT ((stderr,\r
1238                     yystos[*yyssp], *yyvsp));\r
1239       YYDPRINTF ((stderr, "\n"));\r
1240 \r
1241       yydestruct (yystos[yystate], *yyvsp);\r
1242       yyvsp--;\r
1243       yystate = *--yyssp;\r
1244 \r
1245 \r
1246 #if YYDEBUG\r
1247       if (yydebug)\r
1248         {\r
1249           short *yyssp1 = yyss - 1;\r
1250           YYFPRINTF (stderr, "Error: state stack now");\r
1251           while (yyssp1 != yyssp)\r
1252             YYFPRINTF (stderr, " %d", *++yyssp1);\r
1253           YYFPRINTF (stderr, "\n");\r
1254         }\r
1255 #endif\r
1256     }\r
1257 \r
1258   if (yyn == YYFINAL)\r
1259     YYACCEPT;\r
1260 \r
1261   YYDPRINTF ((stderr, "Shifting error token, "));\r
1262 \r
1263   *++yyvsp = yylval;\r
1264 \r
1265 \r
1266   yystate = yyn;\r
1267   goto yynewstate;\r
1268 \r
1269 \r
1270 /*-------------------------------------.\r
1271 | yyacceptlab -- YYACCEPT comes here.  |\r
1272 `-------------------------------------*/\r
1273 yyacceptlab:\r
1274   yyresult = 0;\r
1275   goto yyreturn;\r
1276 \r
1277 /*-----------------------------------.\r
1278 | yyabortlab -- YYABORT comes here.  |\r
1279 `-----------------------------------*/\r
1280 yyabortlab:\r
1281   yyresult = 1;\r
1282   goto yyreturn;\r
1283 \r
1284 #ifndef yyoverflow\r
1285 /*----------------------------------------------.\r
1286 | yyoverflowlab -- parser overflow comes here.  |\r
1287 `----------------------------------------------*/\r
1288 yyoverflowlab:\r
1289   yyerror ("parser stack overflow");\r
1290   yyresult = 2;\r
1291   /* Fall through.  */\r
1292 #endif\r
1293 \r
1294 yyreturn:\r
1295 #ifndef yyoverflow\r
1296   if (yyss != yyssa)\r
1297     YYSTACK_FREE (yyss);\r
1298 #endif\r
1299   return yyresult;\r
1300 }\r
1301 \r
1302 \r
1303 #line 122 "nic.y"\r
1304 \r
1305 \r
1306 \r