Source File rpsl/default.tab.c

    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)
    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)
    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)
    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)
    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)
    1215 | {
    1216 |     yyerror(s);
    1217 |     return 0;
    1218 | }
    1219 |