## modules/rpsl/filter.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. filtererror
6. yyerror
7. syntax_error
8. yywrap
9. yy_input
10. main

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

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