## modules/rpsl/export.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. 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;
      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)
         /* [<][>][^][v][top][bottom][index][help] */
     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)
         /* [<][>][^][v][top][bottom][index][help] */
     494 #define YYBACKUP(token, value) \
         /* [<][>][^][v][top][bottom][index][help] */
     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)
         /* [<][>][^][v][top][bottom][index][help] */
     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] */