modules/rpsl/export.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. exporterror

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

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