Source File rpsl/components.tab.c

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