modules/up/src/rpsl/rpsl/rpsl.y.cc

/* [<][>]
[^][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. enable_yy_parser_debugging
  9. handleArgumentTypeError
  10. searchMethod


/*  A Bison parser, made from rpsl.y
 by  GNU Bison version 1.25
  */

#define YYBISON 1  /* Identify Bison output.  */

#define yyparse rpslparse
#define yylex rpsllex
#define yyerror rpslerror
#define yylval rpsllval
#define yychar rpslchar
#define yydebug rpsldebug
#define yynerrs rpslnerrs
#define KEYW_TRUE       258
#define KEYW_FALSE      259
#define KEYW_ACTION     260
#define KEYW_ACCEPT     261
#define KEYW_ANNOUNCE   262
#define KEYW_FROM       263
#define KEYW_TO 264
#define KEYW_AT 265
#define KEYW_ANY        266
#define KEYW_REFINE     267
#define KEYW_EXCEPT     268
#define KEYW_STATIC     269
#define KEYW_NETWORKS   270
#define KEYW_MASKLEN    271
#define KEYW_UNION      272
#define KEYW_RANGE      273
#define KEYW_LIST       274
#define KEYW_OF 275
#define KEYW_OPERATOR   276
#define KEYW_SYNTAX     277
#define KEYW_SPECIAL    278
#define KEYW_OPTIONAL   279
#define KEYW_MANDATORY  280
#define KEYW_INTERNAL   281
#define KEYW_SINGLEVALUED       282
#define KEYW_MULTIVALUED        283
#define KEYW_LOOKUP     284
#define KEYW_KEY        285
#define KEYW_DELETED    286
#define KEYW_GENERATED  287
#define KEYW_OBSOLETE   288
#define KEYW_PEERAS     289
#define KEYW_PROTOCOL   290
#define KEYW_INTO       291
#define KEYW_ATOMIC     292
#define KEYW_INBOUND    293
#define KEYW_OUTBOUND   294
#define KEYW_UPON       295
#define KEYW_HAVE_COMPONENTS    296
#define KEYW_EXCLUDE    297
#define KEYW_NONE       298
#define KEYW_MAILFROM   299
#define KEYW_CRYPTPW    300
#define KEYW_ASSIGNED   301
#define KEYW_ALLOCATED  302
#define KEYW_PI 303
#define KEYW_PA 304
#define KEYW_UNSPECIFIED        305
#define KEYW_EXT        306
#define KEYW_SIMPLE     307
#define KEYW_RIPE       308
#define KEYW_INTERNIC   309
#define KEYW_CLIENTADDRESS      310
#define TKN_ERROR       311
#define TKN_UNKNOWN_CLASS       312
#define TKN_EOA 313
#define TKN_EOO 314
#define TKN_FREETEXT    315
#define TKN_INT 316
#define TKN_REAL        317
#define TKN_STRING      318
#define TKN_TIMESTAMP   319
#define TKN_BLOB        320
#define TKN_IPV4        321
#define TKN_PRFXV6      322
#define TKN_PRFXV4      323
#define TKN_PRFXV4RNG   324
#define TKN_ASNO        325
#define TKN_ASNAME      326
#define TKN_RSNAME      327
#define TKN_RTRSNAME    328
#define TKN_PRNGNAME    329
#define TKN_FLTRNAME    330
#define TKN_BOOLEAN     331
#define TKN_WORD        332
#define TKN_RP_ATTR     333
#define TKN_DNS 334
#define TKN_EMAIL       335
#define TKN_3DOTS       336
#define TKN_NICHDL      337
#define TKN_KEYCRTNAME  338
#define TKN_CRYPTEDPW   339
#define ATTR_GENERIC    340
#define ATTR_BLOBS      341
#define ATTR_IMPORT     342
#define ATTR_EXPORT     343
#define ATTR_DEFAULT    344
#define ATTR_FREETEXT   345
#define ATTR_CHANGED    346
#define ATTR_IFADDR     347
#define ATTR_PEER       348
#define ATTR_INJECT     349
#define ATTR_COMPONENTS 350
#define ATTR_AGGR_MTD   351
#define ATTR_AGGR_BNDRY 352
#define ATTR_RS_MEMBERS 353
#define ATTR_RP_ATTR    354
#define ATTR_TYPEDEF    355
#define ATTR_PROTOCOL   356
#define ATTR_FILTER     357
#define ATTR_PEERING    358
#define ATTR_ATTR       359
#define ATTR_MNT_ROUTES 360
#define ATTR_NICHDL     361
#define ATTR_AUTH       362
#define ATTR_STATUS_INET        363
#define ATTR_PHONE      364
#define ATTR_SOURCE     365
#define ATTR_REFER      366
#define ATTR_COUNTRY    367
#define ATTR_PERSON     368
#define OP_OR   369
#define OP_AND  370
#define OP_NOT  371
#define OP_MS   372
#define TKN_OPERATOR    373

#line 1 "rpsl.y"

//  $Id: rpsl.y.cc,v 1.1.1.1 2000/03/10 16:32:24 engin Exp $
//
//  Copyright (c) 1994 by the University of Southern California
//  All rights reserved.
//
//  Permission to use, copy, modify, and distribute this software and its
//  documentation in source and binary forms for lawful non-commercial
//  purposes and without fee is hereby granted, provided that the above
//  copyright notice appear in all copies and that both the copyright
//  notice and this permission notice appear in supporting documentation,
//  and that any documentation, advertising materials, and other materials
//  related to such distribution and use acknowledge that the software was
//  developed by the University of Southern California, Information
//  Sciences Institute. The name of the USC may not be used to endorse or
//  promote products derived from this software without specific prior
//  written permission.
//
//  THE UNIVERSITY OF SOUTHERN CALIFORNIA DOES NOT MAKE ANY
//  REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR ANY
//  PURPOSE.  THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
//  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
//  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE,
//  TITLE, AND NON-INFRINGEMENT.
//
//  IN NO EVENT SHALL USC, OR ANY OTHER CONTRIBUTOR BE LIABLE FOR ANY
//  SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES, WHETHER IN CONTRACT, TORT,
//  OR OTHER FORM OF ACTION, ARISING OUT OF OR IN CONNECTION WITH, THE USE
//  OR PERFORMANCE OF THIS SOFTWARE.
//
//  Questions concerning this software should be directed to
//  ratoolset@isi.edu.
//
//  Author(s): Cengiz Alaettinoglu <cengiz@ISI.EDU>

#include "config.h"
#include "time.h"
#include "schema.hh"
#include "object.hh"
#include "regexp.hh"
#include "rptype.hh"

#ifdef DEBUG
#define YYDEBUG 1
#endif // DEBUG
#if YYDEBUG != 0
// stdio is needed for yydebug
#include <cstdio>
#endif

extern void handle_error(char *, ...);
extern void handle_object_error(char *, ...);
extern void handle_warning(char *, ...);
extern int yylex();
char *token_name(int token_id);
void rpslerror(char *s, ...);
Attr *changeCurrentAttr(Attr *b);
void handleArgumentTypeError(char *attr, char *method, int position,
                             const RPType *correctType, 
                             bool isOperator = false);
const AttrMethod *searchMethod(const AttrRPAttr *rp_attr, char *method, ItemList *args);

/* argument to yyparse result of parsing should be stored here */
#define YYPARSE_PARAM object    
#define yyschema schema
#define enable_yy_parser_debugging enable_rpsl_parser_debugging

extern Object *current_object;


#line 74 "rpsl.y"
typedef union {
   long long int      i;
   double             real;
   char              *string;
   void              *ptr;
   time_t             time;
   Item              *item;
   ItemList          *list;
   regexp            *re;
   SymID              sid;
   IPAddr            *ip;
   Prefix            *prfx;
   PrefixRange       *prfxrng;
   RPType            *typenode;

   Filter                    *filter;
   FilterMS                  *moreSpecOp;
   PolicyPeering             *peering;
   PolicyActionList          *actionList;
   PolicyAction              *actionNode;
   PolicyFactor              *policyFactor;
   PolicyTerm                *policyTerm;
   PolicyExpr                *policyExpr;
   List<PolicyPeeringAction> *peeringActionList;

   Attr               *attr;
   AttrAttr           *rpslattr;
   AttrMethod         *method;
   const AttrRPAttr   *rp_attr;
   const AttrProtocol *protocol;
   AttrProtocolOption *protocol_option;
   List<AttrProtocolOption> *protocol_option_list;

   AttrPeerOption       *peer_option;
   List<AttrPeerOption> *peer_option_list;

   List<RPTypeNode> *typelist;
   List<AttrMethod> *methodlist;
   List<WordNode>   *wordlist;

   List<AttrMntRoutes::MntPrfxPair> *listMntPrfxPair;
   AttrMntRoutes::MntPrfxPair       *mntPrfxPair;
} YYSTYPE;
#include <stdio.h>

#ifndef __cplusplus
#ifndef __STDC__
#define const
#endif
#endif



#define YYFINAL         739
#define YYFLAG          -32768
#define YYNTBASE        138

#define YYTRANSLATE(x) ((unsigned)(x) <= 373 ? yytranslate[x] : 262)
/* [<][>][^][v][top][bottom][index][help] */

static const short yytranslate[] = {     0,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,   137,     2,     2,     2,   120,
   121,   134,   119,   123,   124,   122,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,   125,   128,   131,
     2,   132,   135,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
   129,     2,   130,   136,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,   126,   133,   127,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
     6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
    16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
    36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
    46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
    56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
    66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
    76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
    86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
    96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
   106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
   116,   117,   118
};

#if YYDEBUG != 0
static const short yyprhs[] = {     0,
     0,     3,     6,     9,    11,    13,    15,    16,    18,    21,
    23,    25,    27,    29,    31,    33,    35,    37,    39,    41,
    43,    45,    47,    49,    51,    53,    55,    57,    59,    61,
    63,    65,    67,    69,    71,    73,    75,    77,    79,    82,
    85,    90,    94,    98,   102,   106,   111,   116,   120,   124,
   129,   134,   139,   144,   149,   153,   158,   168,   176,   188,
   192,   194,   197,   201,   205,   210,   216,   221,   227,   232,
   238,   243,   249,   253,   257,   261,   266,   270,   272,   275,
   278,   282,   286,   287,   289,   291,   295,   299,   303,   305,
   308,   310,   314,   316,   318,   320,   322,   324,   326,   328,
   330,   332,   336,   342,   346,   352,   354,   356,   358,   360,
   362,   364,   366,   368,   370,   372,   374,   376,   380,   384,
   386,   388,   390,   392,   394,   396,   398,   400,   402,   404,
   406,   408,   410,   412,   414,   416,   418,   420,   422,   424,
   426,   428,   430,   432,   434,   436,   438,   440,   442,   444,
   446,   448,   450,   452,   454,   456,   458,   460,   462,   464,
   466,   468,   470,   472,   474,   476,   478,   480,   482,   484,
   486,   488,   490,   492,   494,   496,   498,   500,   502,   504,
   506,   508,   510,   512,   513,   515,   519,   521,   525,   529,
   531,   535,   537,   539,   541,   542,   544,   545,   548,   552,
   554,   558,   562,   564,   568,   570,   572,   574,   576,   580,
   582,   583,   586,   588,   591,   599,   604,   610,   616,   618,
   622,   625,   627,   631,   633,   636,   640,   642,   644,   648,
   650,   652,   654,   657,   659,   661,   663,   665,   667,   671,
   672,   674,   676,   680,   682,   684,   688,   690,   693,   695,
   698,   701,   704,   706,   708,   710,   714,   716,   718,   720,
   722,   724,   728,   733,   734,   737,   740,   743,   748,   751,
   758,   762,   767,   772,   776,   781,   785,   790,   794,   797,
   801,   805,   808,   812,   815,   819,   822,   826,   828,   832,
   836,   838,   842,   846,   847,   850,   851,   854,   860,   866,
   870,   876,   882,   886,   887,   890,   897,   903,   907,   911,
   915,   919,   923,   930,   937,   943,   948,   952,   953,   955,
   957,   961,   966,   968,   970,   972,   974,   980,   986,   991,
   995,   999,  1003,  1007,  1012,  1017,  1022,  1026,  1027,  1030,
  1034,  1036,  1040,  1042,  1046,  1048,  1050,  1055,  1060,  1066,
  1070,  1071,  1073,  1074,  1076,  1081,  1086,  1090,  1091,  1093,
  1095,  1099,  1101,  1104,  1106,  1109,  1111,  1114,  1116,  1118,
  1122,  1126,  1131,  1136,  1140,  1142,  1145,  1149,  1154,  1161,
  1167,  1175,  1179,  1184,  1188,  1191,  1196,  1200,  1202,  1206,
  1209,  1213,  1215,  1222,  1229,  1234,  1243,  1247,  1252,  1254,
  1258,  1263,  1268,  1272,  1273,  1276,  1279,  1282,  1283,  1285,
  1287,  1291,  1295,  1300,  1307,  1309,  1311,  1313,  1315,  1317,
  1319,  1321,  1323,  1325,  1327,  1332,  1337,  1341,  1345,  1347,
  1351,  1353,  1356
};

static const short yyrhs[] = {   139,
    59,     0,    57,    59,     0,     1,    59,     0,   139,     0,
    57,     0,     1,     0,     0,   140,     0,   139,   140,     0,
   153,     0,   156,     0,   141,     0,   218,     0,   219,     0,
   221,     0,   229,     0,   224,     0,   240,     0,   237,     0,
   231,     0,   230,     0,   248,     0,   252,     0,   245,     0,
   244,     0,   222,     0,   223,     0,   258,     0,   152,     0,
   259,     0,   142,     0,   143,     0,   144,     0,   145,     0,
   147,     0,   148,     0,   149,     0,   150,     0,    56,    58,
     0,     1,    58,     0,    91,    80,    61,    58,     0,    91,
     1,    58,     0,   106,    82,    58,     0,   106,     1,    58,
     0,   107,   162,    58,     0,   107,   163,    80,    58,     0,
   107,   164,    84,    58,     0,   107,    83,    58,     0,   107,
     1,    58,     0,   108,   165,   167,    58,     0,   108,   165,
   168,    58,     0,   108,   166,   167,    58,     0,   108,   166,
   168,    58,     0,   108,   166,   169,    58,     0,   108,     1,
    58,     0,   109,   119,   146,    58,     0,   109,   119,   146,
   120,   146,   121,   146,    61,    58,     0,   109,   119,   146,
   170,   122,    61,    58,     0,   109,   119,   146,   120,   146,
   121,   146,   170,   122,    61,    58,     0,   109,     1,    58,
     0,    61,     0,   146,    61,     0,   110,   160,    58,     0,
   110,     1,    58,     0,   111,   171,    79,    58,     0,   111,
   171,    79,    61,    58,     0,   111,   172,    79,    58,     0,
   111,   172,    79,    61,    58,     0,   111,   173,    79,    58,
     0,   111,   173,    79,    61,    58,     0,   111,   174,    79,
    58,     0,   111,   174,    79,    61,    58,     0,   111,     1,
    58,     0,   112,   160,    58,     0,   112,     1,    58,     0,
   113,   160,   151,    58,     0,   113,     1,    58,     0,   160,
     0,   151,   160,     0,    90,    58,     0,    85,   154,    58,
     0,    85,     1,    58,     0,     0,   155,     0,   158,     0,
   155,   123,   158,     0,    86,   157,    58,     0,    86,     1,
    58,     0,   158,     0,   157,   158,     0,   159,     0,   159,
   124,   159,     0,    70,     0,    61,     0,    62,     0,    63,
     0,    64,     0,    66,     0,    68,     0,    67,     0,    69,
     0,    66,   125,    61,     0,    66,   125,    61,   125,    61,
     0,    79,   125,    61,     0,    79,   125,    61,   125,    61,
     0,    71,     0,    72,     0,    73,     0,    74,     0,    75,
     0,    76,     0,    77,     0,   161,     0,    79,     0,    80,
     0,    83,     0,    65,     0,   126,   154,   127,     0,   120,
   190,   121,     0,    77,     0,    70,     0,    71,     0,    72,
     0,    73,     0,    74,     0,    75,     0,    82,     0,    76,
     0,   161,     0,   172,     0,   173,     0,   171,     0,   174,
     0,     3,     0,     4,     0,     5,     0,     6,     0,     7,
     0,     8,     0,     9,     0,    10,     0,    11,     0,    12,
     0,    13,     0,    14,     0,    15,     0,    16,     0,    17,
     0,    18,     0,    19,     0,    20,     0,    21,     0,    22,
     0,    23,     0,    24,     0,    25,     0,    26,     0,    31,
     0,    27,     0,    32,     0,    28,     0,    29,     0,    30,
     0,    33,     0,    34,     0,    35,     0,    36,     0,    37,
     0,    38,     0,    39,     0,    43,     0,    44,     0,    45,
     0,    46,     0,    47,     0,    48,     0,    49,     0,    50,
     0,    51,     0,    52,     0,    53,     0,    54,     0,    55,
     0,     0,   176,     0,   176,   114,   177,     0,   177,     0,
   177,   115,   178,     0,   177,    13,   178,     0,   178,     0,
   120,   176,   121,     0,   179,     0,    70,     0,    71,     0,
     0,   182,     0,     0,    10,   182,     0,   182,   114,   183,
     0,   183,     0,   183,   115,   184,     0,   183,    13,   184,
     0,   184,     0,   120,   182,   121,     0,   185,     0,    66,
     0,    79,     0,    73,     0,   176,   180,   181,     0,    74,
     0,     0,     5,   188,     0,   189,     0,   188,   189,     0,
    78,   122,    77,   120,   154,   121,   128,     0,    78,   118,
   158,   128,     0,    78,   120,   154,   121,   128,     0,    78,
   129,   154,   130,   128,     0,   128,     0,   190,   114,   191,
     0,   190,   191,     0,   191,     0,   191,   115,   192,     0,
   192,     0,   116,   192,     0,   120,   190,   121,     0,   193,
     0,    11,     0,   131,   199,   132,     0,   205,     0,    75,
     0,   194,     0,   195,   117,     0,   195,     0,    70,     0,
    34,     0,    71,     0,    72,     0,   126,   196,   127,     0,
     0,   197,     0,   198,     0,   197,   123,   198,     0,    68,
     0,    69,     0,   199,   133,   200,     0,   200,     0,   200,
   201,     0,   201,     0,   201,   134,     0,   201,   135,     0,
   201,   119,     0,   202,     0,   136,     0,   137,     0,   120,
   199,   121,     0,   203,     0,    70,     0,    34,     0,    71,
     0,   122,     0,   129,   204,   130,     0,   129,   136,   204,
   130,     0,     0,   204,    70,     0,   204,    34,     0,   204,
   122,     0,   204,    70,   124,    70,     0,   204,    71,     0,
    78,   122,    77,   120,   154,   121,     0,    78,   118,   158,
     0,    78,   120,   154,   121,     0,    78,   129,   154,   130,
     0,     8,   186,   187,     0,   206,     8,   186,   187,     0,
     9,   186,   187,     0,   207,     9,   186,   187,     0,   206,
     6,   190,     0,   208,   128,     0,   209,   208,   128,     0,
   207,     7,   190,     0,   210,   128,     0,   211,   210,   128,
     0,   208,   128,     0,   126,   209,   127,     0,   210,   128,
     0,   126,   211,   127,     0,   212,     0,   212,    12,   214,
     0,   212,    13,   214,     0,   213,     0,   213,    12,   215,
     0,   213,    13,   215,     0,     0,    35,   160,     0,     0,
    36,   160,     0,    87,   216,   217,   214,    58,     0,    87,
   216,   217,   208,    58,     0,    87,     1,    58,     0,    88,
   216,   217,   215,    58,     0,    88,   216,   217,   210,    58,
     0,    88,     1,    58,     0,     0,    15,   190,     0,    89,
     9,   186,   187,   220,    58,     0,    89,     9,   186,     1,
    58,     0,    89,     1,    58,     0,   102,   190,    58,     0,
   102,     1,    58,     0,   103,   186,    58,     0,   103,     1,
    58,     0,    92,    66,    16,    61,   187,    58,     0,    92,
    66,    16,    61,     1,    58,     0,    92,    66,    16,     1,
    58,     0,    92,    66,     1,    58,     0,    92,     1,    58,
     0,     0,   226,     0,   227,     0,   226,   123,   227,     0,
   160,   120,   154,   121,     0,    66,     0,    79,     0,    73,
     0,    74,     0,    93,   160,   228,   225,    58,     0,    93,
   160,    66,     1,    58,     0,    93,   160,     1,    58,     0,
    93,     1,    58,     0,    97,   176,    58,     0,    97,     1,
    58,     0,    96,    38,    58,     0,    96,    39,   175,    58,
     0,    96,    39,     1,    58,     0,    96,    38,     1,    58,
     0,    96,     1,    58,     0,     0,    40,   233,     0,   233,
   114,   234,     0,   234,     0,   234,   115,   235,     0,   235,
     0,   120,   233,   121,     0,   236,     0,    14,     0,    41,
   126,   196,   127,     0,    42,   126,   196,   127,     0,    94,
   181,   187,   232,    58,     0,    94,     1,    58,     0,     0,
    37,     0,     0,   190,     0,   239,    35,   160,   190,     0,
    95,   238,   239,    58,     0,    95,     1,    58,     0,     0,
   242,     0,   243,     0,   242,   123,   243,     0,    70,     0,
    70,   117,     0,    71,     0,    71,   117,     0,    72,     0,
    72,   117,     0,    68,     0,    69,     0,    98,   241,    58,
     0,    98,     1,    58,     0,    99,    77,   246,    58,     0,
    99,    78,   246,    58,     0,    99,     1,    58,     0,   247,
     0,   246,   247,     0,    77,   120,   121,     0,    77,   120,
   249,   121,     0,    77,   120,   249,   123,    81,   121,     0,
    21,   118,   120,   249,   121,     0,    21,   118,   120,   249,
   123,    81,   121,     0,    77,     1,   121,     0,    21,   118,
     1,   121,     0,    21,     1,   121,     0,     1,   121,     0,
   100,    77,   250,    58,     0,   100,     1,    58,     0,   250,
     0,   249,   123,   250,     0,    17,   249,     0,    18,    20,
   250,     0,    77,     0,    77,   129,    61,   123,    61,   130,
     0,    77,   129,    62,   123,    62,   130,     0,    77,   129,
   251,   130,     0,    19,   129,    61,   125,    61,   130,    20,
   250,     0,    19,    20,   250,     0,    19,     1,    20,   250,
     0,   160,     0,   251,   123,   160,     0,   101,   160,   253,
    58,     0,   101,   160,     1,    58,     0,   101,     1,    58,
     0,     0,   253,   254,     0,    25,   247,     0,    24,   247,
     0,     0,   256,     0,   257,     0,   256,   123,   257,     0,
     1,   123,   257,     0,    22,   120,   250,   121,     0,    22,
   120,    23,   123,   160,   121,     0,    24,     0,    25,     0,
    31,     0,    27,     0,    28,     0,    29,     0,    30,     0,
    33,     0,    26,     0,    32,     0,   104,   160,   255,    58,
     0,   104,   160,     1,    58,     0,   104,     1,    58,     0,
   105,   260,    58,     0,   261,     0,   260,   123,   261,     0,
   160,     0,   160,    11,     0,   160,   126,   196,   127,     0
};

#endif

#if YYDEBUG != 0
static const short yyrline[] = { 0,
   385,   388,   391,   395,   398,   401,   405,   410,   413,   418,
   419,   420,   421,   422,   423,   424,   425,   426,   427,   428,
   429,   430,   431,   432,   433,   434,   435,   436,   437,   438,
   439,   440,   441,   442,   443,   444,   445,   446,   447,   451,
   460,   464,   471,   475,   480,   483,   487,   491,   495,   504,
   507,   510,   513,   516,   519,   525,   528,   531,   534,   537,
   543,   547,   551,   560,   565,   568,   571,   574,   577,   580,
   583,   586,   589,   594,   603,   608,   611,   616,   619,   624,
   635,   644,   653,   656,   659,   663,   669,   672,   680,   684,
   690,   693,   698,   701,   704,   707,   710,   713,   716,   719,
   723,   726,   729,   732,   735,   738,   741,   744,   747,   750,
   753,   756,   759,   762,   765,   768,   771,   774,   777,   782,
   785,   790,   793,   796,   799,   802,   805,   808,   814,   815,
   816,   817,   818,   821,   824,   827,   830,   833,   836,   839,
   842,   845,   848,   851,   854,   857,   860,   863,   866,   869,
   872,   875,   878,   881,   884,   887,   890,   893,   896,   899,
   902,   905,   908,   911,   914,   917,   920,   923,   926,   929,
   934,   938,   942,   946,   950,   954,   958,   962,   966,   970,
   974,   978,   982,   991,   994,   997,  1000,  1003,  1006,  1009,
  1012,  1015,  1018,  1021,  1028,  1031,  1036,  1039,  1044,  1047,
  1050,  1053,  1056,  1059,  1062,  1065,  1068,  1071,  1078,  1081,
  1088,  1091,  1096,  1101,  1108,  1118,  1132,  1141,  1150,  1157,
  1160,  1163,  1166,  1169,  1172,  1175,  1178,  1181,  1184,  1187,
  1193,  1196,  1199,  1203,  1206,  1209,  1212,  1215,  1218,  1223,
  1226,  1229,  1233,  1240,  1243,  1248,  1251,  1254,  1257,  1260,
  1263,  1266,  1269,  1272,  1275,  1278,  1281,  1284,  1287,  1290,
  1293,  1296,  1299,  1305,  1308,  1311,  1314,  1317,  1320,  1325,
  1335,  1349,  1358,  1371,  1375,  1381,  1385,  1393,  1398,  1402,
  1408,  1413,  1417,  1425,  1430,  1435,  1440,  1447,  1450,  1453,
  1458,  1461,  1464,  1471,  1474,  1484,  1487,  1499,  1504,  1510,
  1517,  1522,  1528,  1535,  1538,  1543,  1548,  1554,  1560,  1563,
  1570,  1573,  1582,  1586,  1592,  1598,  1604,  1613,  1616,  1621,
  1625,  1631,  1636,  1637,  1640,  1643,  1648,  1695,  1702,  1708,
  1717,  1721,  1728,  1731,  1734,  1739,  1744,  1753,  1756,  1761,
  1764,  1767,  1770,  1773,  1776,  1779,  1782,  1785,  1790,  1796,
  1805,  1806,  1809,  1811,  1814,  1820,  1823,  1832,  1835,  1838,
  1842,  1848,  1851,  1855,  1858,  1862,  1865,  1869,  1872,  1877,
  1880,  1889,  1892,  1895,  1902,  1907,  1914,  1917,  1920,  1923,
  1930,  1937,  1942,  1947,  1951,  1959,  1962,  1969,  1974,  1981,
  1988,  1995,  2002,  2009,  2016,  2024,  2035,  2042,  2049,  2053,
  2061,  2064,  2069,  2076,  2079,  2085,  2088,  2095,  2098,  2105,
  2108,  2113,  2119,  2122,  2131,  2134,  2137,  2140,  2143,  2146,
  2149,  2152,  2155,  2158,  2163,  2167,  2173,  2182,  2187,  2191,
  2197,  2200,  2203
};
#endif


#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)

static const char * const yytname[] = {   "$","error","$undefined.","KEYW_TRUE",
"KEYW_FALSE","KEYW_ACTION","KEYW_ACCEPT","KEYW_ANNOUNCE","KEYW_FROM","KEYW_TO",
"KEYW_AT","KEYW_ANY","KEYW_REFINE","KEYW_EXCEPT","KEYW_STATIC","KEYW_NETWORKS",
"KEYW_MASKLEN","KEYW_UNION","KEYW_RANGE","KEYW_LIST","KEYW_OF","KEYW_OPERATOR",
"KEYW_SYNTAX","KEYW_SPECIAL","KEYW_OPTIONAL","KEYW_MANDATORY","KEYW_INTERNAL",
"KEYW_SINGLEVALUED","KEYW_MULTIVALUED","KEYW_LOOKUP","KEYW_KEY","KEYW_DELETED",
"KEYW_GENERATED","KEYW_OBSOLETE","KEYW_PEERAS","KEYW_PROTOCOL","KEYW_INTO","KEYW_ATOMIC",
"KEYW_INBOUND","KEYW_OUTBOUND","KEYW_UPON","KEYW_HAVE_COMPONENTS","KEYW_EXCLUDE",
"KEYW_NONE","KEYW_MAILFROM","KEYW_CRYPTPW","KEYW_ASSIGNED","KEYW_ALLOCATED",
"KEYW_PI","KEYW_PA","KEYW_UNSPECIFIED","KEYW_EXT","KEYW_SIMPLE","KEYW_RIPE",
"KEYW_INTERNIC","KEYW_CLIENTADDRESS","TKN_ERROR","TKN_UNKNOWN_CLASS","TKN_EOA",
"TKN_EOO","TKN_FREETEXT","TKN_INT","TKN_REAL","TKN_STRING","TKN_TIMESTAMP","TKN_BLOB",
"TKN_IPV4","TKN_PRFXV6","TKN_PRFXV4","TKN_PRFXV4RNG","TKN_ASNO","TKN_ASNAME",
"TKN_RSNAME","TKN_RTRSNAME","TKN_PRNGNAME","TKN_FLTRNAME","TKN_BOOLEAN","TKN_WORD",
"TKN_RP_ATTR","TKN_DNS","TKN_EMAIL","TKN_3DOTS","TKN_NICHDL","TKN_KEYCRTNAME",
"TKN_CRYPTEDPW","ATTR_GENERIC","ATTR_BLOBS","ATTR_IMPORT","ATTR_EXPORT","ATTR_DEFAULT",
"ATTR_FREETEXT","ATTR_CHANGED","ATTR_IFADDR","ATTR_PEER","ATTR_INJECT","ATTR_COMPONENTS",
"ATTR_AGGR_MTD","ATTR_AGGR_BNDRY","ATTR_RS_MEMBERS","ATTR_RP_ATTR","ATTR_TYPEDEF",
"ATTR_PROTOCOL","ATTR_FILTER","ATTR_PEERING","ATTR_ATTR","ATTR_MNT_ROUTES","ATTR_NICHDL",
"ATTR_AUTH","ATTR_STATUS_INET","ATTR_PHONE","ATTR_SOURCE","ATTR_REFER","ATTR_COUNTRY",
"ATTR_PERSON","OP_OR","OP_AND","OP_NOT","OP_MS","TKN_OPERATOR","'+'","'('","')'",
"'.'","','","'-'","':'","'{'","'}'","';'","'['","']'","'<'","'>'","'|'","'*'",
"'?'","'^'","'$'","object","attribute_list","attribute","changed_attribute",
"nichdl_attribute","auth_attribute","status_inet_attribute","phone_attribute",
"int_list","source_attribute","refer_attribute","country_attribute","person_attribute",
"name_list","freetext_attribute","generic_attribute","generic_list","generic_non_empty_list",
"blobs_attribute","blobs_list","list_item","list_item_0","tkn_word","tkn_word_from_keyw",
"tkn_word_from_keyw_none","tkn_word_from_keyw_mailfrom","tkn_word_from_keyw_cryptpw",
"tkn_word_from_keyw_assigned","tkn_word_from_keyw_allocated","tkn_word_from_keyw_pi",
"tkn_word_from_keyw_pa","tkn_word_from_keyw_unspecified","tkn_word_from_keyw_ext",
"tkn_word_from_keyw_simple","tkn_word_from_keyw_ripe","tkn_word_from_keyw_internic",
"tkn_word_from_keyw_clientaddress","opt_as_expr","as_expr","as_expr_term","as_expr_factor",
"as_expr_operand","opt_router_expr","opt_router_expr_with_at","router_expr",
"router_expr_term","router_expr_factor","router_expr_operand","peering","opt_action",
"action","single_action","filter","filter_term","filter_factor","filter_operand",
"filter_prefix","filter_prefix_operand","opt_filter_prefix_list","filter_prefix_list",
"filter_prefix_list_prefix","filter_aspath","filter_aspath_term","filter_aspath_closure",
"filter_aspath_factor","filter_aspath_no","filter_aspath_range","filter_rp_attribute",
"import_peering_action_list","export_peering_action_list","import_factor","import_factor_list",
"export_factor","export_factor_list","import_term","export_term","import_expr",
"export_expr","opt_protocol_from","opt_protocol_into","import_attribute","export_attribute",
"opt_default_filter","default_attribute","filter_attribute","peering_attribute",
"ifaddr_attribute","opt_peer_options","peer_options","peer_option","peer_id",
"peer_attribute","aggr_bndry_attribute","aggr_mtd_attribute","opt_inject_expr",
"inject_expr","inject_expr_term","inject_expr_factor","inject_expr_operand",
"inject_attribute","opt_atomic","components_list","components_attribute","opt_rs_members_list",
"rs_members_list","rs_member","rs_members_attribute","rpattr_attribute","methods",
"method","typedef_attribute","typedef_type_list","typedef_type","enum_list",
"protocol_attribute","protocol_options","protocol_option","opt_attr_options",
"attr_options","attr_option","attr_attribute","mnt_routes_attribute","mnt_routes_list",
"mnt_routes_list_item", NULL
};
#endif

static const short yyr1[] = {     0,
   138,   138,   138,   138,   138,   138,   138,   139,   139,   140,
   140,   140,   140,   140,   140,   140,   140,   140,   140,   140,
   140,   140,   140,   140,   140,   140,   140,   140,   140,   140,
   140,   140,   140,   140,   140,   140,   140,   140,   140,   140,
   141,   141,   142,   142,   143,   143,   143,   143,   143,   144,
   144,   144,   144,   144,   144,   145,   145,   145,   145,   145,
   146,   146,   147,   147,   148,   148,   148,   148,   148,   148,
   148,   148,   148,   149,   149,   150,   150,   151,   151,   152,
   153,   153,   154,   154,   155,   155,   156,   156,   157,   157,
   158,   158,   159,   159,   159,   159,   159,   159,   159,   159,
   159,   159,   159,   159,   159,   159,   159,   159,   159,   159,
   159,   159,   159,   159,   159,   159,   159,   159,   159,   160,
   160,   160,   160,   160,   160,   160,   160,   160,   160,   160,
   160,   160,   160,   161,   161,   161,   161,   161,   161,   161,
   161,   161,   161,   161,   161,   161,   161,   161,   161,   161,
   161,   161,   161,   161,   161,   161,   161,   161,   161,   161,
   161,   161,   161,   161,   161,   161,   161,   161,   161,   161,
   162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
   172,   173,   174,   175,   175,   176,   176,   177,   177,   177,
   178,   178,   179,   179,   180,   180,   181,   181,   182,   182,
   183,   183,   183,   184,   184,   185,   185,   185,   186,   186,
   187,   187,   188,   188,   189,   189,   189,   189,   189,   190,
   190,   190,   191,   191,   192,   192,   192,   193,   193,   193,
   193,   193,   194,   194,   195,   195,   195,   195,   195,   196,
   196,   197,   197,   198,   198,   199,   199,   200,   200,   201,
   201,   201,   201,   202,   202,   202,   202,   203,   203,   203,
   203,   203,   203,   204,   204,   204,   204,   204,   204,   205,
   205,   205,   205,   206,   206,   207,   207,   208,   209,   209,
   210,   211,   211,   212,   212,   213,   213,   214,   214,   214,
   215,   215,   215,   216,   216,   217,   217,   218,   218,   218,
   219,   219,   219,   220,   220,   221,   221,   221,   222,   222,
   223,   223,   224,   224,   224,   224,   224,   225,   225,   226,
   226,   227,   228,   228,   228,   228,   229,   229,   229,   229,
   230,   230,   231,   231,   231,   231,   231,   232,   232,   233,
   233,   234,   234,   235,   235,   236,   236,   236,   237,   237,
   238,   238,   239,   239,   239,   240,   240,   241,   241,   242,
   242,   243,   243,   243,   243,   243,   243,   243,   243,   244,
   244,   245,   245,   245,   246,   246,   247,   247,   247,   247,
   247,   247,   247,   247,   247,   248,   248,   249,   249,   250,
   250,   250,   250,   250,   250,   250,   250,   250,   251,   251,
   252,   252,   252,   253,   253,   254,   254,   255,   255,   256,
   256,   256,   257,   257,   257,   257,   257,   257,   257,   257,
   257,   257,   257,   257,   258,   258,   258,   259,   260,   260,
   261,   261,   261
};

static const short yyr2[] = {     0,
     2,     2,     2,     1,     1,     1,     0,     1,     2,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     2,     2,
     4,     3,     3,     3,     3,     4,     4,     3,     3,     4,
     4,     4,     4,     4,     3,     4,     9,     7,    11,     3,
     1,     2,     3,     3,     4,     5,     4,     5,     4,     5,
     4,     5,     3,     3,     3,     4,     3,     1,     2,     2,
     3,     3,     0,     1,     1,     3,     3,     3,     1,     2,
     1,     3,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     3,     5,     3,     5,     1,     1,     1,     1,     1,
     1,     1,     1,     1,     1,     1,     1,     3,     3,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     0,     1,     3,     1,     3,     3,     1,
     3,     1,     1,     1,     0,     1,     0,     2,     3,     1,
     3,     3,     1,     3,     1,     1,     1,     1,     3,     1,
     0,     2,     1,     2,     7,     4,     5,     5,     1,     3,
     2,     1,     3,     1,     2,     3,     1,     1,     3,     1,
     1,     1,     2,     1,     1,     1,     1,     1,     3,     0,
     1,     1,     3,     1,     1,     3,     1,     2,     1,     2,
     2,     2,     1,     1,     1,     3,     1,     1,     1,     1,
     1,     3,     4,     0,     2,     2,     2,     4,     2,     6,
     3,     4,     4,     3,     4,     3,     4,     3,     2,     3,
     3,     2,     3,     2,     3,     2,     3,     1,     3,     3,
     1,     3,     3,     0,     2,     0,     2,     5,     5,     3,
     5,     5,     3,     0,     2,     6,     5,     3,     3,     3,
     3,     3,     6,     6,     5,     4,     3,     0,     1,     1,
     3,     4,     1,     1,     1,     1,     5,     5,     4,     3,
     3,     3,     3,     4,     4,     4,     3,     0,     2,     3,
     1,     3,     1,     3,     1,     1,     4,     4,     5,     3,
     0,     1,     0,     1,     4,     4,     3,     0,     1,     1,
     3,     1,     2,     1,     2,     1,     2,     1,     1,     3,
     3,     4,     4,     3,     1,     2,     3,     4,     6,     5,
     7,     3,     4,     3,     2,     4,     3,     1,     3,     2,
     3,     1,     6,     6,     4,     8,     3,     4,     1,     3,
     4,     4,     3,     0,     2,     2,     2,     0,     1,     1,
     3,     3,     4,     6,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     1,     4,     4,     3,     3,     1,     3,
     1,     2,     4
};

static const short yydefact[] = {     0,
     6,     0,     5,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     8,    12,    31,    32,    33,    34,    35,
    36,    37,    38,    29,    10,    11,    13,    14,    15,    26,
    27,    17,    16,    21,    20,    19,    18,    25,    24,    22,
    23,    28,    30,    40,     3,    39,     2,     0,   134,   135,
   136,   137,   138,   139,   140,   141,   142,   143,   144,   145,
   146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
   156,   157,   159,   161,   162,   163,   158,   160,   164,   165,
   166,   167,   168,   169,   170,    94,    95,    96,    97,   117,
    98,   100,    99,   101,    93,   106,   107,   108,   109,   110,
   111,   112,   114,   115,   116,     0,    83,     0,    84,    85,
    91,   113,     0,     0,    89,     0,     0,   296,     0,   296,
     0,     0,    80,     0,     0,     0,     0,     0,   180,   181,
   182,   183,   121,   122,   123,   124,   125,   126,   128,   120,
   127,     0,   129,   132,   130,   131,   133,     0,     0,   211,
     0,   352,   353,     0,     0,     0,     0,   193,   194,     0,
     0,   187,   190,   192,     0,   368,   369,   362,   364,   366,
     0,   359,   360,     0,     0,     0,     0,     0,     0,     0,
     0,   228,   236,   235,   237,   238,   231,     0,     0,     0,
   240,     0,     0,   222,   224,   227,   232,   234,   230,     0,
   210,   195,     0,     0,     0,   431,     0,   429,     0,     0,
     0,   171,   172,   173,     0,     0,     0,     0,     0,   174,
   175,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     1,     9,    82,
     0,     0,     0,     0,    81,     0,     0,    88,    87,    90,
   300,   295,     0,     0,   303,     0,   308,     0,    42,     0,
   317,     0,     0,   330,     0,     0,   325,   326,   324,   318,
   350,   206,   208,   207,     0,   198,   200,   203,   205,     0,
   338,   357,   354,     0,   337,     0,   333,     0,     0,   185,
   332,     0,   331,     0,     0,     0,   371,   363,   365,   367,
   370,     0,   374,     0,     0,     0,     0,   375,     0,   387,
     0,     0,     0,   392,     0,   403,     0,     0,   310,     0,
    83,     0,    83,   225,     0,   244,   245,     0,   241,   242,
   259,   258,   260,     0,   261,   264,   254,   255,     0,   247,
   249,   253,   257,   309,     0,   221,     0,   233,   312,   197,
   196,   311,   427,     0,     0,   415,   416,   423,   418,   419,
   420,   421,   417,   424,   422,     0,   409,   410,   432,   240,
   428,     0,    44,    43,    49,    48,    45,     0,     0,    55,
   176,   177,     0,     0,   178,     0,     0,     0,    60,    61,
     0,    64,    63,    73,     0,     0,     0,     0,    75,    74,
    77,     0,    78,   102,   104,   119,   118,    86,    92,   297,
     0,     0,     0,     0,   288,     0,     0,     0,     0,     0,
   291,     0,     0,   304,    41,   316,     0,     0,   329,     0,
     0,     0,   319,   320,     0,     0,     0,     0,     0,   219,
   212,   213,     0,     0,     0,   356,   336,   335,   334,   191,
   186,   189,   188,   361,   385,     0,     0,     0,     0,   372,
   376,   373,   390,   388,     0,     0,     0,     0,     0,   386,
   402,     0,     0,   401,   405,   271,     0,     0,     0,   226,
   239,     0,     0,   264,     0,   229,     0,   248,   252,   250,
   251,   220,   223,   209,   426,     0,     0,   425,     0,     0,
   430,    46,    47,    50,    51,    52,    53,    54,   179,    56,
    62,     0,     0,    65,     0,    67,     0,    69,     0,    71,
     0,    76,    79,     0,     0,   211,     0,     0,     0,     0,
   299,   284,     0,     0,   298,   211,     0,     0,     0,     0,
   302,   286,     0,     0,   301,   307,     0,     0,   315,     0,
     0,   328,    83,   327,     0,   204,   199,   202,   201,     0,
    83,     0,    83,   214,   346,     0,     0,     0,   339,   341,
   343,   345,   349,     0,   384,     0,     0,   382,   377,     0,
     0,   391,     0,   397,     0,     0,     0,   399,     0,   407,
   406,   272,    83,   273,   243,   256,     0,   266,   265,   269,
   267,   262,   246,   412,     0,     0,   411,   433,     0,     0,
    66,    68,    70,    72,   103,   105,   274,   279,   285,     0,
   278,   211,     0,   289,   290,   276,   282,   287,     0,   281,
   211,     0,   292,   293,   305,   306,   314,   313,     0,   321,
     0,     0,     0,     0,   240,   240,     0,     0,     0,   355,
   383,     0,   378,     0,   389,   398,     0,     0,     0,     0,
   395,     0,   263,     0,     0,   413,     0,     0,   280,   275,
   283,   277,   322,   216,     0,    83,     0,     0,     0,   344,
   340,   342,   380,     0,     0,     0,     0,     0,   400,   270,
   268,     0,     0,    58,   217,     0,   218,   347,   348,     0,
   379,     0,   393,   394,   414,    62,     0,     0,   381,     0,
    57,     0,   215,   396,     0,    59,     0,     0,     0
};

static const short yydefgoto[] = {   737,
    33,    34,    35,    36,    37,    38,    39,   411,    40,    41,
    42,    43,   422,    44,    45,   128,   129,    46,   134,   130,
   131,   226,   163,   236,   237,   238,   242,   243,   403,   404,
   408,   533,   164,   165,   166,   167,   309,   222,   182,   183,
   184,   370,   170,   296,   297,   298,   299,   223,   301,   461,
   462,   213,   214,   215,   216,   217,   218,   348,   349,   350,
   359,   360,   361,   362,   363,   505,   219,   433,   439,   643,
   548,   652,   558,   435,   441,   436,   442,   138,   274,    47,
    48,   568,    49,    50,    51,    52,   452,   453,   454,   290,
    53,    54,    55,   464,   589,   590,   591,   592,    56,   173,
   304,    57,   191,   192,   193,    58,    59,   327,   328,    60,
   483,   484,   609,    61,   338,   495,   386,   387,   388,    62,
    63,   227,   228
};

static const short yypact[] = {   525,
    29,   -12,    -7,   690,   814,    28,    31,    80,    25,    38,
    50,  1266,   343,    24,   260,    49,   306,    44,    40,  1346,
    36,    71,  1426,  1906,    30,    41,   303,    47,  1506,   342,
  1586,  1666,   451,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,   143,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   -20,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,   -15,-32768,-32768,   240,  1062,   164,     6,-32768,
   104,-32768,   185,   938,-32768,   283,  1906,   229,   305,   229,
   326,   349,-32768,   359,   262,   363,    76,   375,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,   251,-32768,-32768,-32768,-32768,-32768,   379,   345,   458,
   417,-32768,   240,   418,    73,    90,   419,-32768,-32768,   -27,
   174,    60,-32768,-32768,   421,-32768,-32768,   369,   370,   371,
   431,   380,-32768,   434,    48,    48,   446,   208,   447,   356,
   448,-32768,-32768,-32768,-32768,-32768,-32768,   280,   240,   240,
   290,   225,    93,   358,-32768,-32768,-32768,   404,-32768,   464,
-32768,   320,   465,   466,   469,    51,    10,-32768,   470,   471,
   472,-32768,-32768,-32768,   473,   474,   453,   481,   477,-32768,
-32768,   321,   382,   509,   507,   512,   513,   514,   495,   496,
   499,   504,   526,   527,   528,  1906,   529,-32768,-32768,-32768,
   530,   531,   115,   461,-32768,  1062,  1062,-32768,-32768,-32768,
-32768,-32768,  1906,    52,-32768,    17,-32768,   350,-32768,   532,
-32768,   535,    54,-32768,   536,  1186,-32768,-32768,-32768,  1906,
-32768,-32768,-32768,-32768,   345,   475,    85,-32768,-32768,   128,
   555,-32768,   200,   181,-32768,   538,-32768,   539,   540,   485,
-32768,   100,-32768,   -27,   -27,   -27,-32768,-32768,-32768,-32768,
-32768,   413,-32768,   479,    74,    26,    55,-32768,   202,-32768,
   208,   581,    18,   476,   544,-32768,   545,   277,-32768,  1062,
  1062,   562,  1062,-32768,   124,-32768,-32768,   480,   483,-32768,
-32768,-32768,-32768,   225,-32768,   468,-32768,-32768,   257,   225,
   233,-32768,-32768,-32768,   240,   358,   240,-32768,-32768,   598,
   475,-32768,-32768,   146,   520,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,   583,   519,-32768,-32768,   290,
-32768,  1906,-32768,-32768,-32768,-32768,-32768,   585,   586,-32768,
-32768,-32768,   587,   588,-32768,   589,   590,   591,-32768,-32768,
   147,-32768,-32768,-32768,   248,   261,   327,   354,-32768,-32768,
-32768,  1826,-32768,   533,   534,-32768,-32768,-32768,-32768,-32768,
   349,   642,   398,   -28,   415,   593,   349,   643,   429,   -25,
   441,   595,   596,   640,-32768,-32768,   599,   232,-32768,   602,
   541,   604,   542,-32768,   159,   345,   345,   345,   337,-32768,
   128,-32768,    95,   605,  1906,-32768,-32768,-32768,-32768,-32768,
    60,-32768,-32768,-32768,-32768,   543,    33,   546,    61,-32768,
-32768,-32768,   547,-32768,   208,   636,   208,   607,  1746,-32768,
-32768,    48,    48,-32768,-32768,-32768,   548,   552,   549,-32768,
-32768,   290,   109,-32768,   178,-32768,   225,   233,-32768,-32768,
-32768,   358,-32768,-32768,-32768,   487,   315,-32768,   487,   550,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,   507,   551,-32768,   608,-32768,   616,-32768,   617,-32768,
   620,-32768,-32768,   619,   621,   458,   553,    46,   240,   349,
-32768,-32768,    52,    52,-32768,   458,   556,    56,   240,   349,
-32768,-32768,    17,    17,-32768,-32768,   240,   625,-32768,   627,
   628,-32768,  1062,-32768,  1906,-32768,    85,-32768,-32768,  1062,
  1062,   610,  1062,-32768,-32768,   563,   564,    95,   574,   615,
-32768,-32768,-32768,   240,-32768,   611,   208,-32768,-32768,   322,
   208,-32768,   208,-32768,   606,   612,   613,-32768,   249,-32768,
-32768,-32768,  1062,-32768,-32768,-32768,   183,-32768,   609,-32768,
-32768,-32768,   225,-32768,   614,   618,-32768,-32768,   136,   673,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   622,
   200,   458,   644,-32768,-32768,-32768,-32768,-32768,   646,   200,
   458,   647,-32768,-32768,   200,-32768,-32768,-32768,   623,-32768,
   648,   624,   626,   638,   290,   290,   289,    95,    95,   200,
-32768,   325,-32768,   265,-32768,-32768,   677,   679,   680,  1906,
-32768,   650,-32768,   671,  1906,-32768,   507,   685,-32768,-32768,
-32768,-32768,-32768,-32768,   649,  1062,   651,   653,   654,-32768,
   615,-32768,-32768,   310,   657,   652,   655,   656,-32768,-32768,
-32768,   662,   207,-32768,-32768,   663,-32768,-32768,-32768,   666,
-32768,   727,-32768,-32768,-32768,   691,   667,   660,-32768,   208,
-32768,   729,-32768,-32768,   733,-32768,   792,   793,-32768
};

static const short yypgoto[] = {-32768,
-32768,   761,-32768,-32768,-32768,-32768,-32768,  -511,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,  -123,-32768,-32768,-32768,     0,
   537,    -9,    -4,-32768,-32768,-32768,-32768,-32768,   554,   557,
-32768,    82,   766,   768,   769,   771,-32768,     8,   488,   126,
-32768,-32768,   433,  -194,   351,     4,-32768,  -134,  -269,-32768,
   344,  -120,  -206,  -193,-32768,-32768,-32768,  -372,-32768,   304,
   454,   302,  -347,-32768,-32768,   307,-32768,-32768,-32768,  -262,
-32768,  -266,-32768,-32768,-32768,   -86,   -92,   805,   674,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   238,-32768,
-32768,-32768,-32768,-32768,   266,   187,   188,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,   570,-32768,-32768,   664,  -312,-32768,
  -408,  -196,-32768,-32768,-32768,-32768,-32768,-32768,   -94,-32768,
-32768,-32768,   467
};


#define YYLAST          1988


static const short yytable[] = {   132,
   132,   335,   162,   264,   135,   263,   366,   278,   444,   440,
   200,   434,   508,   225,   481,   344,   481,   520,   486,   247,
   629,   254,   256,   181,   171,   437,   478,   371,   136,   551,
   229,   139,   561,   596,  -351,  -294,   201,   487,   144,  -294,
   197,   231,   178,   179,   194,    66,   202,   244,   324,   177,
   146,    67,   303,   431,   447,   324,   366,  -351,  -351,   431,
   172,   389,   137,  -294,   437,   137,  -294,   391,   325,   203,
   600,   220,   315,   306,   476,   325,   282,   331,   332,   333,
   141,  -351,   143,   232,   233,   234,    64,    65,   142,   345,
   308,   283,   180,  -351,  -351,  -351,   366,   457,  -351,   552,
   455,  -351,   562,   202,   261,   204,   205,   206,   585,   262,
   207,   230,   480,   208,   448,   147,   198,   145,   178,   179,
   195,   196,   132,   235,   326,   202,   203,   272,   266,   132,
   307,   326,   392,   270,   202,   586,   587,   334,   366,  -351,
   178,   179,   438,  -351,   221,   479,   488,  -184,   203,  -351,
   364,   209,   597,  -294,  -351,   210,  -294,   203,   512,   178,
   179,   211,   204,   205,   206,   245,   212,   207,   180,   547,
   208,   557,   639,   513,   316,   713,   390,   432,   571,   610,
   611,   599,   648,   310,   204,   205,   206,   312,   672,   207,
   180,   477,   208,   204,   205,   206,   531,   529,   207,   458,
   260,   208,   324,   515,   530,   459,   365,   531,   209,   180,
   202,   618,   210,   314,   588,   465,   618,   497,   211,   499,
   470,   265,   325,   212,   331,   332,   333,   267,   365,   616,
   209,   313,   570,   203,   210,   426,   300,   365,   466,   209,
   211,   507,   268,   210,   500,   212,   423,   619,   620,   211,
   202,   285,   619,   620,   212,   460,   687,   529,   351,   482,
   174,   132,   132,   430,   273,   428,   532,   726,   516,   204,
   205,   206,   456,   203,   207,   508,   637,   208,   326,   576,
   451,   331,   332,   333,   334,   640,   646,   314,   602,  -211,
   604,   649,   698,   699,   352,   353,   546,   175,   176,   621,
   492,   493,   556,   239,   621,   534,   185,   622,   535,   204,
   205,   206,   683,   365,   207,   209,   286,   208,   536,   210,
   626,   537,   280,   287,   288,   211,   331,   332,   333,   289,
   212,   331,   332,   333,   494,   132,   132,   625,   132,   496,
   271,   334,   248,   168,   354,   705,   355,  -197,   240,   241,
   443,   509,   169,   356,   300,   209,   337,   346,   347,   210,
   357,   358,   275,  -358,  -211,   211,   510,   511,   401,   402,
   212,   680,   690,   186,   187,   188,   189,   190,   681,  -404,
  -404,   692,  -197,   277,   538,   292,   334,   539,   506,   507,
   720,   334,   293,   149,   150,   151,   152,   340,   294,   341,
  -197,   342,   668,   549,   675,   550,   676,  -211,   343,   700,
   292,   540,   543,  -404,   541,   642,   279,   293,   178,   179,
   281,   624,   221,   294,   627,   651,   553,   554,   641,   401,
   402,   405,   284,   314,   366,   559,   291,   560,   650,   295,
   472,   473,   673,   366,   674,   703,   655,   704,   366,   659,
    -4,   257,   563,   564,   580,   594,   581,   662,   582,   664,
   578,   579,   300,   366,   295,   583,   644,   645,   180,   374,
   653,   654,   367,   670,   302,   305,   311,   675,   317,   608,
   186,   187,   188,   189,   190,   318,   319,   320,   321,   682,
   375,   323,   376,   377,   378,   379,   380,   381,   382,   383,
   384,   385,   322,   330,   336,   339,     2,   675,   375,   258,
   376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
   368,   369,   372,   373,    -7,     1,  -408,   393,   394,   395,
   396,   397,   398,   734,   400,     4,     5,     6,     7,     8,
     9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
    29,    30,    31,    32,   399,   451,   409,   410,   132,   412,
   413,   414,   716,   415,   416,   132,   132,   417,   132,   661,
     2,     3,   418,   419,   420,   421,    64,   427,   456,   445,
   424,   425,   446,   449,   463,   467,   468,   469,   314,   475,
   485,   490,   491,   504,   489,   502,   501,   169,   132,     4,
     5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25,    26,    27,    28,    29,    30,    31,    32,   498,   517,
   518,   519,   522,   523,   524,   525,   526,   527,   528,   431,
   555,   437,   565,   566,   567,   603,   569,   544,   545,   572,
   573,   574,   593,   595,   575,   631,   598,   605,   612,   601,
   709,   613,   630,   632,   633,   712,   628,   634,   614,   635,
   638,   636,   656,   647,   657,   658,   663,   668,   665,   666,
    68,   132,    69,    70,    71,    72,    73,    74,    75,    76,
    77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
    87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
    97,    98,    99,   100,   101,   102,   103,   104,   105,   669,
   677,   671,   684,   688,   678,   679,   685,   706,   686,   707,
   711,   708,   714,   693,   695,   696,   730,   -83,   731,   689,
   106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
   116,   117,   118,   119,   120,   121,   122,   697,   123,   124,
   710,   552,   125,   691,   562,   694,   715,   721,   717,   718,
   719,   722,   725,   728,   723,   724,   729,   733,   732,   735,
   736,   738,   739,   259,   727,   249,   406,   250,   251,   407,
   252,   471,   514,   429,   584,   615,   577,   503,   623,   126,
   617,   140,   660,   276,   133,   127,    69,    70,    71,    72,
    73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
    83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
    93,    94,    95,    96,    97,    98,    99,   100,   101,   102,
   103,   104,   105,   667,   701,     0,   702,     0,   521,   329,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,   106,   107,   108,   109,   110,   111,
   112,   113,   114,   115,   116,   117,   118,   119,   120,   121,
   122,   474,   123,   124,     0,     0,   125,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,   126,     0,     0,     0,     0,     0,   127,
    69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
    79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
    89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
    99,   100,   101,   102,   103,   104,   105,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   269,     0,     0,   106,   107,
   108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
   118,   119,   120,   121,   122,     0,   123,   124,     0,     0,
   125,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   126,     0,     0,
     0,     0,     0,   127,    69,    70,    71,    72,    73,    74,
    75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
    85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
    95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
   105,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,   106,   107,   108,   109,   110,   111,   112,   113,
   114,   115,   116,   117,   118,   119,   120,   121,   122,     0,
   123,   124,     0,     0,   125,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,   126,     0,     0,     0,     0,   450,   127,  -323,  -323,
  -323,  -323,  -323,  -323,  -323,  -323,  -323,  -323,  -323,  -323,
  -323,  -323,  -323,  -323,  -323,  -323,  -323,  -323,  -323,  -323,
  -323,  -323,  -323,  -323,  -323,  -323,  -323,  -323,  -323,  -323,
  -323,  -323,  -323,  -323,  -323,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,  -323,  -323,  -323,
  -323,     0,     0,  -323,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,  -323,  -323,  -323,  -323,  -323,
  -323,  -323,  -323,     0,     0,     0,   148,  -323,    69,    70,
    71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
    81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
    91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
   101,   102,   103,   104,   105,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   149,   150,   151,
   152,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   153,   154,   155,   156,   157,
   158,   159,   160,     0,     0,     0,   199,   161,    69,    70,
    71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
    81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
    91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
   101,   102,   103,   104,   105,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   149,   150,   151,
   152,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   153,   154,   155,   156,   157,
   158,   159,   160,     0,     0,     0,   224,   161,    69,    70,
    71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
    81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
    91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
   101,   102,   103,   104,   105,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   149,   150,   151,
   152,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   153,   154,   155,   156,   157,
   158,   159,   160,     0,     0,     0,   246,   161,    69,    70,
    71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
    81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
    91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
   101,   102,   103,   104,   105,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   149,   150,   151,
   152,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   153,   154,   155,   156,   157,
   158,   159,   160,     0,     0,     0,   253,   161,    69,    70,
    71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
    81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
    91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
   101,   102,   103,   104,   105,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   149,   150,   151,
   152,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   153,   154,   155,   156,   157,
   158,   159,   160,     0,     0,     0,   255,   161,    69,    70,
    71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
    81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
    91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
   101,   102,   103,   104,   105,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   149,   150,   151,
   152,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   153,   154,   155,   156,   157,
   158,   159,   160,     0,     0,     0,     0,   161,    69,    70,
    71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
    81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
    91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
   101,   102,   103,   104,   105,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   149,   150,   151,
   152,     0,     0,     0,     0,     0,   606,   607,     0,     0,
     0,     0,     0,     0,     0,   153,   154,   155,   156,   157,
   158,   159,   160,     0,     0,     0,     0,   161,    69,    70,
    71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
    81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
    91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
   101,   102,   103,   104,   105,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   149,   150,   151,
   152,     0,     0,   542,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   153,   154,   155,   156,   157,
   158,   159,   160,     0,     0,     0,     0,   161,    69,    70,
    71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
    81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
    91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
   101,   102,   103,   104,   105,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   149,   150,   151,
   152,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   153,   154,   155,   156,   157,
   158,   159,   160,     0,     0,     0,     0,   161
};

static const short yycheck[] = {     4,
     5,   198,    12,   127,     5,   126,   213,   142,   278,   276,
    20,   274,   360,    23,   327,   209,   329,   390,     1,    29,
   532,    31,    32,    16,     1,     9,     1,   222,     1,    58,
     1,     1,    58,     1,    11,     8,     1,    20,     1,     9,
     1,     1,    70,    71,     1,    58,    11,     1,     1,     1,
     1,    59,   173,     8,     1,     1,   263,    34,    35,     8,
    37,    11,    35,    36,     9,    35,    36,    58,    21,    34,
   479,     1,    13,     1,     1,    21,     1,    17,    18,    19,
     1,    58,    58,    43,    44,    45,    58,    59,     9,   210,
     1,    16,   120,    70,    71,    72,   303,    13,    75,   128,
   295,    78,   128,    11,   125,    70,    71,    72,    14,   125,
    75,    82,    58,    78,    61,    66,    77,    80,    70,    71,
    77,    78,   127,    83,    77,    11,    34,   137,   123,   134,
    58,    77,   123,   134,    11,    41,    42,    77,   345,   116,
    70,    71,   126,   120,    74,   120,   129,    58,    34,   126,
    58,   116,   120,   126,   131,   120,   126,    34,   365,    70,
    71,   126,    70,    71,    72,   119,   131,    75,   120,   432,
    78,   438,   127,   367,   115,   687,   126,   126,   448,   492,
   493,   121,   127,   176,    70,    71,    72,   180,   597,    75,
   120,   118,    78,    70,    71,    72,    61,    51,    75,   115,
    58,    78,     1,    58,    58,    78,   114,    61,   116,   120,
    11,    34,   120,   114,   120,    35,    34,   341,   126,   343,
   121,    58,    21,   131,    17,    18,    19,   124,   114,   121,
   116,    58,     1,    34,   120,   121,     5,   114,    58,   116,
   126,   133,    58,   120,   121,   131,   256,    70,    71,   126,
    11,     1,    70,    71,   131,   128,   121,    51,    34,    58,
     1,   266,   267,   273,    36,   266,   120,    61,   123,    70,
    71,    72,   114,    34,    75,   623,   546,    78,    77,   121,
   290,    17,    18,    19,    77,   548,   556,   114,   485,    58,
   487,   558,   665,   666,    70,    71,   431,    38,    39,   122,
    24,    25,   437,     1,   122,    58,     1,   130,    61,    70,
    71,    72,   130,   114,    75,   116,    66,    78,    58,   120,
   517,    61,    61,    73,    74,   126,    17,    18,    19,    79,
   131,    17,    18,    19,    58,   340,   341,    23,   343,   340,
    58,    77,     1,     1,   120,    81,   122,     5,    46,    47,
     1,   119,    10,   129,     5,   116,     1,    68,    69,   120,
   136,   137,    58,    58,    15,   126,   134,   135,    48,    49,
   131,   123,   642,    68,    69,    70,    71,    72,   130,    24,
    25,   651,    40,    58,    58,    66,    77,    61,   132,   133,
    81,    77,    73,    52,    53,    54,    55,   118,    79,   120,
    58,   122,   114,     6,   601,     8,   603,    58,   129,   121,
    66,    58,   422,    58,    61,   550,    58,    73,    70,    71,
    58,   516,    74,    79,   519,   560,    12,    13,   549,    48,
    49,    50,    58,   114,   641,     7,    58,     9,   559,   120,
   315,   316,   121,   650,   123,   121,   567,   123,   655,   573,
     0,     1,    12,    13,   118,   465,   120,   581,   122,   583,
   457,   458,     5,   670,   120,   129,   553,   554,   120,     1,
   563,   564,   115,   594,    58,    58,    58,   674,    58,   489,
    68,    69,    70,    71,    72,   117,   117,   117,    58,   613,
    22,    58,    24,    25,    26,    27,    28,    29,    30,    31,
    32,    33,   123,    58,    58,    58,    56,   704,    22,    59,
    24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
   117,    58,    58,    58,     0,     1,    58,    58,    58,    58,
    58,    58,    80,   730,    58,    85,    86,    87,    88,    89,
    90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
   100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
   110,   111,   112,   113,    84,   575,    58,    61,   573,    58,
    58,    58,   696,    79,    79,   580,   581,    79,   583,   580,
    56,    57,    79,    58,    58,    58,    58,   127,   114,    58,
    61,    61,    58,    58,    40,    58,    58,    58,   114,   121,
    20,    58,    58,   136,   129,   123,   127,    10,   613,    85,
    86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
    96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
   106,   107,   108,   109,   110,   111,   112,   113,    77,   120,
    58,   123,    58,    58,    58,    58,    58,    58,    58,     8,
    58,     9,    58,    58,    15,    20,    58,   125,   125,    58,
   120,    58,    58,   121,   123,    58,   121,    61,   121,   123,
   680,   120,   122,    58,    58,   685,   127,    58,   130,    61,
   128,    61,    58,   128,    58,    58,    77,   114,   126,   126,
     1,   696,     3,     4,     5,     6,     7,     8,     9,    10,
    11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
    21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
    31,    32,    33,    34,    35,    36,    37,    38,    39,   115,
   125,   121,   124,    61,   123,   123,   123,    61,   121,    61,
    70,    62,    58,   121,   121,   120,    20,    58,    58,   128,
    61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
    71,    72,    73,    74,    75,    76,    77,   130,    79,    80,
   121,   128,    83,   128,   128,   128,   128,   121,   128,   127,
   127,   130,   121,   121,   130,   130,   121,   128,   122,    61,
    58,     0,     0,    33,   713,    30,   243,    30,    30,   243,
    30,   314,   370,   267,   461,   502,   456,   354,   507,   120,
   504,     7,   575,   140,     1,   126,     3,     4,     5,     6,
     7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
    17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
    27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
    37,    38,    39,   588,   668,    -1,   669,    -1,   392,   196,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    61,    62,    63,    64,    65,    66,
    67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
    77,   322,    79,    80,    -1,    -1,    83,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,   120,    -1,    -1,    -1,    -1,    -1,   126,
     3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
    13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
    23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
    33,    34,    35,    36,    37,    38,    39,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    58,    -1,    -1,    61,    62,
    63,    64,    65,    66,    67,    68,    69,    70,    71,    72,
    73,    74,    75,    76,    77,    -1,    79,    80,    -1,    -1,
    83,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,    -1,    -1,
    -1,    -1,    -1,   126,     3,     4,     5,     6,     7,     8,
     9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
    19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
    29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    61,    62,    63,    64,    65,    66,    67,    68,
    69,    70,    71,    72,    73,    74,    75,    76,    77,    -1,
    79,    80,    -1,    -1,    83,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,   120,    -1,    -1,    -1,    -1,     1,   126,     3,     4,
     5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
    55,    -1,    -1,    58,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
    75,    76,    77,    -1,    -1,    -1,     1,    82,     3,     4,
     5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
    75,    76,    77,    -1,    -1,    -1,     1,    82,     3,     4,
     5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
    75,    76,    77,    -1,    -1,    -1,     1,    82,     3,     4,
     5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
    75,    76,    77,    -1,    -1,    -1,     1,    82,     3,     4,
     5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
    75,    76,    77,    -1,    -1,    -1,     1,    82,     3,     4,
     5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
    75,    76,    77,    -1,    -1,    -1,     1,    82,     3,     4,
     5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
    75,    76,    77,    -1,    -1,    -1,    -1,    82,     3,     4,
     5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
    55,    -1,    -1,    -1,    -1,    -1,    61,    62,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
    75,    76,    77,    -1,    -1,    -1,    -1,    82,     3,     4,
     5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
    55,    -1,    -1,    58,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
    75,    76,    77,    -1,    -1,    -1,    -1,    82,     3,     4,
     5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    52,    53,    54,
    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
    75,    76,    77,    -1,    -1,    -1,    -1,    82
};
/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
#line 3 "/usr/local/share/bison.simple"

/* Skeleton output parser for bison,
   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* As a special exception, when this file is copied by Bison into a
   Bison output file, you may use that output file without restriction.
   This special exception was added by the Free Software Foundation
   in version 1.24 of Bison.  */

#ifndef alloca
#ifdef __GNUC__
#define alloca __builtin_alloca
#else /* not GNU C.  */
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
#include <alloca.h>
#else /* not sparc */
#if defined (MSDOS) && !defined (__TURBOC__)
#include <malloc.h>
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
#include <malloc.h>
 #pragma alloca
#else /* not MSDOS, __TURBOC__, or _AIX */
#ifdef __hpux
#ifdef __cplusplus
extern "C" {
void *alloca (unsigned int);
};
#else /* not __cplusplus */
void *alloca ();
#endif /* not __cplusplus */
#endif /* __hpux */
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
#endif /* not sparc.  */
#endif /* not GNU C.  */
#endif /* alloca not defined.  */

/* This is the parser code that is written into each bison parser
  when the %semantic_parser declaration is not specified in the grammar.
  It was written by Richard Stallman by simplifying the hairy parser
  used when %semantic_parser is specified.  */

/* Note: there must be only one dollar sign in this file.
   It is replaced by the list of actions, each action
   as one case of the switch.  */

#define yyerrok         (yyerrstatus = 0)
#define yyclearin       (yychar = YYEMPTY)
#define YYEMPTY         -2
#define YYEOF           0
#define YYACCEPT        return(0)
#define YYABORT         return(1)
#define YYERROR         goto yyerrlab1
/* Like YYERROR except do call yyerror.
   This remains here temporarily to ease the
   transition to the new meaning of YYERROR, for GCC.
   Once GCC version 2 has supplanted version 1, this can go.  */
#define YYFAIL          goto yyerrlab
#define YYRECOVERING()  (!!yyerrstatus)
/* [<][>][^][v][top][bottom][index][help] */
#define YYBACKUP(token, value) \
/* [<][>][^][v][top][bottom][index][help] */
do                                                              \
  if (yychar == YYEMPTY && yylen == 1)                          \
    { yychar = (token), yylval = (value);                       \
      yychar1 = YYTRANSLATE (yychar);                           \
      YYPOPSTACK;                                               \
      goto yybackup;                                            \
    }                                                           \
  else                                                          \
    { yyerror ("syntax error: cannot back up"); YYERROR; }      \
while (0)

#define YYTERROR        1
#define YYERRCODE       256

#ifndef YYPURE
#define YYLEX           yylex()
#endif

#ifdef YYPURE
#ifdef YYLSP_NEEDED
#ifdef YYLEX_PARAM
#define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
#else
#define YYLEX           yylex(&yylval, &yylloc)
#endif
#else /* not YYLSP_NEEDED */
#ifdef YYLEX_PARAM
#define YYLEX           yylex(&yylval, YYLEX_PARAM)
#else
#define YYLEX           yylex(&yylval)
#endif
#endif /* not YYLSP_NEEDED */
#endif

/* If nonreentrant, generate the variables here */

#ifndef YYPURE

int     yychar;                 /*  the lookahead symbol                */
YYSTYPE yylval;                 /*  the semantic value of the           */
                                /*  lookahead symbol                    */

#ifdef YYLSP_NEEDED
YYLTYPE yylloc;                 /*  location data for the lookahead     */
                                /*  symbol                              */
#endif

int yynerrs;                    /*  number of parse errors so far       */
#endif  /* not YYPURE */

#if YYDEBUG != 0
int yydebug;                    /*  nonzero means print parse trace     */
/* Since this is uninitialized, it does not stop multiple parsers
   from coexisting.  */
#endif

/*  YYINITDEPTH indicates the initial size of the parser's stacks       */

#ifndef YYINITDEPTH
#define YYINITDEPTH 200
#endif

/*  YYMAXDEPTH is the maximum size the stacks can grow to
    (effective only if the built-in stack extension method is used).  */

#if YYMAXDEPTH == 0
#undef YYMAXDEPTH
#endif

#ifndef YYMAXDEPTH
#define YYMAXDEPTH 10000
#endif

/* Prevent warning if -Wstrict-prototypes.  */
#ifdef __GNUC__
int yyparse (void);
#endif

#if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
#define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
/* [<][>][^][v][top][bottom][index][help] */
#else                           /* not GNU C or C++ */
#ifndef __cplusplus

/* This is the most reliable way to avoid incompatibilities
   in available built-in functions on various systems.  */
static void
__yy_memcpy (to, from, count)
/* [<][>][^][v][top][bottom][index][help] */
     char *to;
     char *from;
     int count;
{
  register char *f = from;
  register char *t = to;
  register int i = count;

  while (i-- > 0)
    *t++ = *f++;
}

#else /* __cplusplus */

/* This is the most reliable way to avoid incompatibilities
   in available built-in functions on various systems.  */
static void
__yy_memcpy (char *to, char *from, int count)
/* [<][>][^][v][top][bottom][index][help] */
{
  register char *f = from;
  register char *t = to;
  register int i = count;

  while (i-- > 0)
    *t++ = *f++;
}

#endif
#endif

#line 196 "/usr/local/share/bison.simple"

/* The user can define YYPARSE_PARAM as the name of an argument to be passed
   into yyparse.  The argument should have type void *.
   It should actually point to an object.
   Grammar actions can access the variable by casting it
   to the proper pointer type.  */

#ifdef YYPARSE_PARAM
#ifdef __cplusplus
#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
#define YYPARSE_PARAM_DECL
#else /* not __cplusplus */
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
#endif /* not __cplusplus */
#else /* not YYPARSE_PARAM */
#define YYPARSE_PARAM_ARG
#define YYPARSE_PARAM_DECL
#endif /* not YYPARSE_PARAM */

int
yyparse(YYPARSE_PARAM_ARG)
/* [<][>][^][v][top][bottom][index][help] */
     YYPARSE_PARAM_DECL
{
  register int yystate;
  register int yyn;
  register short *yyssp;
  register YYSTYPE *yyvsp;
  int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
  int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */

  short yyssa[YYINITDEPTH];     /*  the state stack                     */
  YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */

  short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
  YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */

#ifdef YYLSP_NEEDED
  YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
  YYLTYPE *yyls = yylsa;
  YYLTYPE *yylsp;

#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
#else
#define YYPOPSTACK   (yyvsp--, yyssp--)
#endif

  int yystacksize = YYINITDEPTH;

#ifdef YYPURE
  int yychar;
  YYSTYPE yylval;
  int yynerrs;
#ifdef YYLSP_NEEDED
  YYLTYPE yylloc;
#endif
#endif

  YYSTYPE yyval;                /*  the variable used to return         */
                                /*  semantic values from the action     */
                                /*  routines                            */

  int yylen;

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Starting parse\n");
#endif

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY;             /* Cause a token to be read.  */

  /* Initialize stack pointers.
     Waste one element of value and location stack
     so that they stay on the same level as the state stack.
     The wasted elements are never initialized.  */

  yyssp = yyss - 1;
  yyvsp = yyvs;
#ifdef YYLSP_NEEDED
  yylsp = yyls;
#endif

/* Push a new state, which is found in  yystate  .  */
/* In all cases, when you get here, the value and location stacks
   have just been pushed. so pushing a state here evens the stacks.  */
yynewstate:

  *++yyssp = yystate;

  if (yyssp >= yyss + yystacksize - 1)
    {
      /* Give user a chance to reallocate the stack */
      /* Use copies of these so that the &'s don't force the real ones into memory. */
      YYSTYPE *yyvs1 = yyvs;
      short *yyss1 = yyss;
#ifdef YYLSP_NEEDED
      YYLTYPE *yyls1 = yyls;
#endif

      /* Get the current used size of the three stacks, in elements.  */
      int size = yyssp - yyss + 1;

#ifdef yyoverflow
      /* Each stack pointer address is followed by the size of
         the data in use in that stack, in bytes.  */
#ifdef YYLSP_NEEDED
      /* This used to be a conditional around just the two extra args,
         but that might be undefined if yyoverflow is a macro.  */
      yyoverflow("parser stack overflow",
                 &yyss1, size * sizeof (*yyssp),
                 &yyvs1, size * sizeof (*yyvsp),
                 &yyls1, size * sizeof (*yylsp),
                 &yystacksize);
#else
      yyoverflow("parser stack overflow",
                 &yyss1, size * sizeof (*yyssp),
                 &yyvs1, size * sizeof (*yyvsp),
                 &yystacksize);
#endif

      yyss = yyss1; yyvs = yyvs1;
#ifdef YYLSP_NEEDED
      yyls = yyls1;
#endif
#else /* no yyoverflow */
      /* Extend the stack our own way.  */
      if (yystacksize >= YYMAXDEPTH)
        {
          yyerror("parser stack overflow");
          return 2;
        }
      yystacksize *= 2;
      if (yystacksize > YYMAXDEPTH)
        yystacksize = YYMAXDEPTH;
      yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
      __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
      yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
      __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
#ifdef YYLSP_NEEDED
      yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
      __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
#endif
#endif /* no yyoverflow */

      yyssp = yyss + size - 1;
      yyvsp = yyvs + size - 1;
#ifdef YYLSP_NEEDED
      yylsp = yyls + size - 1;
#endif

#if YYDEBUG != 0
      if (yydebug)
        fprintf(stderr, "Stack size increased to %d\n", yystacksize);
#endif

      if (yyssp >= yyss + yystacksize - 1)
        YYABORT;
    }

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Entering state %d\n", yystate);
#endif

  goto yybackup;
 yybackup:

/* Do appropriate processing given the current state.  */
/* Read a lookahead token if we need one and don't already have one.  */
/* yyresume: */

  /* First try to decide what to do without reference to lookahead token.  */

  yyn = yypact[yystate];
  if (yyn == YYFLAG)
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* yychar is either YYEMPTY or YYEOF
     or a valid token in external form.  */

  if (yychar == YYEMPTY)
    {
#if YYDEBUG != 0
      if (yydebug)
        fprintf(stderr, "Reading a token: ");
#endif
      yychar = YYLEX;
    }

  /* Convert token to internal form (in yychar1) for indexing tables with */

  if (yychar <= 0)              /* This means end of input. */
    {
      yychar1 = 0;
      yychar = YYEOF;           /* Don't call YYLEX any more */

#if YYDEBUG != 0
      if (yydebug)
        fprintf(stderr, "Now at end of input.\n");
#endif
    }
  else
    {
      yychar1 = YYTRANSLATE(yychar);

#if YYDEBUG != 0
      if (yydebug)
        {
          fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
          /* Give the individual parser a way to print the precise meaning
             of a token, for further debugging info.  */
#ifdef YYPRINT
          YYPRINT (stderr, yychar, yylval);
#endif
          fprintf (stderr, ")\n");
        }
#endif
    }

  yyn += yychar1;
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
    goto yydefault;

  yyn = yytable[yyn];

  /* yyn is what to do for this token type in this state.
     Negative => reduce, -yyn is rule number.
     Positive => shift, yyn is new state.
       New state is final state => don't bother to shift,
       just return success.
     0, or most negative number => error.  */

  if (yyn < 0)
    {
      if (yyn == YYFLAG)
        goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }
  else if (yyn == 0)
    goto yyerrlab;

  if (yyn == YYFINAL)
    YYACCEPT;

  /* Shift the lookahead token.  */

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
#endif

  /* Discard the token being shifted unless it is eof.  */
  if (yychar != YYEOF)
    yychar = YYEMPTY;

  *++yyvsp = yylval;
#ifdef YYLSP_NEEDED
  *++yylsp = yylloc;
#endif

  /* count tokens shifted since error; after three, turn off error status.  */
  if (yyerrstatus) yyerrstatus--;

  yystate = yyn;
  goto yynewstate;

/* Do the default action for the current state.  */
yydefault:

  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;

/* Do a reduction.  yyn is the number of a rule to reduce with.  */
yyreduce:
  yylen = yyr2[yyn];
  if (yylen > 0)
    yyval = yyvsp[1-yylen]; /* implement default value of the action */

#if YYDEBUG != 0
  if (yydebug)
    {
      int i;

      fprintf (stderr, "Reducing via rule %d (line %d), ",
               yyn, yyrline[yyn]);

      /* Print the symbols being reduced, and their result.  */
      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
        fprintf (stderr, "%s ", yytname[yyrhs[i]]);
      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
    }
#endif


  switch (yyn) {

case 1:
#line 385 "rpsl.y"
{
   YYACCEPT;
;
    break;}
case 2:
#line 388 "rpsl.y"
{
   YYACCEPT;
;
    break;}
case 3:
#line 391 "rpsl.y"
{
   handle_object_error("Error: syntax error\n");
   YYABORT;
;
    break;}
case 4:
#line 395 "rpsl.y"
{ // end of file
   YYACCEPT;
;
    break;}
case 5:
#line 398 "rpsl.y"
{ // end of file
   YYACCEPT;
;
    break;}
case 6:
#line 401 "rpsl.y"
{ // end of file
   handle_object_error("Error: syntax error\n");
   YYABORT;
;
    break;}
case 7:
#line 405 "rpsl.y"
{ // end of file
   YYABORT;
;
    break;}
case 8:
#line 410 "rpsl.y"
{
   (*current_object) += yyvsp[0].attr;
;
    break;}
case 9:
#line 413 "rpsl.y"
{
   (*current_object) += yyvsp[0].attr;
;
    break;}
case 39:
#line 447 "rpsl.y"
{ // the current line started w/ non-attribute
   yyval.attr = changeCurrentAttr(new Attr);
   handle_error("Error: syntax error\n");
;
    break;}
case 40:
#line 451 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new Attr);
   handle_error("Error: syntax error\n");
   yyerrok;
;
    break;}
case 41:
#line 460 "rpsl.y"
{
   free(yyvsp[-2].string);
   yyval.attr = yyvsp[-3].attr;
;
    break;}
case 42:
#line 464 "rpsl.y"
{
   handle_error("Error: \"changed: <email> <YYYYMMDD>\" expected\n");
   yyerrok;
;
    break;}
case 43:
#line 471 "rpsl.y"
{
   free(yyvsp[-1].string);
   yyval.attr = yyvsp[-2].attr;
;
    break;}
case 44:
#line 475 "rpsl.y"
{
  handle_error("Error: \"%s: <nic-handle>\" expected\n",yyvsp[-2].attr->type->name());
  yyerrok; 
;
    break;}
case 45:
#line 480 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
;
    break;}
case 46:
#line 483 "rpsl.y"
{
   free(yyvsp[-1].string);
   yyval.attr = yyvsp[-3].attr;
;
    break;}
case 47:
#line 487 "rpsl.y"
{
   free(yyvsp[-1].string);
   yyval.attr = yyvsp[-3].attr; 
;
    break;}
case 48:
#line 491 "rpsl.y"
{
   free(yyvsp[-1].string);
   yyval.attr = yyvsp[-2].attr;
;
    break;}
case 49:
#line 495 "rpsl.y"
{
   handle_error("Error: \"auth: MAIL-FROM <regexp>\""
                ", \"auth: NONE\", \"auth: CRYPT-PW <cryptedpaswd>\""
                "  or \"auth: PGPKEY-<pgpid>\"  expected\n");
   yyerrok;
   
;
    break;}
case 50:
#line 504 "rpsl.y"
{
  yyval.attr = yyvsp[-3].attr;
;
    break;}
case 51:
#line 507 "rpsl.y"
{
  yyval.attr = yyvsp[-3].attr;
;
    break;}
case 52:
#line 510 "rpsl.y"
{
  yyval.attr = yyvsp[-3].attr;
;
    break;}
case 53:
#line 513 "rpsl.y"
{
  yyval.attr = yyvsp[-3].attr;
;
    break;}
case 54:
#line 516 "rpsl.y"
{
  yyval.attr = yyvsp[-3].attr;
;
    break;}
case 55:
#line 519 "rpsl.y"
{
   handle_error("Error: \"status\" attribute contains invalid keywords\n");
   yyerrok;  
;
    break;}
case 56:
#line 525 "rpsl.y"
{
  yyval.attr = yyvsp[-3].attr;
;
    break;}
case 57:
#line 528 "rpsl.y"
{
  yyval.attr = yyvsp[-8].attr; 
;
    break;}
case 58:
#line 531 "rpsl.y"
{
  yyval.attr = yyvsp[-6].attr; 
;
    break;}
case 59:
#line 534 "rpsl.y"
{
  yyval.attr = yyvsp[-10].attr; 
;
    break;}
case 60:
#line 537 "rpsl.y"
{
   handle_error("Error: intn'l phone number expected (with a preceding '+')\n");
   yyerrok;
;
    break;}
case 61:
#line 543 "rpsl.y"
{
  //sprintf($$, "%i", $1);
  yyval.string = strdup("phone"); // well, sprintf($$, "%i", $1) didn't work
;
    break;}
case 62:
#line 547 "rpsl.y"
{
  yyval.string = yyvsp[-1].string;
;
    break;}
case 63:
#line 551 "rpsl.y"
{
  if(yyschema.searchSource(yyvsp[-1].string)){
    free(yyvsp[-1].string);
    yyval.attr = yyvsp[-2].attr;
  }else{
    free(yyvsp[-1].string);
    handle_error("Error: No such source\n");
  }
;
    break;}
case 64:
#line 560 "rpsl.y"
{
   handle_error("Error: invalid source attribute\n");
   yyerrok;
;
    break;}
case 65:
#line 565 "rpsl.y"
{
   yyval.attr = yyvsp[-3].attr;
;
    break;}
case 66:
#line 568 "rpsl.y"
{
   yyval.attr = yyvsp[-4].attr;
;
    break;}
case 67:
#line 571 "rpsl.y"
{
   yyval.attr = yyvsp[-3].attr;
;
    break;}
case 68:
#line 574 "rpsl.y"
{
   yyval.attr = yyvsp[-4].attr;
;
    break;}
case 69:
#line 577 "rpsl.y"
{
   yyval.attr = yyvsp[-3].attr;
;
    break;}
case 70:
#line 580 "rpsl.y"
{
   yyval.attr = yyvsp[-4].attr;
;
    break;}
case 71:
#line 583 "rpsl.y"
{
   yyval.attr = yyvsp[-3].attr;
;
    break;}
case 72:
#line 586 "rpsl.y"
{
   yyval.attr = yyvsp[-4].attr;
;
    break;}
case 73:
#line 589 "rpsl.y"
{
   handle_error("Error: invalid refer attribute\n");
   yyerrok;
;
    break;}
case 74:
#line 594 "rpsl.y"
{
  if(yyschema.searchCountry(yyvsp[-1].string)){
    free(yyvsp[-1].string);
    yyval.attr = yyvsp[-2].attr;
  }else{
    free(yyvsp[-1].string);
    handle_error("Error: No such country\n");
  }
;
    break;}
case 75:
#line 603 "rpsl.y"
{
   handle_error("Error: invalid country attribute\n");
   yyerrok;
;
    break;}
case 76:
#line 608 "rpsl.y"
{
  yyval.attr = yyvsp[-3].attr;
;
    break;}
case 77:
#line 611 "rpsl.y"
{
   handle_error("Error: invalid %s attribute\n",yyvsp[-2].attr->type->name());
   yyerrok;
;
    break;}
case 78:
#line 616 "rpsl.y"
{
  yyval.string = strdup(yyvsp[0].string);
;
    break;}
case 79:
#line 619 "rpsl.y"
{
  yyval.string = strdup(yyvsp[0].string);
;
    break;}
case 80:
#line 624 "rpsl.y"
{
   char *start = strchr(yyvsp[-1].attr->object->contents + yyvsp[-1].attr->offset, ':') + 1;
   int len = yyvsp[-1].attr->object->contents + yyvsp[-1].attr->offset + yyvsp[-1].attr->len - start;
   ItemFREETEXT *ft = new ItemFREETEXT(start, len);
   ItemList *il = new ItemList;
   il->append(ft);
   
   yyval.attr = changeCurrentAttr(new AttrGeneric(yyvsp[-1].attr->type, il));
;
    break;}
case 81:
#line 635 "rpsl.y"
{
   if (!yyvsp[-2].attr->type->subsyntax()->validate(yyvsp[-1].list)) {
      handle_error("Error: argument to %s should be %s.\n",
              yyvsp[-2].attr->type->name(), yyvsp[-2].attr->type->subsyntax()->name());
      delete yyvsp[-1].list;
      yyval.attr = changeCurrentAttr(new AttrGeneric(yyvsp[-2].attr->type, NULL));
   } else 
      yyval.attr = changeCurrentAttr(new AttrGeneric(yyvsp[-2].attr->type, yyvsp[-1].list));
;
    break;}
case 82:
#line 644 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   cout << "issuing error:  argument to %s should be %s.(ATTR_GENERIC error TKN_EOA)" << endl;
   handle_error("Error: argument to %s should be %s.\n",
           yyvsp[-2].attr->type->name(), yyvsp[-2].attr->type->subsyntax()->name());
   yyerrok;
;
    break;}
case 83:
#line 653 "rpsl.y"
{
   yyval.list = new ItemList;
;
    break;}
case 85:
#line 659 "rpsl.y"
{       
   yyval.list = new ItemList;
   yyval.list->append(yyvsp[0].item);
;
    break;}
case 86:
#line 663 "rpsl.y"
{
   yyval.list = yyvsp[-2].list;
   yyval.list->append(yyvsp[0].item);
;
    break;}
case 87:
#line 669 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrGeneric(yyvsp[-2].attr->type, yyvsp[-1].list));
;
    break;}
case 88:
#line 672 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: argument to %s should be blob sequence.\n",
           yyvsp[-2].attr->type->name());
   yyerrok;
;
    break;}
case 89:
#line 680 "rpsl.y"
{       
   yyval.list = new ItemList;
   yyval.list->append(yyvsp[0].item);
;
    break;}
case 90:
#line 684 "rpsl.y"
{
   yyval.list = yyvsp[-1].list;
   yyval.list->append(yyvsp[0].item);
;
    break;}
case 91:
#line 690 "rpsl.y"
{
   yyval.item = yyvsp[0].item;
;
    break;}
case 92:
#line 693 "rpsl.y"
{
   yyval.item = new ItemRange(yyvsp[-2].item, yyvsp[0].item);
;
    break;}
case 93:
#line 698 "rpsl.y"
{
   yyval.item = new ItemASNO(yyvsp[0].i);
;
    break;}
case 94:
#line 701 "rpsl.y"
{
   yyval.item = new ItemINT(yyvsp[0].i);
;
    break;}
case 95:
#line 704 "rpsl.y"
{
   yyval.item = new ItemREAL(yyvsp[0].real);
;
    break;}
case 96:
#line 707 "rpsl.y"
{
   yyval.item = new ItemSTRING(yyvsp[0].string);
;
    break;}
case 97:
#line 710 "rpsl.y"
{
   yyval.item = new ItemTimeStamp(yyvsp[0].time);
;
    break;}
case 98:
#line 713 "rpsl.y"
{
   yyval.item = new ItemIPV4(yyvsp[0].ip);
;
    break;}
case 99:
#line 716 "rpsl.y"
{
   yyval.item = new ItemPRFXV4(yyvsp[0].prfx);
;
    break;}
case 100:
#line 719 "rpsl.y"
{
   printf("Debug: parser: Reducing  TKN_PRFXV6 into list_item_0\n");
   yyval.item = new ItemPRFXV6(yyvsp[0].string);
;
    break;}
case 101:
#line 723 "rpsl.y"
{
   yyval.item = new ItemPRFXV4Range(yyvsp[0].prfxrng);
;
    break;}
case 102:
#line 726 "rpsl.y"
{
   yyval.item = new ItemConnection(yyvsp[-2].ip, yyvsp[0].i);
;
    break;}
case 103:
#line 729 "rpsl.y"
{
   yyval.item = new ItemConnection(yyvsp[-4].ip, yyvsp[-2].i, yyvsp[0].i);
;
    break;}
case 104:
#line 732 "rpsl.y"
{
   yyval.item = new ItemConnection(yyvsp[-2].sid, yyvsp[0].i);
;
    break;}
case 105:
#line 735 "rpsl.y"
{
   yyval.item = new ItemConnection(yyvsp[-4].sid, yyvsp[-2].i, yyvsp[0].i);
;
    break;}
case 106:
#line 738 "rpsl.y"
{
   yyval.item = new ItemASNAME(yyvsp[0].sid);
;
    break;}
case 107:
#line 741 "rpsl.y"
{
   yyval.item = new ItemRSNAME(yyvsp[0].sid);
;
    break;}
case 108:
#line 744 "rpsl.y"
{
   yyval.item = new ItemRTRSNAME(yyvsp[0].sid);
;
    break;}
case 109:
#line 747 "rpsl.y"
{
   yyval.item = new ItemPRNGNAME(yyvsp[0].sid);
;
    break;}
case 110:
#line 750 "rpsl.y"
{
   yyval.item = new ItemFLTRNAME(yyvsp[0].sid);
;
    break;}
case 111:
#line 753 "rpsl.y"
{
   yyval.item = new ItemBOOLEAN(yyvsp[0].i);
;
    break;}
case 112:
#line 756 "rpsl.y"
{
   yyval.item = new ItemWORD(yyvsp[0].string);
;
    break;}
case 113:
#line 759 "rpsl.y"
{
   yyval.item = new ItemWORD(yyvsp[0].string);
;
    break;}
case 114:
#line 762 "rpsl.y"
{
   yyval.item = new ItemDNS(yyvsp[0].sid);
;
    break;}
case 115:
#line 765 "rpsl.y"
{
   yyval.item = new ItemEMAIL(yyvsp[0].string);
;
    break;}
case 116:
#line 768 "rpsl.y"
{
   yyval.item = new ItemKEYCRTNAME(yyvsp[0].string);
;
    break;}
case 117:
#line 771 "rpsl.y"
{
   yyval.item = new ItemBLOB(yyvsp[0].string);
;
    break;}
case 118:
#line 774 "rpsl.y"
{
   yyval.item = yyvsp[-1].list;
;
    break;}
case 119:
#line 777 "rpsl.y"
{
   yyval.item = new ItemFilter(yyvsp[-1].filter);
;
    break;}
case 120:
#line 782 "rpsl.y"
{
   yyval.string = yyvsp[0].string;
;
    break;}
case 121:
#line 785 "rpsl.y"
{
   char buffer[64];
   sprintf(buffer, "AS%d", yyvsp[0].i);
   yyval.string = strdup(buffer);
;
    break;}
case 122:
#line 790 "rpsl.y"
{
   yyval.string = strdup(yyvsp[0].sid);
;
    break;}
case 123:
#line 793 "rpsl.y"
{
   yyval.string = strdup(yyvsp[0].sid);
;
    break;}
case 124:
#line 796 "rpsl.y"
{
   yyval.string = strdup(yyvsp[0].sid);
;
    break;}
case 125:
#line 799 "rpsl.y"
{
   yyval.string = strdup(yyvsp[0].sid);
;
    break;}
case 126:
#line 802 "rpsl.y"
{
   yyval.string = strdup(yyvsp[0].sid);
;
    break;}
case 127:
#line 805 "rpsl.y"
{
   yyval.string = strdup(yyvsp[0].string);
;
    break;}
case 128:
#line 808 "rpsl.y"
{
   if (yyvsp[0].i)
      yyval.string = strdup("true");
   else
      yyval.string = strdup("false");
;
    break;}
case 134:
#line 821 "rpsl.y"
{
   yyval.string = strdup("true");
;
    break;}
case 135:
#line 824 "rpsl.y"
{
   yyval.string = strdup("false");
;
    break;}
case 136:
#line 827 "rpsl.y"
{
   yyval.string = strdup("action");
;
    break;}
case 137:
#line 830 "rpsl.y"
{
   yyval.string = strdup("accept");
;
    break;}
case 138:
#line 833 "rpsl.y"
{
   yyval.string = strdup("announce");
;
    break;}
case 139:
#line 836 "rpsl.y"
{
   yyval.string = strdup("from");
;
    break;}
case 140:
#line 839 "rpsl.y"
{
   yyval.string = strdup("to");
;
    break;}
case 141:
#line 842 "rpsl.y"
{
   yyval.string = strdup("at");
;
    break;}
case 142:
#line 845 "rpsl.y"
{
   yyval.string = strdup("any");
;
    break;}
case 143:
#line 848 "rpsl.y"
{
   yyval.string = strdup("refine");
;
    break;}
case 144:
#line 851 "rpsl.y"
{
   yyval.string = strdup("except");
;
    break;}
case 145:
#line 854 "rpsl.y"
{
   yyval.string = strdup("static");
;
    break;}
case 146:
#line 857 "rpsl.y"
{
   yyval.string = strdup("networks");
;
    break;}
case 147:
#line 860 "rpsl.y"
{
   yyval.string = strdup("masklen");
;
    break;}
case 148:
#line 863 "rpsl.y"
{
   yyval.string = strdup("union");
;
    break;}
case 149:
#line 866 "rpsl.y"
{
   yyval.string = strdup("range");
;
    break;}
case 150:
#line 869 "rpsl.y"
{
   yyval.string = strdup("list");
;
    break;}
case 151:
#line 872 "rpsl.y"
{
   yyval.string = strdup("of");
;
    break;}
case 152:
#line 875 "rpsl.y"
{
   yyval.string = strdup("operator");
;
    break;}
case 153:
#line 878 "rpsl.y"
{
   yyval.string = strdup("syntax");
;
    break;}
case 154:
#line 881 "rpsl.y"
{
   yyval.string = strdup("special");
;
    break;}
case 155:
#line 884 "rpsl.y"
{
   yyval.string = strdup("optional");
;
    break;}
case 156:
#line 887 "rpsl.y"
{
   yyval.string = strdup("mandatory");
;
    break;}
case 157:
#line 890 "rpsl.y"
{
   yyval.string = strdup("internal");
;
    break;}
case 158:
#line 893 "rpsl.y"
{
   yyval.string = strdup("deleted");
;
    break;}
case 159:
#line 896 "rpsl.y"
{
   yyval.string = strdup("singlevalued");
;
    break;}
case 160:
#line 899 "rpsl.y"
{
   yyval.string = strdup("generated");
;
    break;}
case 161:
#line 902 "rpsl.y"
{
   yyval.string = strdup("multivalued");
;
    break;}
case 162:
#line 905 "rpsl.y"
{
   yyval.string = strdup("lookup");
;
    break;}
case 163:
#line 908 "rpsl.y"
{
   yyval.string = strdup("key");
;
    break;}
case 164:
#line 911 "rpsl.y"
{
   yyval.string = strdup("obsolete");
;
    break;}
case 165:
#line 914 "rpsl.y"
{
   yyval.string = strdup("peeras");
;
    break;}
case 166:
#line 917 "rpsl.y"
{
   yyval.string = strdup("protocol");
;
    break;}
case 167:
#line 920 "rpsl.y"
{
   yyval.string = strdup("into");
;
    break;}
case 168:
#line 923 "rpsl.y"
{
   yyval.string = strdup("atomic");
;
    break;}
case 169:
#line 926 "rpsl.y"
{
   yyval.string = strdup("inbound");
;
    break;}
case 170:
#line 929 "rpsl.y"
{
   yyval.string = strdup("outbound");
;
    break;}
case 171:
#line 934 "rpsl.y"
{
   yyval.string = strdup("none");
;
    break;}
case 172:
#line 938 "rpsl.y"
{
   yyval.string = strdup("mail-from");
;
    break;}
case 173:
#line 942 "rpsl.y"
{
   yyval.string = strdup("crypt-pw");
;
    break;}
case 174:
#line 946 "rpsl.y"
{
   yyval.string = strdup("assigned");
;
    break;}
case 175:
#line 950 "rpsl.y"
{
   yyval.string = strdup("allocated");
;
    break;}
case 176:
#line 954 "rpsl.y"
{
   yyval.string = strdup("pi");
;
    break;}
case 177:
#line 958 "rpsl.y"
{
   yyval.string = strdup("pa");
;
    break;}
case 178:
#line 962 "rpsl.y"
{
   yyval.string = strdup("unspecified");
;
    break;}
case 179:
#line 966 "rpsl.y"
{
   yyval.string = strdup("ext");
;
    break;}
case 180:
#line 970 "rpsl.y"
{
   yyval.string = strdup("simple");
;
    break;}
case 181:
#line 974 "rpsl.y"
{
   yyval.string = strdup("ripe");
;
    break;}
case 182:
#line 978 "rpsl.y"
{
   yyval.string = strdup("internic");
;
    break;}
case 183:
#line 982 "rpsl.y"
{
   yyval.string = strdup("clientaddress");
;
    break;}
case 184:
#line 991 "rpsl.y"
{
   yyval.filter = new FilterASNAME(symbols.symID("AS-ANY"));
;
    break;}
case 186:
#line 997 "rpsl.y"
{
   yyval.filter = new FilterOR(yyvsp[-2].filter, yyvsp[0].filter);
;
    break;}
case 188:
#line 1003 "rpsl.y"
{
   yyval.filter = new FilterAND(yyvsp[-2].filter, yyvsp[0].filter);
;
    break;}
case 189:
#line 1006 "rpsl.y"
{
   yyval.filter = new FilterEXCEPT(yyvsp[-2].filter, yyvsp[0].filter);
;
    break;}
case 191:
#line 1012 "rpsl.y"
{
   yyval.filter = yyvsp[-1].filter;
;
    break;}
case 193:
#line 1018 "rpsl.y"
{
   yyval.filter = new FilterASNO(yyvsp[0].i);
;
    break;}
case 194:
#line 1021 "rpsl.y"
{
   yyval.filter = new FilterASNAME(yyvsp[0].sid);
;
    break;}
case 195:
#line 1028 "rpsl.y"
{
   yyval.filter = new FilterANY;
;
    break;}
case 196:
#line 1031 "rpsl.y"
{
   yyval.filter = yyvsp[0].filter;
;
    break;}
case 197:
#line 1036 "rpsl.y"
{
   yyval.filter = new FilterANY;
;
    break;}
case 198:
#line 1039 "rpsl.y"
{
   yyval.filter = yyvsp[0].filter;
;
    break;}
case 199:
#line 1044 "rpsl.y"
{
   yyval.filter = new FilterOR(yyvsp[-2].filter, yyvsp[0].filter);
;
    break;}
case 201:
#line 1050 "rpsl.y"
{
   yyval.filter = new FilterAND(yyvsp[-2].filter, yyvsp[0].filter);
;
    break;}
case 202:
#line 1053 "rpsl.y"
{
   yyval.filter = new FilterEXCEPT(yyvsp[-2].filter, yyvsp[0].filter);
;
    break;}
case 204:
#line 1059 "rpsl.y"
{
   yyval.filter = yyvsp[-1].filter;
;
    break;}
case 206:
#line 1065 "rpsl.y"
{
   yyval.filter = new FilterRouter(yyvsp[0].ip);
;
    break;}
case 207:
#line 1068 "rpsl.y"
{
   yyval.filter = new FilterRouterName(yyvsp[0].sid);
;
    break;}
case 208:
#line 1071 "rpsl.y"
{
   yyval.filter = new FilterRTRSNAME(yyvsp[0].sid);
;
    break;}
case 209:
#line 1078 "rpsl.y"
{
   yyval.peering = new PolicyPeering(yyvsp[-2].filter, yyvsp[-1].filter, yyvsp[0].filter);
;
    break;}
case 210:
#line 1081 "rpsl.y"
{
   yyval.peering = new PolicyPeering(yyvsp[0].sid);
;
    break;}
case 211:
#line 1088 "rpsl.y"
{
   yyval.actionList = new PolicyActionList;
;
    break;}
case 212:
#line 1091 "rpsl.y"
{
   yyval.actionList = yyvsp[0].actionList;
;
    break;}
case 213:
#line 1096 "rpsl.y"
{
   yyval.actionList = new PolicyActionList;
   if (yyvsp[0].actionNode)
      yyval.actionList->append(yyvsp[0].actionNode);  
;
    break;}
case 214:
#line 1101 "rpsl.y"
{
   yyval.actionList = yyvsp[-1].actionList;
   if (yyvsp[0].actionNode)
      yyval.actionList->append(yyvsp[0].actionNode);  
;
    break;}
case 215:
#line 1108 "rpsl.y"
{
   const AttrMethod *mtd = searchMethod(yyvsp[-6].rp_attr, yyvsp[-4].string, yyvsp[-2].list);
   if (mtd)
      yyval.actionNode = new PolicyAction(yyvsp[-6].rp_attr, mtd, yyvsp[-2].list);
   else {
      delete yyvsp[-2].list;
      yyval.actionNode = NULL;
   }
   free(yyvsp[-4].string);
;
    break;}
case 216:
#line 1118 "rpsl.y"
{
   ItemList *plist = new ItemList;
   plist->append(yyvsp[-1].item);

   const AttrMethod *mtd = searchMethod(yyvsp[-3].rp_attr, yyvsp[-2].string, plist);
   if (mtd)
      yyval.actionNode = new PolicyAction(yyvsp[-3].rp_attr, mtd, plist);
   else {
      delete plist;
      yyval.actionNode = NULL;
   }
   // Added by wlee
   free(yyvsp[-2].string);
;
    break;}
case 217:
#line 1132 "rpsl.y"
{
   const AttrMethod *mtd = searchMethod(yyvsp[-4].rp_attr, "()", yyvsp[-2].list);
   if (mtd)
      yyval.actionNode = new PolicyAction(yyvsp[-4].rp_attr, mtd, yyvsp[-2].list);
   else {
      delete yyvsp[-2].list;
      yyval.actionNode = NULL;
   }
;
    break;}
case 218:
#line 1141 "rpsl.y"
{
   const AttrMethod *mtd = searchMethod(yyvsp[-4].rp_attr, "[]", yyvsp[-2].list);
   if (mtd)
      yyval.actionNode = new PolicyAction(yyvsp[-4].rp_attr, mtd, yyvsp[-2].list);
   else {
      delete yyvsp[-2].list;
      yyval.actionNode = NULL;
   }
;
    break;}
case 219:
#line 1150 "rpsl.y"
{
   yyval.actionNode = NULL;
;
    break;}
case 220:
#line 1157 "rpsl.y"
{
   yyval.filter = new FilterOR(yyvsp[-2].filter, yyvsp[0].filter);
;
    break;}
case 221:
#line 1160 "rpsl.y"
{
   yyval.filter = new FilterOR(yyvsp[-1].filter, yyvsp[0].filter);
;
    break;}
case 223:
#line 1166 "rpsl.y"
{
   yyval.filter = new FilterAND(yyvsp[-2].filter, yyvsp[0].filter);
;
    break;}
case 225:
#line 1172 "rpsl.y"
{
   yyval.filter = new FilterNOT(yyvsp[0].filter);
;
    break;}
case 226:
#line 1175 "rpsl.y"
{
   yyval.filter = yyvsp[-1].filter;
;
    break;}
case 228:
#line 1181 "rpsl.y"
{
   yyval.filter = new FilterANY;
;
    break;}
case 229:
#line 1184 "rpsl.y"
{
   yyval.filter = new FilterASPath(yyvsp[-1].re);
;
    break;}
case 230:
#line 1187 "rpsl.y"
{
   if (yyvsp[0].filter)
      yyval.filter = yyvsp[0].filter;
   else
      yyval.filter = new FilterNOT(new FilterANY);
;
    break;}
case 231:
#line 1193 "rpsl.y"
{
   yyval.filter = new FilterFLTRNAME(yyvsp[0].sid);
;
    break;}
case 233:
#line 1199 "rpsl.y"
{
   yyvsp[0].moreSpecOp->f1 = yyvsp[-1].filter;
   yyval.filter = yyvsp[0].moreSpecOp;
;
    break;}
case 235:
#line 1206 "rpsl.y"
{
   yyval.filter = new FilterASNO(yyvsp[0].i);
;
    break;}
case 236:
#line 1209 "rpsl.y"
{
   yyval.filter = new FilterPeerAS;
;
    break;}
case 237:
#line 1212 "rpsl.y"
{
   yyval.filter = new FilterASNAME(yyvsp[0].sid);
;
    break;}
case 238:
#line 1215 "rpsl.y"
{
   yyval.filter = new FilterRSNAME(yyvsp[0].sid);
;
    break;}
case 239:
#line 1218 "rpsl.y"
{ 
   yyval.filter = yyvsp[-1].filter; 
;
    break;}
case 240:
#line 1223 "rpsl.y"
{
   yyval.filter = new FilterPRFXList;
;
    break;}
case 242:
#line 1229 "rpsl.y"
{
   ((FilterPRFXList *) (yyval.filter = new FilterPRFXList))->add_high(*yyvsp[0].prfxrng);
   delete yyvsp[0].prfxrng;
;
    break;}
case 243:
#line 1233 "rpsl.y"
{
   yyval.filter = yyvsp[-2].filter;
   ((FilterPRFXList *) (yyval.filter))->add_high(*yyvsp[0].prfxrng);
   delete yyvsp[0].prfxrng;
;
    break;}
case 244:
#line 1240 "rpsl.y"
{
   yyval.prfxrng = yyvsp[0].prfx;
;
    break;}
case 245:
#line 1243 "rpsl.y"
{
   yyval.prfxrng = yyvsp[0].prfxrng;
;
    break;}
case 246:
#line 1248 "rpsl.y"
{
   yyval.re = new regexp_or(yyvsp[-2].re, yyvsp[0].re);
;
    break;}
case 248:
#line 1254 "rpsl.y"
{
   yyval.re = new regexp_cat(yyvsp[-1].re, yyvsp[0].re);
;
    break;}
case 250:
#line 1260 "rpsl.y"
{
   yyval.re = new regexp_star(yyvsp[-1].re);
;
    break;}
case 251:
#line 1263 "rpsl.y"
{
   yyval.re = new regexp_question(yyvsp[-1].re);
;
    break;}
case 252:
#line 1266 "rpsl.y"
{
   yyval.re = new regexp_plus(yyvsp[-1].re);
;
    break;}
case 254:
#line 1272 "rpsl.y"
{
   yyval.re = new regexp_bol;
;
    break;}
case 255:
#line 1275 "rpsl.y"
{
   yyval.re = new regexp_eol;
;
    break;}
case 256:
#line 1278 "rpsl.y"
{
   yyval.re = yyvsp[-1].re;
;
    break;}
case 258:
#line 1284 "rpsl.y"
{
   yyval.re = new regexp_symbol(yyvsp[0].i);
;
    break;}
case 259:
#line 1287 "rpsl.y"
{
   yyval.re = new regexp_symbol(symbols.symID("PEERAS"));
;
    break;}
case 260:
#line 1290 "rpsl.y"
{
   yyval.re = new regexp_symbol(yyvsp[0].sid);
;
    break;}
case 261:
#line 1293 "rpsl.y"
{
   yyval.re = new regexp_symbol(regexp_symbol::MIN_AS, regexp_symbol::MAX_AS);
;
    break;}
case 262:
#line 1296 "rpsl.y"
{
   yyval.re = yyvsp[-1].re;
;
    break;}
case 263:
#line 1299 "rpsl.y"
{
   yyval.re = yyvsp[-1].re;
   ((regexp_symbol *) yyval.re)->complement();
;
    break;}
case 264:
#line 1305 "rpsl.y"
{
   yyval.re = new regexp_symbol;
;
    break;}
case 265:
#line 1308 "rpsl.y"
{
   ((regexp_symbol *) (yyval.re = yyvsp[-1].re))->add(yyvsp[0].i);
;
    break;}
case 266:
#line 1311 "rpsl.y"
{
   ((regexp_symbol *) (yyval.re = yyvsp[-1].re))->add(symbols.symID("PEERAS"));
;
    break;}
case 267:
#line 1314 "rpsl.y"
{
   ((regexp_symbol *) (yyval.re = yyvsp[-1].re))->add(regexp_symbol::MIN_AS, regexp_symbol::MAX_AS);
;
    break;}
case 268:
#line 1317 "rpsl.y"
{
   ((regexp_symbol *) (yyval.re = yyvsp[-3].re))->add(yyvsp[-2].i, yyvsp[0].i);
;
    break;}
case 269:
#line 1320 "rpsl.y"
{
   ((regexp_symbol *) (yyval.re = yyvsp[-1].re))->add(yyvsp[0].sid);
;
    break;}
case 270:
#line 1325 "rpsl.y"
{
   const AttrMethod *mtd = searchMethod(yyvsp[-5].rp_attr, yyvsp[-3].string, yyvsp[-1].list);
   if (mtd)
      yyval.filter = new FilterRPAttribute(yyvsp[-5].rp_attr, mtd, yyvsp[-1].list);
   else {
      delete yyvsp[-1].list;
      yyval.filter = NULL;
   }
   free(yyvsp[-3].string);
;
    break;}
case 271:
#line 1335 "rpsl.y"
{
   ItemList *plist = new ItemList;
   plist->append(yyvsp[0].item);

   const AttrMethod *mtd = searchMethod(yyvsp[-2].rp_attr, yyvsp[-1].string, plist);
   if (mtd)
      yyval.filter = new FilterRPAttribute(yyvsp[-2].rp_attr, mtd, plist);
   else {
      delete plist;
      yyval.filter = NULL;
   }
   // Added by wlee
   free(yyvsp[-1].string);
;
    break;}
case 272:
#line 1349 "rpsl.y"
{
   const AttrMethod *mtd = searchMethod(yyvsp[-3].rp_attr, "()", yyvsp[-1].list);
   if (mtd)
      yyval.filter = new FilterRPAttribute(yyvsp[-3].rp_attr, mtd, yyvsp[-1].list);
   else {
      delete yyvsp[-1].list;
      yyval.filter = NULL;
   }
;
    break;}
case 273:
#line 1358 "rpsl.y"
{
   const AttrMethod *mtd = searchMethod(yyvsp[-3].rp_attr, "[]", yyvsp[-1].list);
   if (mtd)
      yyval.filter = new FilterRPAttribute(yyvsp[-3].rp_attr, mtd, yyvsp[-1].list);
   else {
      delete yyvsp[-1].list;
      yyval.filter = NULL;
   }
;
    break;}
case 274:
#line 1371 "rpsl.y"
{
   yyval.peeringActionList = new List<PolicyPeeringAction>;
   yyval.peeringActionList->append(new PolicyPeeringAction(yyvsp[-1].peering, yyvsp[0].actionList));
;
    break;}
case 275:
#line 1375 "rpsl.y"
{
   yyval.peeringActionList = yyvsp[-3].peeringActionList;
   yyval.peeringActionList->append(new PolicyPeeringAction(yyvsp[-1].peering, yyvsp[0].actionList));
;
    break;}
case 276:
#line 1381 "rpsl.y"
{
   yyval.peeringActionList = new List<PolicyPeeringAction>;
   yyval.peeringActionList->append(new PolicyPeeringAction(yyvsp[-1].peering, yyvsp[0].actionList));
;
    break;}
case 277:
#line 1385 "rpsl.y"
{
   yyval.peeringActionList = yyvsp[-3].peeringActionList;
   yyval.peeringActionList->append(new PolicyPeeringAction(yyvsp[-1].peering, yyvsp[0].actionList));
;
    break;}
case 278:
#line 1393 "rpsl.y"
{
   yyval.policyFactor = new PolicyFactor(yyvsp[-2].peeringActionList, yyvsp[0].filter);
;
    break;}
case 279:
#line 1398 "rpsl.y"
{
   yyval.policyTerm = new PolicyTerm;
   yyval.policyTerm->append(yyvsp[-1].policyFactor);
;
    break;}
case 280:
#line 1402 "rpsl.y"
{
   yyval.policyTerm = yyvsp[-2].policyTerm;
   yyval.policyTerm->append(yyvsp[-1].policyFactor);
;
    break;}
case 281:
#line 1408 "rpsl.y"
{
   yyval.policyFactor = new PolicyFactor(yyvsp[-2].peeringActionList, yyvsp[0].filter);
;
    break;}
case 282:
#line 1413 "rpsl.y"
{
   yyval.policyTerm = new PolicyTerm;
   yyval.policyTerm->append(yyvsp[-1].policyFactor);
;
    break;}
case 283:
#line 1417 "rpsl.y"
{
   yyval.policyTerm = yyvsp[-2].policyTerm;
   yyval.policyTerm->append(yyvsp[-1].policyFactor);
;
    break;}
case 284:
#line 1425 "rpsl.y"
{
   PolicyTerm *term = new PolicyTerm;
   term->append(yyvsp[-1].policyFactor);
   yyval.policyTerm = term;
;
    break;}
case 285:
#line 1430 "rpsl.y"
{
   yyval.policyTerm = yyvsp[-1].policyTerm;
;
    break;}
case 286:
#line 1435 "rpsl.y"
{
   PolicyTerm *term = new PolicyTerm;
   term->append(yyvsp[-1].policyFactor);
   yyval.policyTerm = term;
;
    break;}
case 287:
#line 1440 "rpsl.y"
{
   yyval.policyTerm = yyvsp[-1].policyTerm;
;
    break;}
case 288:
#line 1447 "rpsl.y"
{
   yyval.policyExpr = yyvsp[0].policyTerm;
;
    break;}
case 289:
#line 1450 "rpsl.y"
{
   yyval.policyExpr = new PolicyRefine(yyvsp[-2].policyTerm, yyvsp[0].policyExpr);
;
    break;}
case 290:
#line 1453 "rpsl.y"
{
   yyval.policyExpr = new PolicyExcept(yyvsp[-2].policyTerm, yyvsp[0].policyExpr);
;
    break;}
case 291:
#line 1458 "rpsl.y"
{
   yyval.policyExpr = yyvsp[0].policyTerm;
;
    break;}
case 292:
#line 1461 "rpsl.y"
{
   yyval.policyExpr = new PolicyRefine(yyvsp[-2].policyTerm, yyvsp[0].policyExpr);
;
    break;}
case 293:
#line 1464 "rpsl.y"
{
   yyval.policyExpr = new PolicyExcept(yyvsp[-2].policyTerm, yyvsp[0].policyExpr);
;
    break;}
case 294:
#line 1471 "rpsl.y"
{
   yyval.protocol = schema.searchProtocol("BGP4");
;
    break;}
case 295:
#line 1474 "rpsl.y"
{
   yyval.protocol = schema.searchProtocol(yyvsp[0].string);
   if (!yyval.protocol) {
      handle_warning("Warning: unknown protocol %s, BGP4 assumed.\n", yyvsp[0].string);
      yyval.protocol = schema.searchProtocol("BGP4");
   }
   free(yyvsp[0].string);
;
    break;}
case 296:
#line 1484 "rpsl.y"
{
   yyval.protocol = schema.searchProtocol("BGP4");
;
    break;}
case 297:
#line 1487 "rpsl.y"
{
   yyval.protocol = schema.searchProtocol(yyvsp[0].string);
   if (!yyval.protocol) {
      handle_warning("Warning: unknown protocol %s, BGP4 assumed.\n", yyvsp[0].string);
      yyval.protocol = schema.searchProtocol("BGP4");
   }
   free(yyvsp[0].string);;
;
    break;}
case 298:
#line 1501 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrImport(yyvsp[-3].protocol, yyvsp[-2].protocol, yyvsp[-1].policyExpr));
;
    break;}
case 299:
#line 1504 "rpsl.y"
{
   PolicyTerm *term = new PolicyTerm;
   term->append(yyvsp[-1].policyFactor);

   yyval.attr = changeCurrentAttr(new AttrImport(yyvsp[-3].protocol, yyvsp[-2].protocol, term));
;
    break;}
case 300:
#line 1510 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: from <peering> expected.\n");
   yyerrok;
;
    break;}
case 301:
#line 1519 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrExport(yyvsp[-3].protocol, yyvsp[-2].protocol, yyvsp[-1].policyExpr));
;
    break;}
case 302:
#line 1522 "rpsl.y"
{
   PolicyTerm *term = new PolicyTerm;
   term->append(yyvsp[-1].policyFactor);

   yyval.attr = changeCurrentAttr(new AttrExport(yyvsp[-3].protocol, yyvsp[-2].protocol, term));
;
    break;}
case 303:
#line 1528 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: to <peering> expected.\n");
   yyerrok;
;
    break;}
case 304:
#line 1535 "rpsl.y"
{
   yyval.filter = new FilterANY;
;
    break;}
case 305:
#line 1538 "rpsl.y"
{
   yyval.filter = yyvsp[0].filter;
;
    break;}
case 306:
#line 1545 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrDefault(yyvsp[-3].peering, yyvsp[-2].actionList, yyvsp[-1].filter));
;
    break;}
case 307:
#line 1548 "rpsl.y"
{
   if (yyvsp[-2].peering)
      delete yyvsp[-2].peering;
   handle_error("Error: badly formed filter/action or keyword NETWORKS/ACTION missing.\n");
   yyerrok;
;
    break;}
case 308:
#line 1554 "rpsl.y"
{
   handle_error("Error: TO <peer> missing.\n");
   yyerrok;
;
    break;}
case 309:
#line 1560 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrFilter(yyvsp[-1].filter));
;
    break;}
case 310:
#line 1563 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: badly formed filter.\n");
   yyerrok;
;
    break;}
case 311:
#line 1570 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrPeering(yyvsp[-1].peering));
;
    break;}
case 312:
#line 1573 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: badly formed filter.\n");
   yyerrok;
;
    break;}
case 313:
#line 1582 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrIfAddr(yyvsp[-4].ip->get_ipaddr(), yyvsp[-2].i, yyvsp[-1].actionList));
   delete yyvsp[-4].ip;
;
    break;}
case 314:
#line 1586 "rpsl.y"
{
   delete yyvsp[-4].ip;
   yyval.attr = yyvsp[-5].attr;
   handle_error("Error: in action specification.\n");
   yyerrok;
;
    break;}
case 315:
#line 1592 "rpsl.y"
{
   delete yyvsp[-3].ip;
   yyval.attr = yyvsp[-4].attr;
   handle_error("Error: integer mask length expected.\n");
   yyerrok;
;
    break;}
case 316:
#line 1598 "rpsl.y"
{
   delete yyvsp[-2].ip;
   yyval.attr = yyvsp[-3].attr;
   handle_error("Error: MASKLEN <length> expected.\n");
   yyerrok;
;
    break;}
case 317:
#line 1604 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: <ip_address> MASKLEN <length> [<action>] expected.\n");
   yyerrok;
;
    break;}
case 318:
#line 1613 "rpsl.y"
{
   yyval.peer_option_list = new List<AttrPeerOption>;
;
    break;}
case 319:
#line 1616 "rpsl.y"
{
   yyval.peer_option_list = yyvsp[0].peer_option_list;
;
    break;}
case 320:
#line 1621 "rpsl.y"
{
   yyval.peer_option_list = new List<AttrPeerOption>;
   yyval.peer_option_list->append(yyvsp[0].peer_option);
;
    break;}
case 321:
#line 1625 "rpsl.y"
{
   yyval.peer_option_list = yyvsp[-2].peer_option_list;
   yyval.peer_option_list->append(yyvsp[0].peer_option);
;
    break;}
case 322:
#line 1631 "rpsl.y"
{
   yyval.peer_option = new AttrPeerOption(yyvsp[-3].string, yyvsp[-1].list);
;
    break;}
case 324:
#line 1637 "rpsl.y"
{
   yyval.ip = new IPAddr;
;
    break;}
case 325:
#line 1640 "rpsl.y"
{
   yyval.ip = new IPAddr;
;
    break;}
case 326:
#line 1643 "rpsl.y"
{
   yyval.ip = new IPAddr;
;
    break;}
case 327:
#line 1648 "rpsl.y"
{
   const AttrProtocol *protocol = schema.searchProtocol(yyvsp[-3].string);
   int position;
   const RPType *correctType;
   bool error = false;

   if (!protocol) {
      handle_error("Error: unknown protocol %s.\n", yyvsp[-3].string);
      error = true;
   } else {
      ((AttrProtocol *) protocol)->startMandatoryCheck();
      for (AttrPeerOption *opt = yyvsp[-1].peer_option_list->head(); opt; opt = yyvsp[-1].peer_option_list->next(opt)) {
         const AttrProtocolOption *decl = protocol->searchOption(opt->option);
         if (!decl)  {
            handle_error("Error: protocol %s does not have option %s.\n", 
                         yyvsp[-3].string, opt->option);
            error = true;
         } else {
            for (; decl; decl = protocol->searchNextOption(decl))
               if (decl->option->validateArgs(opt->args, position, correctType))
                  break;
            if (! decl) {
               handleArgumentTypeError(yyvsp[-3].string, opt->option, position, correctType);
               error = true;
            }
         }
      }
   }

   if (! error) {
      const AttrProtocolOption *missing = 
         ((AttrProtocol *) protocol)->missingMandatoryOption();
      if (missing) {
         handle_error("Error: mandatory option %s of protocol %s is missing.\n", 
                      missing->option->name, yyvsp[-3].string);
         error = true;
      }
   }
      
   if (!error)
      yyval.attr = changeCurrentAttr(new AttrPeer(protocol, yyvsp[-2].ip, yyvsp[-1].peer_option_list));
   else {
      free(yyvsp[-3].string);
      delete yyvsp[-2].ip;
      delete yyvsp[-1].peer_option_list;
   }
;
    break;}
case 328:
#line 1695 "rpsl.y"
{
   yyval.attr = yyvsp[-4].attr;
   free(yyvsp[-3].string);
   delete yyvsp[-2].ip;
   handle_error("Error: in peer option.\n");
   yyerrok;
;
    break;}
case 329:
#line 1702 "rpsl.y"
{
   yyval.attr = yyvsp[-3].attr;
   free(yyvsp[-2].string);
   handle_error("Error: missing peer ip_address.\n");
   yyerrok;
;
    break;}
case 330:
#line 1708 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: missing protocol name.\n");
   yyerrok;
;
    break;}
case 331:
#line 1717 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   delete yyvsp[-1].filter;
;
    break;}
case 332:
#line 1721 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: <as-expression> expected.\n");
   yyerrok;
;
    break;}
case 333:
#line 1728 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
;
    break;}
case 334:
#line 1731 "rpsl.y"
{
   delete yyvsp[-1].filter;
;
    break;}
case 335:
#line 1734 "rpsl.y"
{
   yyval.attr = yyvsp[-3].attr;
   handle_error("Error: OUTBOUND <as-expression> expected.\n");
   yyerrok;
;
    break;}
case 336:
#line 1739 "rpsl.y"
{
   yyval.attr = yyvsp[-3].attr;
   handle_error("Error: INBOUND can not be followed by anything.\n");
   yyerrok;
;
    break;}
case 337:
#line 1744 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: keyword INBOUND or OUTBOUND expected.\n");
   yyerrok;
;
    break;}
case 338:
#line 1753 "rpsl.y"
{
   yyval.filter = new FilterANY;
;
    break;}
case 339:
#line 1756 "rpsl.y"
{
   yyval.filter = yyvsp[0].filter;
;
    break;}
case 340:
#line 1761 "rpsl.y"
{
   yyval.filter = new FilterOR(yyvsp[-2].filter, yyvsp[0].filter);
;
    break;}
case 342:
#line 1767 "rpsl.y"
{
   yyval.filter = new FilterAND(yyvsp[-2].filter, yyvsp[0].filter);
;
    break;}
case 344:
#line 1773 "rpsl.y"
{
   yyval.filter = yyvsp[-1].filter;
;
    break;}
case 346:
#line 1779 "rpsl.y"
{
   yyval.filter = new FilterANY;
;
    break;}
case 347:
#line 1782 "rpsl.y"
{ 
   yyval.filter = new FilterHAVE_COMPONENTS((FilterPRFXList *) yyvsp[-1].filter); 
;
    break;}
case 348:
#line 1785 "rpsl.y"
{ 
   yyval.filter = new FilterEXCLUDE((FilterPRFXList *) yyvsp[-1].filter); 
;
    break;}
case 349:
#line 1790 "rpsl.y"
{
   yyval.attr = yyvsp[-4].attr;
   delete yyvsp[-3].filter;
   delete yyvsp[-2].actionList;
   delete yyvsp[-1].filter;
;
    break;}
case 350:
#line 1796 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: [at <router-exp>] [action <action>] [upon <condition>] expected.\n");
   yyerrok;
;
    break;}
case 353:
#line 1809 "rpsl.y"
{
;
    break;}
case 354:
#line 1811 "rpsl.y"
{
   delete yyvsp[0].filter;
;
    break;}
case 355:
#line 1814 "rpsl.y"
{
   free(yyvsp[-1].string);
   delete yyvsp[0].filter;
;
    break;}
case 356:
#line 1820 "rpsl.y"
{
   yyval.attr = yyvsp[-3].attr;
;
    break;}
case 357:
#line 1823 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: [ATOMIC] [[<filter>] [PROTOCOL <protocol> <filter>] ...] expected.\n");
   yyerrok;
;
    break;}
case 358:
#line 1832 "rpsl.y"
{
   yyval.list = new ItemList;
;
    break;}
case 360:
#line 1838 "rpsl.y"
{       
   yyval.list = new ItemList;
   yyval.list->append(yyvsp[0].item);
;
    break;}
case 361:
#line 1842 "rpsl.y"
{
   yyval.list = yyvsp[-2].list;
   yyval.list->append(yyvsp[0].item);
;
    break;}
case 362:
#line 1848 "rpsl.y"
{
   yyval.item = new ItemASNO(yyvsp[0].i);
;
    break;}
case 363:
#line 1851 "rpsl.y"
{
   yyval.item = new ItemMSItem(new ItemASNO(yyvsp[-1].i), yyvsp[0].moreSpecOp->code, yyvsp[0].moreSpecOp->n, yyvsp[0].moreSpecOp->m);
   delete yyvsp[0].moreSpecOp;
;
    break;}
case 364:
#line 1855 "rpsl.y"
{
   yyval.item = new ItemASNAME(yyvsp[0].sid);
;
    break;}
case 365:
#line 1858 "rpsl.y"
{
   yyval.item = new ItemMSItem(new ItemASNAME(yyvsp[-1].sid), yyvsp[0].moreSpecOp->code, yyvsp[0].moreSpecOp->n, yyvsp[0].moreSpecOp->m);
   delete yyvsp[0].moreSpecOp;
;
    break;}
case 366:
#line 1862 "rpsl.y"
{
   yyval.item = new ItemRSNAME(yyvsp[0].sid);
;
    break;}
case 367:
#line 1865 "rpsl.y"
{
   yyval.item = new ItemMSItem(new ItemRSNAME(yyvsp[-1].sid), yyvsp[0].moreSpecOp->code, yyvsp[0].moreSpecOp->n, yyvsp[0].moreSpecOp->m);
   delete yyvsp[0].moreSpecOp;
;
    break;}
case 368:
#line 1869 "rpsl.y"
{
   yyval.item = new ItemPRFXV4(yyvsp[0].prfx);
;
    break;}
case 369:
#line 1872 "rpsl.y"
{
   yyval.item = new ItemPRFXV4Range(yyvsp[0].prfxrng);
;
    break;}
case 370:
#line 1877 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrGeneric(yyvsp[-2].attr->type, yyvsp[-1].list));
;
    break;}
case 371:
#line 1880 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: invalid member\n");
   yyerrok;
;
    break;}
case 372:
#line 1889 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrRPAttr(yyvsp[-2].string, yyvsp[-1].methodlist));
;
    break;}
case 373:
#line 1892 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrRPAttr(yyvsp[-2].rp_attr->name, yyvsp[-1].methodlist));
;
    break;}
case 374:
#line 1895 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: invalid rp-attribute specification\n");
   yyerrok;
;
    break;}
case 375:
#line 1902 "rpsl.y"
{
   yyval.methodlist = new List<AttrMethod>;
   if (yyvsp[0].method)
      yyval.methodlist->append(yyvsp[0].method);
;
    break;}
case 376:
#line 1907 "rpsl.y"
{
   yyval.methodlist = yyvsp[-1].methodlist;
   if (yyvsp[0].method)
      yyval.methodlist->append(yyvsp[0].method);
;
    break;}
case 377:
#line 1914 "rpsl.y"
{
   yyval.method = new AttrMethod(yyvsp[-2].string, new List<RPTypeNode>, false);
;
    break;}
case 378:
#line 1917 "rpsl.y"
{
   yyval.method = new AttrMethod(yyvsp[-3].string, yyvsp[-1].typelist, false);
;
    break;}
case 379:
#line 1920 "rpsl.y"
{
   yyval.method = new AttrMethod(yyvsp[-5].string, yyvsp[-3].typelist, true);
;
    break;}
case 380:
#line 1923 "rpsl.y"
{
   char buffer[16];
   strcpy(buffer, "operator");
   strcat(buffer, yyvsp[-3].string);
   yyval.method = new AttrMethod(strdup(buffer), yyvsp[-1].typelist, false, true);
   free(yyvsp[-3].string);
;
    break;}
case 381:
#line 1930 "rpsl.y"
{
   char buffer[16];
   strcpy(buffer, "operator");
   strcat(buffer, yyvsp[-5].string);
   yyval.method = new AttrMethod(strdup(buffer), yyvsp[-3].typelist, true, true);
   free(yyvsp[-5].string);
;
    break;}
case 382:
#line 1937 "rpsl.y"
{
   free(yyvsp[-2].string);
   yyval.method = NULL;
   handle_error("Error: invalid method specification for %s\n", yyvsp[-2].string);
;
    break;}
case 383:
#line 1942 "rpsl.y"
{
   yyval.method = NULL;
   handle_error("Error: invalid operator specification for %s\n", yyvsp[-2].string);
   free(yyvsp[-2].string);
;
    break;}
case 384:
#line 1947 "rpsl.y"
{
   yyval.method = NULL;
   handle_error("Error: invalid operator\n");
;
    break;}
case 385:
#line 1951 "rpsl.y"
{
   yyval.method = NULL;
   handle_error("Error: method specification expected\n");
;
    break;}
case 386:
#line 1959 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrTypedef(yyvsp[-2].string, yyvsp[-1].typenode));
;
    break;}
case 387:
#line 1962 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: invalid typedef specification\n");
   yyerrok;
;
    break;}
case 388:
#line 1969 "rpsl.y"
{
   yyval.typelist = new List<RPTypeNode>;
   if (yyvsp[0].typenode)
      yyval.typelist->append(new RPTypeNode(yyvsp[0].typenode));
;
    break;}
case 389:
#line 1974 "rpsl.y"
{
   yyval.typelist = yyvsp[-2].typelist;
   if (yyvsp[0].typenode)
      yyval.typelist->append(new RPTypeNode(yyvsp[0].typenode));
;
    break;}
case 390:
#line 1981 "rpsl.y"
{
   yyval.typenode = RPType::newRPType("union", yyvsp[0].typelist);
   if (!yyval.typenode) {
      handle_error("Error: empty union specification\n");
      delete yyvsp[0].typelist;
   }
;
    break;}
case 391:
#line 1988 "rpsl.y"
{
   if (yyvsp[0].typenode)
      yyval.typenode = new RPTypeRange(yyvsp[0].typenode);
   else {
      yyval.typenode = NULL;
   }
;
    break;}
case 392:
#line 1995 "rpsl.y"
{
   yyval.typenode = RPType::newRPType(yyvsp[0].string);
   if (!yyval.typenode) {
      handle_error("Error: invalid type %s\n", yyvsp[0].string);
   }
   free(yyvsp[0].string);
;
    break;}
case 393:
#line 2002 "rpsl.y"
{
   yyval.typenode = RPType::newRPType(yyvsp[-5].string, yyvsp[-3].i, yyvsp[-1].i);
   if (!yyval.typenode) {
      handle_error("Error: invalid type %s[%d,%d]\n", yyvsp[-5].string, yyvsp[-3].i, yyvsp[-1].i);
   }
   free(yyvsp[-5].string);
;
    break;}
case 394:
#line 2009 "rpsl.y"
{
   yyval.typenode = RPType::newRPType(yyvsp[-5].string, yyvsp[-3].real, yyvsp[-1].real);
   if (!yyval.typenode) {
      handle_error("Error: invalid type %s[%f,%f]\n", yyvsp[-5].string, yyvsp[-3].real, yyvsp[-1].real);
   }
   free(yyvsp[-5].string);
;
    break;}
case 395:
#line 2016 "rpsl.y"
{
   yyval.typenode = RPType::newRPType(yyvsp[-3].string, yyvsp[-1].wordlist);
   if (!yyval.typenode) {
      handle_error("Error: invalid type %s, enum expected\n", yyvsp[-3].string);
      delete yyvsp[-1].wordlist;
   }
   free(yyvsp[-3].string);
;
    break;}
case 396:
#line 2024 "rpsl.y"
{
   if (yyvsp[0].typenode)
      if (yyvsp[-5].i < yyvsp[-3].i)
         yyval.typenode = new RPTypeList(yyvsp[0].typenode, yyvsp[-5].i, yyvsp[-3].i);
      else
         yyval.typenode = new RPTypeList(yyvsp[0].typenode, yyvsp[-3].i, yyvsp[-5].i);
   else {
      yyval.typenode = NULL;
      delete yyvsp[0].typenode;
   }
;
    break;}
case 397:
#line 2035 "rpsl.y"
{
   if (yyvsp[0].typenode)
      yyval.typenode = new RPTypeList(yyvsp[0].typenode);
   else {
      yyval.typenode = NULL;
   }
;
    break;}
case 398:
#line 2042 "rpsl.y"
{
   yyval.typenode = NULL;
   delete yyvsp[0].typenode;
   handle_error("Error: invalid list size\n");
;
    break;}
case 399:
#line 2049 "rpsl.y"
{
   yyval.wordlist = new List<WordNode>;
   yyval.wordlist->append(new WordNode(yyvsp[0].string));
;
    break;}
case 400:
#line 2053 "rpsl.y"
{
   yyval.wordlist = yyvsp[-2].wordlist;
   yyval.wordlist->append(new WordNode(yyvsp[0].string));
;
    break;}
case 401:
#line 2061 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrProtocol(yyvsp[-2].string, yyvsp[-1].protocol_option_list));
;
    break;}
case 402:
#line 2064 "rpsl.y"
{
   yyval.attr = yyvsp[-3].attr;
   handle_error("Error: invalid protocol option\n");
   yyerrok;
;
    break;}
case 403:
#line 2069 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: invalid protocol name\n");
   yyerrok;
;
    break;}
case 404:
#line 2076 "rpsl.y"
{
   yyval.protocol_option_list = new List<AttrProtocolOption>;
;
    break;}
case 405:
#line 2079 "rpsl.y"
{
   yyval.protocol_option_list = yyvsp[-1].protocol_option_list;
   yyval.protocol_option_list->append(yyvsp[0].protocol_option);
;
    break;}
case 406:
#line 2085 "rpsl.y"
{
   yyval.protocol_option = new AttrProtocolOption(false, yyvsp[0].method);
;
    break;}
case 407:
#line 2088 "rpsl.y"
{
   yyval.protocol_option = new AttrProtocolOption(true, yyvsp[0].method);
;
    break;}
case 408:
#line 2095 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr(ATTR_GENERIC, RPType::newRPType("free_text"));
;
    break;}
case 409:
#line 2098 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr(ATTR_GENERIC, RPType::newRPType("free_text"));
   *yyval.rpslattr |= *yyvsp[0].rpslattr;
   delete yyvsp[0].rpslattr;
;
    break;}
case 410:
#line 2105 "rpsl.y"
{
   yyval.rpslattr = yyvsp[0].rpslattr;
;
    break;}
case 411:
#line 2108 "rpsl.y"
{
   yyval.rpslattr = yyvsp[-2].rpslattr;
   *yyval.rpslattr |= *yyvsp[0].rpslattr;
   delete yyvsp[0].rpslattr;
;
    break;}
case 412:
#line 2113 "rpsl.y"
{
   yyval.rpslattr = yyvsp[0].rpslattr;
   handle_error("Error: in attr option specification.\n");
;
    break;}
case 413:
#line 2119 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr(ATTR_GENERIC, yyvsp[-1].typenode);
;
    break;}
case 414:
#line 2122 "rpsl.y"
{
   int syntax = schema.searchAttrSyntax(yyvsp[-1].string);
   if (syntax < 0) {
      handle_error("Error: no known syntax rule for %s.\n", yyvsp[-1].string);
      yyval.rpslattr = new AttrAttr;
   } else
      yyval.rpslattr = new AttrAttr(syntax, NULL);
   free(yyvsp[-1].string);
;
    break;}
case 415:
#line 2131 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr(AttrAttr::OPTIONAL);
;
    break;}
case 416:
#line 2134 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr;
;
    break;}
case 417:
#line 2137 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr(AttrAttr::DELETED)
;
    break;}
case 418:
#line 2140 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr;
;
    break;}
case 419:
#line 2143 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr(AttrAttr::MULTIVALUED);
;
    break;}
case 420:
#line 2146 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr(AttrAttr::LOOKUP);
;
    break;}
case 421:
#line 2149 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr(AttrAttr::KEY);
;
    break;}
case 422:
#line 2152 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr(AttrAttr::OBSOLETE);
;
    break;}
case 423:
#line 2155 "rpsl.y"
{
   yyval.rpslattr = new AttrAttr(AttrAttr::INTERNAL);
;
    break;}
case 424:
#line 2158 "rpsl.y"
{
  yyval.rpslattr = new AttrAttr(AttrAttr::GENERATED);
;
    break;}
case 425:
#line 2163 "rpsl.y"
{
   yyvsp[-1].rpslattr->setName(yyvsp[-2].string);
   yyval.attr = changeCurrentAttr(yyvsp[-1].rpslattr);
;
    break;}
case 426:
#line 2167 "rpsl.y"
{
   yyval.attr = yyvsp[-3].attr;
   free(yyvsp[-2].string);
   handle_error("Error: in attr option specification.\n");
   yyerrok;
;
    break;}
case 427:
#line 2173 "rpsl.y"
{
   yyval.attr = yyvsp[-2].attr;
   handle_error("Error: attr name expected.\n");
   yyerrok;
;
    break;}
case 428:
#line 2182 "rpsl.y"
{
   yyval.attr = changeCurrentAttr(new AttrMntRoutes(yyvsp[-1].listMntPrfxPair));
;
    break;}
case 429:
#line 2187 "rpsl.y"
{
   yyval.listMntPrfxPair = new List<AttrMntRoutes::MntPrfxPair>;
   yyval.listMntPrfxPair->append(yyvsp[0].mntPrfxPair);
;
    break;}
case 430:
#line 2191 "rpsl.y"
{
   yyval.listMntPrfxPair = yyvsp[-2].listMntPrfxPair;
   yyval.listMntPrfxPair->append(yyvsp[0].mntPrfxPair);
;
    break;}
case 431:
#line 2197 "rpsl.y"
{
   yyval.mntPrfxPair = new AttrMntRoutes::MntPrfxPair(yyvsp[0].string, NULL);
;
    break;}
case 432:
#line 2200 "rpsl.y"
{
   yyval.mntPrfxPair = new AttrMntRoutes::MntPrfxPair(yyvsp[-1].string, NULL);
;
    break;}
case 433:
#line 2203 "rpsl.y"
{
   yyval.mntPrfxPair = new AttrMntRoutes::MntPrfxPair(yyvsp[-3].string, (FilterPRFXList *) yyvsp[-1].filter);
;
    break;}
}
   /* the action file gets copied in in place of this dollarsign */
#line 498 "/usr/local/share/bison.simple"

  yyvsp -= yylen;
  yyssp -= yylen;
#ifdef YYLSP_NEEDED
  yylsp -= yylen;
#endif

#if YYDEBUG != 0
  if (yydebug)
    {
      short *ssp1 = yyss - 1;
      fprintf (stderr, "state stack now");
      while (ssp1 != yyssp)
        fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

  *++yyvsp = yyval;

#ifdef YYLSP_NEEDED
  yylsp++;
  if (yylen == 0)
    {
      yylsp->first_line = yylloc.first_line;
      yylsp->first_column = yylloc.first_column;
      yylsp->last_line = (yylsp-1)->last_line;
      yylsp->last_column = (yylsp-1)->last_column;
      yylsp->text = 0;
    }
  else
    {
      yylsp->last_line = (yylsp+yylen-1)->last_line;
      yylsp->last_column = (yylsp+yylen-1)->last_column;
    }
#endif

  /* Now "shift" the result of the reduction.
     Determine what state that goes to,
     based on the state we popped back to
     and the rule number reduced by.  */

  yyn = yyr1[yyn];

  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    yystate = yytable[yystate];
  else
    yystate = yydefgoto[yyn - YYNTBASE];

  goto yynewstate;

yyerrlab:   /* here on detecting error */

  if (! yyerrstatus)
    /* If not already recovering from an error, report this error.  */
    {
      ++yynerrs;

#ifdef YYERROR_VERBOSE
      yyn = yypact[yystate];

      if (yyn > YYFLAG && yyn < YYLAST)
        {
          int size = 0;
          char *msg;
          int x, count;

          count = 0;
          /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
          for (x = (yyn < 0 ? -yyn : 0);
               x < (sizeof(yytname) / sizeof(char *)); x++)
            if (yycheck[x + yyn] == x)
              size += strlen(yytname[x]) + 15, count++;
          msg = (char *) malloc(size + 15);
          if (msg != 0)
            {
              strcpy(msg, "parse error");

              if (count < 5)
                {
                  count = 0;
                  for (x = (yyn < 0 ? -yyn : 0);
                       x < (sizeof(yytname) / sizeof(char *)); x++)
                    if (yycheck[x + yyn] == x)
                      {
                        strcat(msg, count == 0 ? ", expecting `" : " or `");
                        strcat(msg, yytname[x]);
                        strcat(msg, "'");
                        count++;
                      }
                }
              yyerror(msg);
              free(msg);
            }
          else
            yyerror ("parse error; also virtual memory exceeded");
        }
      else
#endif /* YYERROR_VERBOSE */
        yyerror("parse error");
    }

  goto yyerrlab1;
yyerrlab1:   /* here on error raised explicitly by an action */

  if (yyerrstatus == 3)
    {
      /* if just tried and failed to reuse lookahead token after an error, discard it.  */

      /* return failure if at end of input */
      if (yychar == YYEOF)
        YYABORT;

#if YYDEBUG != 0
      if (yydebug)
        fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
#endif

      yychar = YYEMPTY;
    }

  /* Else will try to reuse lookahead token
     after shifting the error token.  */

  yyerrstatus = 3;              /* Each real token shifted decrements this */

  goto yyerrhandle;

yyerrdefault:  /* current state does not do anything special for the error token. */

#if 0
  /* This is wrong; only states that explicitly want error tokens
     should shift them.  */
  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  if (yyn) goto yydefault;
#endif

yyerrpop:   /* pop the current state because it cannot handle the error token */

  if (yyssp == yyss) YYABORT;
  yyvsp--;
  yystate = *--yyssp;
#ifdef YYLSP_NEEDED
  yylsp--;
#endif

#if YYDEBUG != 0
  if (yydebug)
    {
      short *ssp1 = yyss - 1;
      fprintf (stderr, "Error: state stack now");
      while (ssp1 != yyssp)
        fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

yyerrhandle:

  yyn = yypact[yystate];
  if (yyn == YYFLAG)
    goto yyerrdefault;

  yyn += YYTERROR;
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
    goto yyerrdefault;

  yyn = yytable[yyn];
  if (yyn < 0)
    {
      if (yyn == YYFLAG)
        goto yyerrpop;
      yyn = -yyn;
      goto yyreduce;
    }
  else if (yyn == 0)
    goto yyerrpop;

  if (yyn == YYFINAL)
    YYACCEPT;

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Shifting error token, ");
#endif

  *++yyvsp = yylval;
#ifdef YYLSP_NEEDED
  *++yylsp = yylloc;
#endif

  yystate = yyn;
  goto yynewstate;
}
#line 2208 "rpsl.y"


void enable_yy_parser_debugging() {
/* [<][>][^][v][top][bottom][index][help] */
#if YYDEBUG != 0
   yydebug = 1;
#endif
}

void handleArgumentTypeError(char *attr, char *method, int position,
/* [<][>][^][v][top][bottom][index][help] */
                             const RPType *correctType, 
                             bool isOperator = false) {
   if (isOperator)
      if (position)
         handle_error("Error: argument %d to %s.operator%s should be %s.\n",
                   position, attr, method, ((RPType *) correctType)->name());
      else
         handle_error("Error: wrong number of arguments to %s.operator%s.\n",
                      attr, method);
   else
      if (position)
         handle_error("Error: argument %d to %s.%s should be %s.\n",
                   position, attr, method, ((RPType *) correctType)->name());
      else
         handle_error("Error: wrong number of arguments to %s.%s.\n",
                      attr, method);
}

const AttrMethod *searchMethod(const AttrRPAttr *rp_attr, char *method, ItemList *args) {
/* [<][>][^][v][top][bottom][index][help] */
   const AttrMethod *mtd = rp_attr->searchMethod(method);
   int position;
   const RPType *correctType;
   
   if (!mtd) {
      handle_error("Error: rp-attribute %s does not have %s defined.\n",
                   rp_attr->name, method);
      return NULL;
   }
   
   for (; mtd; mtd = rp_attr->searchNextMethod(mtd))
      if (mtd->validateArgs(args, position, correctType))
         return mtd;

   handleArgumentTypeError(rp_attr->name, method, position, correctType);
   
   return NULL;
}

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