modules/rpsl/default.tab.c

/* [<][>]
[^][v][top][bottom][index][help] */

FUNCTIONS

This source file includes following functions.
  1. YYTRANSLATE
  2. YYRECOVERING
  3. YYBACKUP
  4. __yy_memcpy
  5. __yy_memcpy
  6. __yy_memcpy
  7. yyparse
  8. defaulterror

   1 
   2 /*  A Bison parser, made from default.y
   3     by GNU Bison version 1.28  */
   4 
   5 #define YYBISON 1  /* Identify Bison output.  */
   6 
   7 #define yyparse defaultparse
   8 #define yylex defaultlex
   9 #define yyerror defaulterror
  10 #define yylval defaultlval
  11 #define yychar defaultchar
  12 #define yydebug defaultdebug
  13 #define yynerrs defaultnerrs
  14 #define OP_OR   257
  15 #define OP_AND  258
  16 #define OP_NOT  259
  17 #define OP_MS   260
  18 #define OP_EQUAL        261
  19 #define OP_APPEND       262
  20 #define OP_COMPARE      263
  21 #define KEYW_ANY        264
  22 #define KEYW_PEERAS     265
  23 #define ASPATH_POSTFIX  266
  24 #define TKN_FLTRNAME    267
  25 #define TKN_ASNO        268
  26 #define TKN_RSNAME      269
  27 #define TKN_ASNAME      270
  28 #define TKN_PRFXV4      271
  29 #define TKN_PRFXV4RNG   272
  30 #define TKN_IPV4        273
  31 #define TKN_DNS 274
  32 #define TKN_RTRSNAME    275
  33 #define TKN_PRNGNAME    276
  34 #define KEYW_TO 277
  35 #define KEYW_ACTION     278
  36 #define KEYW_NETWORKS   279
  37 #define KEYW_EXCEPT     280
  38 #define TKN_PREF        281
  39 #define TKN_MED 282
  40 #define TKN_DPA 283
  41 #define TKN_ASPATH      284
  42 #define TKN_COMMUNITY   285
  43 #define TKN_NEXT_HOP    286
  44 #define TKN_COST        287
  45 #define TKN_COMM_NO     288
  46 #define KEYW_IGP_COST   289
  47 #define KEYW_SELF       290
  48 #define KEYW_PREPEND    291
  49 #define KEYW_APPEND     292
  50 #define KEYW_DELETE     293
  51 #define KEYW_CONTAINS   294
  52 #define KEYW_AT 295
  53 #define KEYW_INTERNET   296
  54 #define KEYW_NO_EXPORT  297
  55 #define KEYW_NO_ADVERTISE       298
  56 #define TKN_INT 299
  57 
  58 #line 1 "default.y"
  59 
  60 /*
  61   filename: default.y
  62 
  63   description:
  64     Defines the grammar for an RPSL default attribute.  It was mostly
  65     stolen from the IRRToolSet, simplified by removing ability to parse
  66     things defined by a dictionary (we use XML for extensibility rather
  67     than a dictionary).
  68 
  69   notes:
  70     Defines tokens for the associated lexer, default.l.
  71 */
  72 
  73 #line 16 "default.y"
  74 typedef union {
  75     char *sval;
  76 } YYSTYPE;
  77 #line 34 "default.y"
  78 
  79 #include <stdio.h>
  80 #include <stdarg.h>
  81 #include <stdlib.h>
  82 
  83 int yyerror(const char *s);
  84 void syntax_error(char *fmt, ...);
  85 
  86 #include <stdio.h>
  87 
  88 #ifndef __cplusplus
  89 #ifndef __STDC__
  90 #define const
  91 #endif
  92 #endif
  93 
  94 
  95 
  96 #define YYFINAL         188
  97 #define YYFLAG          -32768
  98 #define YYNTBASE        64
  99 
 100 #define YYTRANSLATE(x) ((unsigned)(x) <= 299 ? yytranslate[x] : 107)
     /* [<][>][^][v][top][bottom][index][help] */
 101 
 102 static const char yytranslate[] = {     0,
 103      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 104      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 105      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 106      2,     2,     2,     2,     2,    60,     2,     2,     2,    46,
 107     47,    56,    58,    50,    63,    48,     2,     2,     2,     2,
 108      2,     2,     2,     2,     2,     2,     2,     2,    49,    53,
 109      2,    54,    57,     2,     2,     2,     2,     2,     2,     2,
 110      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 111      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 112     61,     2,    62,    59,     2,     2,     2,     2,     2,     2,
 113      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 114      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 115      2,     2,    51,    55,    52,     2,     2,     2,     2,     2,
 116      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 117      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 118      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 119      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 120      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 121      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 122      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 123      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 124      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 125      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 126      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 127      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 128      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
 129      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
 130     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
 131     27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
 132     37,    38,    39,    40,    41,    42,    43,    44,    45
 133 };
 134 
 135 #if YYDEBUG != 0
 136 static const short yyprhs[] = {     0,
 137      0,     5,     9,    11,    12,    15,    16,    19,    23,    25,
 138     29,    33,    35,    39,    41,    43,    45,    46,    48,    49,
 139     52,    56,    58,    62,    66,    68,    72,    74,    76,    78,
 140     80,    82,    86,    89,    93,    95,    97,    99,   101,   103,
 141    105,   107,   111,   115,   119,   123,   130,   132,   136,   140,
 142    144,   151,   158,   165,   170,   174,   178,   180,   184,   186,
 143    188,   190,   192,   194,   198,   202,   206,   210,   213,   215,
 144    219,   221,   224,   228,   230,   232,   236,   238,   240,   242,
 145    245,   247,   249,   251,   253,   255,   259,   260,   262,   264,
 146    268,   270,   272,   276,   278,   281,   283,   286,   289,   292,
 147    295,   297,   299,   301,   305,   307,   309,   311,   313,   315,
 148    319,   324,   325,   328,   331,   334,   339
 149 };
 150 
 151 static const short yyrhs[] = {    23,
 152     65,    66,    67,     0,    68,    72,    73,     0,    22,     0,
 153      0,    24,    79,     0,     0,    25,    92,     0,    68,     3,
 154     69,     0,    69,     0,    69,     4,    70,     0,    69,    26,
 155     70,     0,    70,     0,    46,    68,    47,     0,    71,     0,
 156     14,     0,    16,     0,     0,    74,     0,     0,    41,    74,
 157      0,    74,     3,    75,     0,    75,     0,    75,     4,    76,
 158      0,    75,    26,    76,     0,    76,     0,    46,    74,    47,
 159      0,    77,     0,    19,     0,    78,     0,    21,     0,    20,
 160      0,    78,    48,    20,     0,    80,    49,     0,    79,    80,
 161     49,     0,    81,     0,    82,     0,    83,     0,    84,     0,
 162     86,     0,    90,     0,    91,     0,    27,     7,    45,     0,
 163     28,     7,    45,     0,    28,     7,    35,     0,    29,     7,
 164     45,     0,    30,    48,    37,    46,    85,    47,     0,    14,
 165      0,    85,    50,    14,     0,    31,     7,    87,     0,    31,
 166      8,    87,     0,    31,    48,    38,    46,    88,    47,     0,
 167     31,    48,    39,    46,    88,    47,     0,    31,    48,    40,
 168     46,    88,    47,     0,    31,    46,    88,    47,     0,    31,
 169      9,    87,     0,    51,    88,    52,     0,    89,     0,    88,
 170     50,    89,     0,    42,     0,    43,     0,    44,     0,    45,
 171      0,    34,     0,    32,     7,    19,     0,    32,     7,    36,
 172      0,    33,     7,    45,     0,    92,     3,    93,     0,    92,
 173     93,     0,    93,     0,    93,     4,    94,     0,    94,     0,
 174      5,    94,     0,    46,    92,    47,     0,    95,     0,    10,
 175      0,    53,   101,    54,     0,    80,     0,    13,     0,    96,
 176      0,    97,     6,     0,    97,     0,    14,     0,    11,     0,
 177     16,     0,    15,     0,    51,    98,    52,     0,     0,    99,
 178      0,   100,     0,    99,    50,   100,     0,    17,     0,    18,
 179      0,   101,    55,   102,     0,   102,     0,   102,   103,     0,
 180    103,     0,   103,    56,     0,   103,    57,     0,   103,    58,
 181      0,   103,    12,     0,   104,     0,    59,     0,    60,     0,
 182     46,   101,    47,     0,   105,     0,    14,     0,    11,     0,
 183     16,     0,    48,     0,    61,   106,    62,     0,    61,    59,
 184    106,    62,     0,     0,   106,    14,     0,   106,    11,     0,
 185    106,    48,     0,   106,    14,    63,    14,     0,   106,    16,
 186      0
 187 };
 188 
 189 #endif
 190 
 191 #if YYDEBUG != 0
 192 static const short yyrline[] = { 0,
 193     46,    49,    50,    53,    54,    57,    58,    61,    62,    65,
 194     66,    67,    70,    71,    74,    75,    78,    79,    82,    83,
 195     86,    87,    90,    91,    92,    95,    96,    99,   100,   105,
 196    108,   109,   112,   113,   116,   117,   118,   119,   120,   121,
 197    122,   125,   136,   145,   148,   159,   162,   163,   166,   167,
 198    168,   169,   170,   171,   172,   175,   178,   179,   182,   183,
 199    184,   185,   195,   198,   199,   202,   213,   214,   215,   218,
 200    219,   222,   223,   224,   227,   228,   229,   230,   231,   234,
 201    235,   238,   239,   240,   241,   242,   245,   246,   249,   250,
 202    253,   254,   257,   258,   261,   262,   265,   266,   267,   268,
 203    269,   272,   273,   274,   275,   278,   279,   280,   281,   282,
 204    283,   286,   287,   288,   289,   290,   291
 205 };
 206 #endif
 207 
 208 
 209 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
 210 
 211 static const char * const yytname[] = {   "$","error","$undefined.","OP_OR",
 212 "OP_AND","OP_NOT","OP_MS","OP_EQUAL","OP_APPEND","OP_COMPARE","KEYW_ANY","KEYW_PEERAS",
 213 "ASPATH_POSTFIX","TKN_FLTRNAME","TKN_ASNO","TKN_RSNAME","TKN_ASNAME","TKN_PRFXV4",
 214 "TKN_PRFXV4RNG","TKN_IPV4","TKN_DNS","TKN_RTRSNAME","TKN_PRNGNAME","KEYW_TO",
 215 "KEYW_ACTION","KEYW_NETWORKS","KEYW_EXCEPT","TKN_PREF","TKN_MED","TKN_DPA","TKN_ASPATH",
 216 "TKN_COMMUNITY","TKN_NEXT_HOP","TKN_COST","TKN_COMM_NO","KEYW_IGP_COST","KEYW_SELF",
 217 "KEYW_PREPEND","KEYW_APPEND","KEYW_DELETE","KEYW_CONTAINS","KEYW_AT","KEYW_INTERNET",
 218 "KEYW_NO_EXPORT","KEYW_NO_ADVERTISE","TKN_INT","'('","')'","'.'","';'","','",
 219 "'{'","'}'","'<'","'>'","'|'","'*'","'?'","'+'","'^'","'$'","'['","']'","'-'",
 220 "default_rule","peering","opt_action","opt_default_filter","as_expr","as_expr_term",
 221 "as_expr_factor","as_expr_operand","opt_router_expr","opt_router_expr_with_at",
 222 "router_expr","router_expr_term","router_expr_factor","router_expr_operand",
 223 "domain_name","action","rp_attribute","pref","med","dpa","aspath","asno_list",
 224 "community","community_list","community_elm_list","community_elm","next_hop",
 225 "cost","filter","filter_term","filter_factor","filter_operand","filter_prefix",
 226 "filter_prefix_operand","opt_filter_prefix_list","filter_prefix_list","filter_prefix_list_prefix",
 227 "filter_aspath","filter_aspath_term","filter_aspath_closure","filter_aspath_factor",
 228 "filter_aspath_no","filter_aspath_range", NULL
 229 };
 230 #endif
 231 
 232 static const short yyr1[] = {     0,
 233     64,    65,    65,    66,    66,    67,    67,    68,    68,    69,
 234     69,    69,    70,    70,    71,    71,    72,    72,    73,    73,
 235     74,    74,    75,    75,    75,    76,    76,    77,    77,    77,
 236     78,    78,    79,    79,    80,    80,    80,    80,    80,    80,
 237     80,    81,    82,    82,    83,    84,    85,    85,    86,    86,
 238     86,    86,    86,    86,    86,    87,    88,    88,    89,    89,
 239     89,    89,    89,    90,    90,    91,    92,    92,    92,    93,
 240     93,    94,    94,    94,    95,    95,    95,    95,    95,    96,
 241     96,    97,    97,    97,    97,    97,    98,    98,    99,    99,
 242    100,   100,   101,   101,   102,   102,   103,   103,   103,   103,
 243    103,   104,   104,   104,   104,   105,   105,   105,   105,   105,
 244    105,   106,   106,   106,   106,   106,   106
 245 };
 246 
 247 static const short yyr2[] = {     0,
 248      4,     3,     1,     0,     2,     0,     2,     3,     1,     3,
 249      3,     1,     3,     1,     1,     1,     0,     1,     0,     2,
 250      3,     1,     3,     3,     1,     3,     1,     1,     1,     1,
 251      1,     3,     2,     3,     1,     1,     1,     1,     1,     1,
 252      1,     3,     3,     3,     3,     6,     1,     3,     3,     3,
 253      6,     6,     6,     4,     3,     3,     1,     3,     1,     1,
 254      1,     1,     1,     3,     3,     3,     3,     2,     1,     3,
 255      1,     2,     3,     1,     1,     3,     1,     1,     1,     2,
 256      1,     1,     1,     1,     1,     3,     0,     1,     1,     3,
 257      1,     1,     3,     1,     2,     1,     2,     2,     2,     2,
 258      1,     1,     1,     3,     1,     1,     1,     1,     1,     3,
 259      4,     0,     2,     2,     2,     4,     2
 260 };
 261 
 262 static const short yydefact[] = {     0,
 263      0,    15,    16,     3,     0,     4,    17,     9,    12,    14,
 264      0,     0,     6,     0,    28,    31,    30,     0,    19,    18,
 265     22,    25,    27,    29,     0,     0,    13,     0,     0,     0,
 266      0,     0,     0,     0,     5,     0,    35,    36,    37,    38,
 267     39,    40,    41,     0,     1,     8,     0,     0,     2,     0,
 268      0,     0,     0,    10,    11,     0,     0,     0,     0,     0,
 269      0,     0,     0,     0,     0,     0,     0,    33,     0,    75,
 270     83,    78,    82,    85,    84,     0,    87,     0,    77,     7,
 271     69,    71,    74,    79,    81,    26,    20,    21,    23,    24,
 272     32,    42,    44,    43,    45,     0,     0,    49,    50,    55,
 273     63,    59,    60,    61,    62,     0,    57,     0,     0,     0,
 274     64,    65,    66,    34,    72,     0,    91,    92,     0,    88,
 275     89,   107,   106,   108,     0,   109,   102,   103,   112,     0,
 276     94,    96,   101,   105,     0,    68,     0,    80,     0,     0,
 277     54,     0,     0,     0,     0,    73,    86,     0,     0,   112,
 278      0,    76,     0,    95,   100,    97,    98,    99,    67,    70,
 279     47,     0,    56,    58,     0,     0,     0,    90,   104,     0,
 280    114,   113,   117,   115,   110,    93,    46,     0,    51,    52,
 281     53,   111,     0,    48,   116,     0,     0,     0
 282 };
 283 
 284 static const short yydefgoto[] = {   186,
 285      6,    13,    45,     7,     8,     9,    10,    19,    49,    20,
 286     21,    22,    23,    24,    35,    79,    37,    38,    39,    40,
 287    162,    41,    98,   106,   107,    42,    43,    80,    81,    82,
 288     83,    84,    85,   119,   120,   121,   130,   131,   132,   133,
 289    134,   151
 290 };
 291 
 292 static const short yypact[] = {     3,
 293    122,-32768,-32768,-32768,     2,    -4,   111,     8,-32768,-32768,
 294     19,   123,     6,     2,-32768,-32768,-32768,    63,   101,    46,
 295     10,-32768,-32768,    23,     2,     2,-32768,    78,   142,   151,
 296    117,    87,   154,   160,   123,   124,-32768,-32768,-32768,-32768,
 297 -32768,-32768,-32768,    88,-32768,     8,    30,    63,-32768,    63,
 298     63,    63,   155,-32768,-32768,   129,   -24,   133,   143,   128,
 299    128,   128,   103,    89,    44,   136,   134,-32768,    88,-32768,
 300 -32768,-32768,-32768,-32768,-32768,    88,   105,    65,-32768,    59,
 301    178,-32768,-32768,-32768,   179,-32768,    46,    10,-32768,-32768,
 302 -32768,-32768,-32768,-32768,-32768,   138,   103,-32768,-32768,-32768,
 303 -32768,-32768,-32768,-32768,-32768,   -12,-32768,   140,   141,   145,
 304 -32768,-32768,-32768,-32768,-32768,    14,-32768,-32768,   137,   146,
 305 -32768,-32768,-32768,-32768,    65,-32768,-32768,-32768,   131,    52,
 306     65,     1,-32768,-32768,    88,   178,    88,-32768,   174,   114,
 307 -32768,   103,   103,   103,   103,-32768,-32768,   105,   -32,-32768,
 308     -9,-32768,    65,     1,-32768,-32768,-32768,-32768,   178,-32768,
 309 -32768,    50,-32768,-32768,    93,   112,   113,-32768,-32768,    -8,
 310 -32768,   130,-32768,-32768,-32768,    65,-32768,   180,-32768,-32768,
 311 -32768,-32768,   181,-32768,-32768,   192,   197,-32768
 312 };
 313 
 314 static const short yypgoto[] = {-32768,
 315 -32768,-32768,-32768,   193,   185,   144,-32768,-32768,-32768,    60,
 316    150,   120,-32768,-32768,-32768,    -3,-32768,-32768,-32768,-32768,
 317 -32768,-32768,   115,   -93,    61,-32768,-32768,   125,   -79,   -69,
 318 -32768,-32768,-32768,-32768,-32768,    54,    79,    53,  -121,-32768,
 319 -32768,    55
 320 };
 321 
 322 
 323 #define YYLAST          206
 324 
 325 
 326 static const short yytable[] = {   115,
 327    136,   171,   171,   140,   172,   172,   173,   173,    36,   154,
 328     93,    25,   155,    51,   169,     2,   135,     3,    69,    12,
 329     94,    14,   153,    70,    71,     1,    72,    73,    74,    75,
 330     44,    67,    50,    26,   141,    52,   136,   142,   174,   174,
 331     28,    29,    30,    31,    32,    33,    34,     5,    50,   165,
 332    166,   167,   175,   182,   154,   159,   156,   157,   158,    76,
 333    146,   135,   111,    69,    77,    27,    78,   160,    70,    71,
 334     53,    72,    73,    74,    75,   122,    86,    47,   123,   112,
 335    124,    15,    16,    17,    56,    28,    29,    30,    31,    32,
 336     33,    34,    69,    60,    61,    62,   177,    70,    71,   178,
 337     72,    73,    74,    75,    76,   152,   153,    87,    18,    77,
 338    125,    78,   126,    14,    28,    29,    30,    31,    32,    33,
 339     34,   117,   118,   127,   128,   129,   108,   109,   110,    15,
 340     16,    17,    63,    76,    64,     2,   101,     3,    77,   179,
 341     78,    48,   142,     4,   102,   103,   104,   105,    57,    28,
 342     29,    30,    31,    32,    33,    34,    18,    58,   180,   181,
 343     65,   142,   142,   142,    59,   163,    66,     5,    54,    55,
 344     89,    90,    68,    92,    91,    99,   100,    95,    97,    96,
 345    113,   137,   114,   139,   138,   143,   144,   161,   147,   150,
 346    145,   187,   183,   184,   185,   148,   188,    11,    46,    88,
 347    116,   168,   164,   149,   170,   176
 348 };
 349 
 350 static const short yycheck[] = {    69,
 351     80,    11,    11,    97,    14,    14,    16,    16,    12,   131,
 352     35,     4,    12,     4,    47,    14,     3,    16,     5,    24,
 353     45,     3,    55,    10,    11,    23,    13,    14,    15,    16,
 354     25,    35,     3,    26,    47,    26,   116,    50,    48,    48,
 355     27,    28,    29,    30,    31,    32,    33,    46,     3,   143,
 356    144,   145,    62,    62,   176,   135,    56,    57,    58,    46,
 357     47,     3,    19,     5,    51,    47,    53,   137,    10,    11,
 358     48,    13,    14,    15,    16,    11,    47,    18,    14,    36,
 359     16,    19,    20,    21,     7,    27,    28,    29,    30,    31,
 360     32,    33,     5,     7,     8,     9,    47,    10,    11,    50,
 361     13,    14,    15,    16,    46,    54,    55,    48,    46,    51,
 362     46,    53,    48,     3,    27,    28,    29,    30,    31,    32,
 363     33,    17,    18,    59,    60,    61,    38,    39,    40,    19,
 364     20,    21,    46,    46,    48,    14,    34,    16,    51,    47,
 365     53,    41,    50,    22,    42,    43,    44,    45,     7,    27,
 366     28,    29,    30,    31,    32,    33,    46,     7,    47,    47,
 367      7,    50,    50,    50,    48,    52,     7,    46,    25,    26,
 368     51,    52,    49,    45,    20,    61,    62,    45,    51,    37,
 369     45,     4,    49,    46,     6,    46,    46,    14,    52,    59,
 370     46,     0,    63,    14,    14,    50,     0,     5,    14,    50,
 371     76,   148,   142,   125,   150,   153
 372 };
 373 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 374 #line 3 "/usr/local/share/bison.simple"
 375 /* This file comes from bison-1.28.  */
 376 
 377 /* Skeleton output parser for bison,
 378    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 379 
 380    This program is free software; you can redistribute it and/or modify
 381    it under the terms of the GNU General Public License as published by
 382    the Free Software Foundation; either version 2, or (at your option)
 383    any later version.
 384 
 385    This program is distributed in the hope that it will be useful,
 386    but WITHOUT ANY WARRANTY; without even the implied warranty of
 387    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 388    GNU General Public License for more details.
 389 
 390    You should have received a copy of the GNU General Public License
 391    along with this program; if not, write to the Free Software
 392    Foundation, Inc., 59 Temple Place - Suite 330,
 393    Boston, MA 02111-1307, USA.  */
 394 
 395 /* As a special exception, when this file is copied by Bison into a
 396    Bison output file, you may use that output file without restriction.
 397    This special exception was added by the Free Software Foundation
 398    in version 1.24 of Bison.  */
 399 
 400 /* This is the parser code that is written into each bison parser
 401   when the %semantic_parser declaration is not specified in the grammar.
 402   It was written by Richard Stallman by simplifying the hairy parser
 403   used when %semantic_parser is specified.  */
 404 
 405 #ifndef YYSTACK_USE_ALLOCA
 406 #ifdef alloca
 407 #define YYSTACK_USE_ALLOCA
 408 #else /* alloca not defined */
 409 #ifdef __GNUC__
 410 #define YYSTACK_USE_ALLOCA
 411 #define alloca __builtin_alloca
 412 #else /* not GNU C.  */
 413 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
 414 #define YYSTACK_USE_ALLOCA
 415 #include <alloca.h>
 416 #else /* not sparc */
 417 /* We think this test detects Watcom and Microsoft C.  */
 418 /* This used to test MSDOS, but that is a bad idea
 419    since that symbol is in the user namespace.  */
 420 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
 421 #if 0 /* No need for malloc.h, which pollutes the namespace;
 422          instead, just don't use alloca.  */
 423 #include <malloc.h>
 424 #endif
 425 #else /* not MSDOS, or __TURBOC__ */
 426 #if defined(_AIX)
 427 /* I don't know what this was needed for, but it pollutes the namespace.
 428    So I turned it off.   rms, 2 May 1997.  */
 429 /* #include <malloc.h>  */
 430  #pragma alloca
 431 #define YYSTACK_USE_ALLOCA
 432 #else /* not MSDOS, or __TURBOC__, or _AIX */
 433 #if 0
 434 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
 435                  and on HPUX 10.  Eventually we can turn this on.  */
 436 #define YYSTACK_USE_ALLOCA
 437 #define alloca __builtin_alloca
 438 #endif /* __hpux */
 439 #endif
 440 #endif /* not _AIX */
 441 #endif /* not MSDOS, or __TURBOC__ */
 442 #endif /* not sparc */
 443 #endif /* not GNU C */
 444 #endif /* alloca not defined */
 445 #endif /* YYSTACK_USE_ALLOCA not defined */
 446 
 447 #ifdef YYSTACK_USE_ALLOCA
 448 #define YYSTACK_ALLOC alloca
 449 #else
 450 #define YYSTACK_ALLOC malloc
 451 #endif
 452 
 453 /* Note: there must be only one dollar sign in this file.
 454    It is replaced by the list of actions, each action
 455    as one case of the switch.  */
 456 
 457 #define yyerrok         (yyerrstatus = 0)
 458 #define yyclearin       (yychar = YYEMPTY)
 459 #define YYEMPTY         -2
 460 #define YYEOF           0
 461 #define YYACCEPT        goto yyacceptlab
 462 #define YYABORT         goto yyabortlab
 463 #define YYERROR         goto yyerrlab1
 464 /* Like YYERROR except do call yyerror.
 465    This remains here temporarily to ease the
 466    transition to the new meaning of YYERROR, for GCC.
 467    Once GCC version 2 has supplanted version 1, this can go.  */
 468 #define YYFAIL          goto yyerrlab
 469 #define YYRECOVERING()  (!!yyerrstatus)
     /* [<][>][^][v][top][bottom][index][help] */
 470 #define YYBACKUP(token, value) \
     /* [<][>][^][v][top][bottom][index][help] */
 471 do                                                              \
 472   if (yychar == YYEMPTY && yylen == 1)                          \
 473     { yychar = (token), yylval = (value);                       \
 474       yychar1 = YYTRANSLATE (yychar);                           \
 475       YYPOPSTACK;                                               \
 476       goto yybackup;                                            \
 477     }                                                           \
 478   else                                                          \
 479     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
 480 while (0)
 481 
 482 #define YYTERROR        1
 483 #define YYERRCODE       256
 484 
 485 #ifndef YYPURE
 486 #define YYLEX           yylex()
 487 #endif
 488 
 489 #ifdef YYPURE
 490 #ifdef YYLSP_NEEDED
 491 #ifdef YYLEX_PARAM
 492 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
 493 #else
 494 #define YYLEX           yylex(&yylval, &yylloc)
 495 #endif
 496 #else /* not YYLSP_NEEDED */
 497 #ifdef YYLEX_PARAM
 498 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
 499 #else
 500 #define YYLEX           yylex(&yylval)
 501 #endif
 502 #endif /* not YYLSP_NEEDED */
 503 #endif
 504 
 505 /* If nonreentrant, generate the variables here */
 506 
 507 #ifndef YYPURE
 508 
 509 int     yychar;                 /*  the lookahead symbol                */
 510 YYSTYPE yylval;                 /*  the semantic value of the           */
 511                                 /*  lookahead symbol                    */
 512 
 513 #ifdef YYLSP_NEEDED
 514 YYLTYPE yylloc;                 /*  location data for the lookahead     */
 515                                 /*  symbol                              */
 516 #endif
 517 
 518 int yynerrs;                    /*  number of parse errors so far       */
 519 #endif  /* not YYPURE */
 520 
 521 #if YYDEBUG != 0
 522 int yydebug;                    /*  nonzero means print parse trace     */
 523 /* Since this is uninitialized, it does not stop multiple parsers
 524    from coexisting.  */
 525 #endif
 526 
 527 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
 528 
 529 #ifndef YYINITDEPTH
 530 #define YYINITDEPTH 200
 531 #endif
 532 
 533 /*  YYMAXDEPTH is the maximum size the stacks can grow to
 534     (effective only if the built-in stack extension method is used).  */
 535 
 536 #if YYMAXDEPTH == 0
 537 #undef YYMAXDEPTH
 538 #endif
 539 
 540 #ifndef YYMAXDEPTH
 541 #define YYMAXDEPTH 10000
 542 #endif
 543 
 544 /* Define __yy_memcpy.  Note that the size argument
 545    should be passed with type unsigned int, because that is what the non-GCC
 546    definitions require.  With GCC, __builtin_memcpy takes an arg
 547    of type size_t, but it can handle unsigned int.  */
 548 
 549 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
 550 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
     /* [<][>][^][v][top][bottom][index][help] */
 551 #else                           /* not GNU C or C++ */
 552 #ifndef __cplusplus
 553 
 554 /* This is the most reliable way to avoid incompatibilities
 555    in available built-in functions on various systems.  */
 556 static void
 557 __yy_memcpy (to, from, count)
     /* [<][>][^][v][top][bottom][index][help] */
 558      char *to;
 559      char *from;
 560      unsigned int count;
 561 {
 562   register char *f = from;
 563   register char *t = to;
 564   register int i = count;
 565 
 566   while (i-- > 0)
 567     *t++ = *f++;
 568 }
 569 
 570 #else /* __cplusplus */
 571 
 572 /* This is the most reliable way to avoid incompatibilities
 573    in available built-in functions on various systems.  */
 574 static void
 575 __yy_memcpy (char *to, char *from, unsigned int count)
     /* [<][>][^][v][top][bottom][index][help] */
 576 {
 577   register char *t = to;
 578   register char *f = from;
 579   register int i = count;
 580 
 581   while (i-- > 0)
 582     *t++ = *f++;
 583 }
 584 
 585 #endif
 586 #endif
 587 
 588 #line 217 "/usr/local/share/bison.simple"
 589 
 590 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 591    into yyparse.  The argument should have type void *.
 592    It should actually point to an object.
 593    Grammar actions can access the variable by casting it
 594    to the proper pointer type.  */
 595 
 596 #ifdef YYPARSE_PARAM
 597 #ifdef __cplusplus
 598 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 599 #define YYPARSE_PARAM_DECL
 600 #else /* not __cplusplus */
 601 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
 602 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 603 #endif /* not __cplusplus */
 604 #else /* not YYPARSE_PARAM */
 605 #define YYPARSE_PARAM_ARG
 606 #define YYPARSE_PARAM_DECL
 607 #endif /* not YYPARSE_PARAM */
 608 
 609 /* Prevent warning if -Wstrict-prototypes.  */
 610 #ifdef __GNUC__
 611 #ifdef YYPARSE_PARAM
 612 int yyparse (void *);
 613 #else
 614 int yyparse (void);
 615 #endif
 616 #endif
 617 
 618 int
 619 yyparse(YYPARSE_PARAM_ARG)
     /* [<][>][^][v][top][bottom][index][help] */
 620      YYPARSE_PARAM_DECL
 621 {
 622   register int yystate;
 623   register int yyn;
 624   register short *yyssp;
 625   register YYSTYPE *yyvsp;
 626   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
 627   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
 628 
 629   short yyssa[YYINITDEPTH];     /*  the state stack                     */
 630   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
 631 
 632   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
 633   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
 634 
 635 #ifdef YYLSP_NEEDED
 636   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
 637   YYLTYPE *yyls = yylsa;
 638   YYLTYPE *yylsp;
 639 
 640 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 641 #else
 642 #define YYPOPSTACK   (yyvsp--, yyssp--)
 643 #endif
 644 
 645   int yystacksize = YYINITDEPTH;
 646   int yyfree_stacks = 0;
 647 
 648 #ifdef YYPURE
 649   int yychar;
 650   YYSTYPE yylval;
 651   int yynerrs;
 652 #ifdef YYLSP_NEEDED
 653   YYLTYPE yylloc;
 654 #endif
 655 #endif
 656 
 657   YYSTYPE yyval;                /*  the variable used to return         */
 658                                 /*  semantic values from the action     */
 659                                 /*  routines                            */
 660 
 661   int yylen;
 662 
 663 #if YYDEBUG != 0
 664   if (yydebug)
 665     fprintf(stderr, "Starting parse\n");
 666 #endif
 667 
 668   yystate = 0;
 669   yyerrstatus = 0;
 670   yynerrs = 0;
 671   yychar = YYEMPTY;             /* Cause a token to be read.  */
 672 
 673   /* Initialize stack pointers.
 674      Waste one element of value and location stack
 675      so that they stay on the same level as the state stack.
 676      The wasted elements are never initialized.  */
 677 
 678   yyssp = yyss - 1;
 679   yyvsp = yyvs;
 680 #ifdef YYLSP_NEEDED
 681   yylsp = yyls;
 682 #endif
 683 
 684 /* Push a new state, which is found in  yystate  .  */
 685 /* In all cases, when you get here, the value and location stacks
 686    have just been pushed. so pushing a state here evens the stacks.  */
 687 yynewstate:
 688 
 689   *++yyssp = yystate;
 690 
 691   if (yyssp >= yyss + yystacksize - 1)
 692     {
 693       /* Give user a chance to reallocate the stack */
 694       /* Use copies of these so that the &'s don't force the real ones into memory. */
 695       YYSTYPE *yyvs1 = yyvs;
 696       short *yyss1 = yyss;
 697 #ifdef YYLSP_NEEDED
 698       YYLTYPE *yyls1 = yyls;
 699 #endif
 700 
 701       /* Get the current used size of the three stacks, in elements.  */
 702       int size = yyssp - yyss + 1;
 703 
 704 #ifdef yyoverflow
 705       /* Each stack pointer address is followed by the size of
 706          the data in use in that stack, in bytes.  */
 707 #ifdef YYLSP_NEEDED
 708       /* This used to be a conditional around just the two extra args,
 709          but that might be undefined if yyoverflow is a macro.  */
 710       yyoverflow("parser stack overflow",
 711                  &yyss1, size * sizeof (*yyssp),
 712                  &yyvs1, size * sizeof (*yyvsp),
 713                  &yyls1, size * sizeof (*yylsp),
 714                  &yystacksize);
 715 #else
 716       yyoverflow("parser stack overflow",
 717                  &yyss1, size * sizeof (*yyssp),
 718                  &yyvs1, size * sizeof (*yyvsp),
 719                  &yystacksize);
 720 #endif
 721 
 722       yyss = yyss1; yyvs = yyvs1;
 723 #ifdef YYLSP_NEEDED
 724       yyls = yyls1;
 725 #endif
 726 #else /* no yyoverflow */
 727       /* Extend the stack our own way.  */
 728       if (yystacksize >= YYMAXDEPTH)
 729         {
 730           yyerror("parser stack overflow");
 731           if (yyfree_stacks)
 732             {
 733               free (yyss);
 734               free (yyvs);
 735 #ifdef YYLSP_NEEDED
 736               free (yyls);
 737 #endif
 738             }
 739           return 2;
 740         }
 741       yystacksize *= 2;
 742       if (yystacksize > YYMAXDEPTH)
 743         yystacksize = YYMAXDEPTH;
 744 #ifndef YYSTACK_USE_ALLOCA
 745       yyfree_stacks = 1;
 746 #endif
 747       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
 748       __yy_memcpy ((char *)yyss, (char *)yyss1,
 749                    size * (unsigned int) sizeof (*yyssp));
 750       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
 751       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
 752                    size * (unsigned int) sizeof (*yyvsp));
 753 #ifdef YYLSP_NEEDED
 754       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
 755       __yy_memcpy ((char *)yyls, (char *)yyls1,
 756                    size * (unsigned int) sizeof (*yylsp));
 757 #endif
 758 #endif /* no yyoverflow */
 759 
 760       yyssp = yyss + size - 1;
 761       yyvsp = yyvs + size - 1;
 762 #ifdef YYLSP_NEEDED
 763       yylsp = yyls + size - 1;
 764 #endif
 765 
 766 #if YYDEBUG != 0
 767       if (yydebug)
 768         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
 769 #endif
 770 
 771       if (yyssp >= yyss + yystacksize - 1)
 772         YYABORT;
 773     }
 774 
 775 #if YYDEBUG != 0
 776   if (yydebug)
 777     fprintf(stderr, "Entering state %d\n", yystate);
 778 #endif
 779 
 780   goto yybackup;
 781  yybackup:
 782 
 783 /* Do appropriate processing given the current state.  */
 784 /* Read a lookahead token if we need one and don't already have one.  */
 785 /* yyresume: */
 786 
 787   /* First try to decide what to do without reference to lookahead token.  */
 788 
 789   yyn = yypact[yystate];
 790   if (yyn == YYFLAG)
 791     goto yydefault;
 792 
 793   /* Not known => get a lookahead token if don't already have one.  */
 794 
 795   /* yychar is either YYEMPTY or YYEOF
 796      or a valid token in external form.  */
 797 
 798   if (yychar == YYEMPTY)
 799     {
 800 #if YYDEBUG != 0
 801       if (yydebug)
 802         fprintf(stderr, "Reading a token: ");
 803 #endif
 804       yychar = YYLEX;
 805     }
 806 
 807   /* Convert token to internal form (in yychar1) for indexing tables with */
 808 
 809   if (yychar <= 0)              /* This means end of input. */
 810     {
 811       yychar1 = 0;
 812       yychar = YYEOF;           /* Don't call YYLEX any more */
 813 
 814 #if YYDEBUG != 0
 815       if (yydebug)
 816         fprintf(stderr, "Now at end of input.\n");
 817 #endif
 818     }
 819   else
 820     {
 821       yychar1 = YYTRANSLATE(yychar);
 822 
 823 #if YYDEBUG != 0
 824       if (yydebug)
 825         {
 826           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
 827           /* Give the individual parser a way to print the precise meaning
 828              of a token, for further debugging info.  */
 829 #ifdef YYPRINT
 830           YYPRINT (stderr, yychar, yylval);
 831 #endif
 832           fprintf (stderr, ")\n");
 833         }
 834 #endif
 835     }
 836 
 837   yyn += yychar1;
 838   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 839     goto yydefault;
 840 
 841   yyn = yytable[yyn];
 842 
 843   /* yyn is what to do for this token type in this state.
 844      Negative => reduce, -yyn is rule number.
 845      Positive => shift, yyn is new state.
 846        New state is final state => don't bother to shift,
 847        just return success.
 848      0, or most negative number => error.  */
 849 
 850   if (yyn < 0)
 851     {
 852       if (yyn == YYFLAG)
 853         goto yyerrlab;
 854       yyn = -yyn;
 855       goto yyreduce;
 856     }
 857   else if (yyn == 0)
 858     goto yyerrlab;
 859 
 860   if (yyn == YYFINAL)
 861     YYACCEPT;
 862 
 863   /* Shift the lookahead token.  */
 864 
 865 #if YYDEBUG != 0
 866   if (yydebug)
 867     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
 868 #endif
 869 
 870   /* Discard the token being shifted unless it is eof.  */
 871   if (yychar != YYEOF)
 872     yychar = YYEMPTY;
 873 
 874   *++yyvsp = yylval;
 875 #ifdef YYLSP_NEEDED
 876   *++yylsp = yylloc;
 877 #endif
 878 
 879   /* count tokens shifted since error; after three, turn off error status.  */
 880   if (yyerrstatus) yyerrstatus--;
 881 
 882   yystate = yyn;
 883   goto yynewstate;
 884 
 885 /* Do the default action for the current state.  */
 886 yydefault:
 887 
 888   yyn = yydefact[yystate];
 889   if (yyn == 0)
 890     goto yyerrlab;
 891 
 892 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
 893 yyreduce:
 894   yylen = yyr2[yyn];
 895   if (yylen > 0)
 896     yyval = yyvsp[1-yylen]; /* implement default value of the action */
 897 
 898 #if YYDEBUG != 0
 899   if (yydebug)
 900     {
 901       int i;
 902 
 903       fprintf (stderr, "Reducing via rule %d (line %d), ",
 904                yyn, yyrline[yyn]);
 905 
 906       /* Print the symbols being reduced, and their result.  */
 907       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
 908         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
 909       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 910     }
 911 #endif
 912 
 913 
 914   switch (yyn) {
 915 
 916 case 29:
 917 #line 100 "default.y"
 918 {
 919     if (strlen(yyvsp[0].sval) > 255) {
 920         syntax_error("Domain name \"%s\" is longer than 255 characters", yyvsp[0].sval);
 921     }
 922 ;
 923     break;}
 924 case 42:
 925 #line 125 "default.y"
 926 {
 927       long int val;
 928       char *s, *p;
 929       p = yyvsp[0].sval;
 930       val = strtol(p, &s, 10);
 931       if ((val < 0) || (val > 65535)) {
 932           syntax_error("pref value \"%s\" is not between 0 and 65535", p);
 933       }
 934 ;
 935     break;}
 936 case 43:
 937 #line 136 "default.y"
 938 {
 939       long int val;
 940       char *s, *p;
 941       p = yyvsp[0].sval;
 942       val = strtol(p, &s, 10);
 943       if ((val < 0) || (val > 65535)) {
 944           syntax_error("med value \"%s\" is not between 0 and 65535", p);
 945       }
 946 ;
 947     break;}
 948 case 45:
 949 #line 148 "default.y"
 950 {
 951       long int val;
 952       char *s, *p;
 953       p = yyvsp[0].sval;
 954       val = strtol(p, &s, 10);
 955       if ((val < 0) || (val > 65535)) {
 956           syntax_error("dpa value \"%s\" is not between 0 and 65535", p);
 957       }
 958 ;
 959     break;}
 960 case 62:
 961 #line 185 "default.y"
 962 {
 963       unsigned long int val;
 964       char *s, *p;
 965       p = yyvsp[0].sval;
 966       val = strtoul(p, &s, 10);
 967       if ((val < 1) || (val > 4294967295UL) || (*s != '\0')) {
 968           syntax_error("community element \"%s\" is not between 1 and 4294967295", 
 969                        p);
 970       }
 971 ;
 972     break;}
 973 case 66:
 974 #line 202 "default.y"
 975 {
 976       long int val;
 977       char *s, *p;
 978       p = yyvsp[0].sval;
 979       val = strtol(p, &s, 10);
 980       if ((val < 0) || (val > 65535)) {
 981           syntax_error("cost value \"%s\" is not between 0 and 65535", p);
 982       }
 983 ;
 984     break;}
 985 }
 986    /* the action file gets copied in in place of this dollarsign */
 987 #line 543 "/usr/local/share/bison.simple"
 988 
 989   yyvsp -= yylen;
 990   yyssp -= yylen;
 991 #ifdef YYLSP_NEEDED
 992   yylsp -= yylen;
 993 #endif
 994 
 995 #if YYDEBUG != 0
 996   if (yydebug)
 997     {
 998       short *ssp1 = yyss - 1;
 999       fprintf (stderr, "state stack now");
1000       while (ssp1 != yyssp)
1001         fprintf (stderr, " %d", *++ssp1);
1002       fprintf (stderr, "\n");
1003     }
1004 #endif
1005 
1006   *++yyvsp = yyval;
1007 
1008 #ifdef YYLSP_NEEDED
1009   yylsp++;
1010   if (yylen == 0)
1011     {
1012       yylsp->first_line = yylloc.first_line;
1013       yylsp->first_column = yylloc.first_column;
1014       yylsp->last_line = (yylsp-1)->last_line;
1015       yylsp->last_column = (yylsp-1)->last_column;
1016       yylsp->text = 0;
1017     }
1018   else
1019     {
1020       yylsp->last_line = (yylsp+yylen-1)->last_line;
1021       yylsp->last_column = (yylsp+yylen-1)->last_column;
1022     }
1023 #endif
1024 
1025   /* Now "shift" the result of the reduction.
1026      Determine what state that goes to,
1027      based on the state we popped back to
1028      and the rule number reduced by.  */
1029 
1030   yyn = yyr1[yyn];
1031 
1032   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1033   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1034     yystate = yytable[yystate];
1035   else
1036     yystate = yydefgoto[yyn - YYNTBASE];
1037 
1038   goto yynewstate;
1039 
1040 yyerrlab:   /* here on detecting error */
1041 
1042   if (! yyerrstatus)
1043     /* If not already recovering from an error, report this error.  */
1044     {
1045       ++yynerrs;
1046 
1047 #ifdef YYERROR_VERBOSE
1048       yyn = yypact[yystate];
1049 
1050       if (yyn > YYFLAG && yyn < YYLAST)
1051         {
1052           int size = 0;
1053           char *msg;
1054           int x, count;
1055 
1056           count = 0;
1057           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
1058           for (x = (yyn < 0 ? -yyn : 0);
1059                x < (sizeof(yytname) / sizeof(char *)); x++)
1060             if (yycheck[x + yyn] == x)
1061               size += strlen(yytname[x]) + 15, count++;
1062           msg = (char *) malloc(size + 15);
1063           if (msg != 0)
1064             {
1065               strcpy(msg, "parse error");
1066 
1067               if (count < 5)
1068                 {
1069                   count = 0;
1070                   for (x = (yyn < 0 ? -yyn : 0);
1071                        x < (sizeof(yytname) / sizeof(char *)); x++)
1072                     if (yycheck[x + yyn] == x)
1073                       {
1074                         strcat(msg, count == 0 ? ", expecting `" : " or `");
1075                         strcat(msg, yytname[x]);
1076                         strcat(msg, "'");
1077                         count++;
1078                       }
1079                 }
1080               yyerror(msg);
1081               free(msg);
1082             }
1083           else
1084             yyerror ("parse error; also virtual memory exceeded");
1085         }
1086       else
1087 #endif /* YYERROR_VERBOSE */
1088         yyerror("parse error");
1089     }
1090 
1091   goto yyerrlab1;
1092 yyerrlab1:   /* here on error raised explicitly by an action */
1093 
1094   if (yyerrstatus == 3)
1095     {
1096       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
1097 
1098       /* return failure if at end of input */
1099       if (yychar == YYEOF)
1100         YYABORT;
1101 
1102 #if YYDEBUG != 0
1103       if (yydebug)
1104         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1105 #endif
1106 
1107       yychar = YYEMPTY;
1108     }
1109 
1110   /* Else will try to reuse lookahead token
1111      after shifting the error token.  */
1112 
1113   yyerrstatus = 3;              /* Each real token shifted decrements this */
1114 
1115   goto yyerrhandle;
1116 
1117 yyerrdefault:  /* current state does not do anything special for the error token. */
1118 
1119 #if 0
1120   /* This is wrong; only states that explicitly want error tokens
1121      should shift them.  */
1122   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
1123   if (yyn) goto yydefault;
1124 #endif
1125 
1126 yyerrpop:   /* pop the current state because it cannot handle the error token */
1127 
1128   if (yyssp == yyss) YYABORT;
1129   yyvsp--;
1130   yystate = *--yyssp;
1131 #ifdef YYLSP_NEEDED
1132   yylsp--;
1133 #endif
1134 
1135 #if YYDEBUG != 0
1136   if (yydebug)
1137     {
1138       short *ssp1 = yyss - 1;
1139       fprintf (stderr, "Error: state stack now");
1140       while (ssp1 != yyssp)
1141         fprintf (stderr, " %d", *++ssp1);
1142       fprintf (stderr, "\n");
1143     }
1144 #endif
1145 
1146 yyerrhandle:
1147 
1148   yyn = yypact[yystate];
1149   if (yyn == YYFLAG)
1150     goto yyerrdefault;
1151 
1152   yyn += YYTERROR;
1153   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1154     goto yyerrdefault;
1155 
1156   yyn = yytable[yyn];
1157   if (yyn < 0)
1158     {
1159       if (yyn == YYFLAG)
1160         goto yyerrpop;
1161       yyn = -yyn;
1162       goto yyreduce;
1163     }
1164   else if (yyn == 0)
1165     goto yyerrpop;
1166 
1167   if (yyn == YYFINAL)
1168     YYACCEPT;
1169 
1170 #if YYDEBUG != 0
1171   if (yydebug)
1172     fprintf(stderr, "Shifting error token, ");
1173 #endif
1174 
1175   *++yyvsp = yylval;
1176 #ifdef YYLSP_NEEDED
1177   *++yylsp = yylloc;
1178 #endif
1179 
1180   yystate = yyn;
1181   goto yynewstate;
1182 
1183  yyacceptlab:
1184   /* YYACCEPT comes here.  */
1185   if (yyfree_stacks)
1186     {
1187       free (yyss);
1188       free (yyvs);
1189 #ifdef YYLSP_NEEDED
1190       free (yyls);
1191 #endif
1192     }
1193   return 0;
1194 
1195  yyabortlab:
1196   /* YYABORT comes here.  */
1197   if (yyfree_stacks)
1198     {
1199       free (yyss);
1200       free (yyvs);
1201 #ifdef YYLSP_NEEDED
1202       free (yyls);
1203 #endif
1204     }
1205   return 1;
1206 }
1207 #line 294 "default.y"
1208 
1209 
1210 #undef defaulterror
1211 #undef yyerror
1212 
1213 int
1214 defaulterror (const char *s)
     /* [<][>][^][v][top][bottom][index][help] */
1215 {
1216     yyerror(s);
1217     return 0;
1218 }
1219 

/* [<][>][^][v][top][bottom][index][help] */