## modules/rpsl/default.tab.c

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

## DEFINITIONS

This source file includes following functions.

1. YYSTYPE
2. __yy_memcpy
3. __yy_memcpy
4. yyparse
5. 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;
         /* [<][>][^][v][top][bottom][index][help] */
      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)
     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)
     470 #define YYBACKUP(token, value) \
     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)
     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] */