## modules/rpsl/inject.tab.c

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

## FUNCTIONS

This source file includes following functions.

1. YYTRANSLATE
2. YYRECOVERING
3. YYBACKUP
4. __yy_memcpy
5. __yy_memcpy
6. __yy_memcpy
7. yyparse
8. injecterror

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

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