## modules/rpsl/components.tab.c

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

## DEFINITIONS

This source file includes following functions.

1. YYSTYPE
2. __yy_memcpy
3. __yy_memcpy
4. yyparse
5. componentserror
6. yyerror
7. syntax_error
8. yywrap
9. yy_input
10. main

       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;
         /* [<][>][^][v][top][bottom][index][help] */
      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)
         /* [<][>][^][v][top][bottom][index][help] */
     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)
         /* [<][>][^][v][top][bottom][index][help] */
     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)
         /* [<][>][^][v][top][bottom][index][help] */
     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)
         /* [<][>][^][v][top][bottom][index][help] */
    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)
         /* [<][>][^][v][top][bottom][index][help] */
    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, ...)
         /* [<][>][^][v][top][bottom][index][help] */
    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()
         /* [<][>][^][v][top][bottom][index][help] */
    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)
         /* [<][>][^][v][top][bottom][index][help] */
    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()
         /* [<][>][^][v][top][bottom][index][help] */
    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 */

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