src/ftacmp/ext_fcns.tab.cc

   1 /* A Bison parser, made from ext_fcns.y, by GNU bison 1.75.  */\r
   2 \r
   3 /* Skeleton parser for Yacc-like parsing with Bison,\r
   4    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.\r
   5 \r
   6    This program is free software; you can redistribute it and/or modify\r
   7    it under the terms of the GNU General Public License as published by\r
   8    the Free Software Foundation; either version 2, or (at your option)\r
   9    any later version.\r
  10 \r
  11    This program is distributed in the hope that it will be useful,\r
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14    GNU General Public License for more details.\r
  15 \r
  16    You should have received a copy of the GNU General Public License\r
  17    along with this program; if not, write to the Free Software\r
  18    Foundation, Inc., 59 Temple Place - Suite 330,\r
  19    Boston, MA 02111-1307, USA.  */\r
  20 \r
  21 /* As a special exception, when this file is copied by Bison into a\r
  22    Bison output file, you may use that output file without restriction.\r
  23    This special exception was added by the Free Software Foundation\r
  24    in version 1.24 of Bison.  */\r
  25 \r
  26 /* Written by Richard Stallman by simplifying the original so called\r
  27    ``semantic'' parser.  */\r
  28 \r
  29 /* All symbols defined below should begin with yy or YY, to avoid\r
  30    infringing on user name space.  This should be done even for local\r
  31    variables, as they might otherwise be expanded by user macros.\r
  32    There are some unavoidable exceptions within include files to\r
  33    define necessary library symbols; they are noted "INFRINGES ON\r
  34    USER NAME SPACE" below.  */\r
  35 \r
  36 /* Identify Bison output.  */\r
  37 #define YYBISON 1\r
  38 \r
  39 /* Pure parsers.  */\r
  40 #define YYPURE  0\r
  41 \r
  42 /* Using locations.  */\r
  43 #define YYLSP_NEEDED 0\r
  44 \r
  45 /* If NAME_PREFIX is specified substitute the variables and functions\r
  46    names.  */\r
  47 #define yyparse Ext_fcnsParserparse\r
  48 #define yylex   Ext_fcnsParserlex\r
  49 #define yyerror Ext_fcnsParsererror\r
  50 #define yylval  Ext_fcnsParserlval\r
  51 #define yychar  Ext_fcnsParserchar\r
  52 #define yydebug Ext_fcnsParserdebug\r
  53 #define yynerrs Ext_fcnsParsernerrs\r
  54 \r
  55 \r
  56 /* Tokens.  */\r
  57 #ifndef YYTOKENTYPE\r
  58 # define YYTOKENTYPE\r
  59    /* Put the tokens into the symbol table, so that GDB and other debuggers\r
  60       know about them.  */\r
  61    enum yytokentype {\r
  62      NAME = 258,\r
  63      STRING_TOKEN = 259,\r
  64      INTNUM = 260,\r
  65      SEMICOLON = 261,\r
  66      HANDLE = 262,\r
  67      CONST = 263,\r
  68      CLASS = 264,\r
  69      FUN = 265,\r
  70      PRED = 266,\r
  71      EXTR = 267,\r
  72      UDAF = 268,\r
  73      STATE = 269,\r
  74      SFUN = 270\r
  75    };\r
  76 #endif\r
  77 #define NAME 258\r
  78 #define STRING_TOKEN 259\r
  79 #define INTNUM 260\r
  80 #define SEMICOLON 261\r
  81 #define HANDLE 262\r
  82 #define CONST 263\r
  83 #define CLASS 264\r
  84 #define FUN 265\r
  85 #define PRED 266\r
  86 #define EXTR 267\r
  87 #define UDAF 268\r
  88 #define STATE 269\r
  89 #define SFUN 270\r
  90 \r
  91 \r
  92 \r
  93 \r
  94 /* Copy the first part of user declarations.  */\r
  95 #line 8 "ext_fcns.y"\r
  96 \r
  97 \r
  98 \r
  99 #include <stdio.h>\r
 100 \r
 101 /*              Some addn'l includes, necessary but not included by the\r
 102                 bison generated code.\r
 103 */\r
 104 \r
 105 #include <stdlib.h>\r
 106 \r
 107 /*              prototypes for the parser callbacks.\r
 108 */\r
 109 \r
 110 #include "parse_ext_fcns.h"\r
 111 \r
 112 /*              Interface to ext_fcns parser    */\r
 113         int yyparse();\r
 114         void yyerror(char *s);\r
 115         int yylex();\r
 116 extern int flex_ext_fcns_lineno, flex_ext_fcns_ch;\r
 117 \r
 118 /*              Return value    */\r
 119 extern ext_fcn_list *Ext_fcns;\r
 120 \r
 121 #define YYDEBUG 1\r
 122 \r
 123 \r
 124 \r
 125 /* Enabling traces.  */\r
 126 #ifndef YYDEBUG\r
 127 # define YYDEBUG 0\r
 128 #endif\r
 129 \r
 130 /* Enabling verbose error messages.  */\r
 131 #ifdef YYERROR_VERBOSE\r
 132 # undef YYERROR_VERBOSE\r
 133 # define YYERROR_VERBOSE 1\r
 134 #else\r
 135 # define YYERROR_VERBOSE 0\r
 136 #endif\r
 137 \r
 138 #ifndef YYSTYPE\r
 139 #line 40 "ext_fcns.y"\r
 140 typedef union {\r
 141         char* strval;\r
 142         ext_fcn_list *ext_fcn_list_t;\r
 143         ext_fcn_def *ext_fcn_t;\r
 144         ext_fcn_param_list *plist_t;\r
 145         param_list *tplist_t;\r
 146         ext_fcn_param *param_t;\r
 147         ext_fcn_modifier_list *modif_t;\r
 148         } yystype;\r
 149 /* Line 193 of /usr/local/share/bison/yacc.c.  */\r
 150 #line 151 "ext_fcns.tab.cc"\r
 151 # define YYSTYPE yystype\r
 152 # define YYSTYPE_IS_TRIVIAL 1\r
 153 #endif\r
 154 \r
 155 #ifndef YYLTYPE\r
 156 typedef struct yyltype\r
 157 {\r
 158   int first_line;\r
 159   int first_column;\r
 160   int last_line;\r
 161   int last_column;\r
 162 } yyltype;\r
 163 # define YYLTYPE yyltype\r
 164 # define YYLTYPE_IS_TRIVIAL 1\r
 165 #endif\r
 166 \r
 167 /* Copy the second part of user declarations.  */\r
 168 \r
 169 \r
 170 /* Line 213 of /usr/local/share/bison/yacc.c.  */\r
 171 #line 172 "ext_fcns.tab.cc"\r
 172 \r
 173 #if ! defined (yyoverflow) || YYERROR_VERBOSE\r
 174 \r
 175 /* The parser invokes alloca or malloc; define the necessary symbols.  */\r
 176 \r
 177 # if YYSTACK_USE_ALLOCA\r
 178 #  define YYSTACK_ALLOC alloca\r
 179 # else\r
 180 #  ifndef YYSTACK_USE_ALLOCA\r
 181 #   if defined (alloca) || defined (_ALLOCA_H)\r
 182 #    define YYSTACK_ALLOC alloca\r
 183 #   else\r
 184 #    ifdef __GNUC__\r
 185 #     define YYSTACK_ALLOC __builtin_alloca\r
 186 #    endif\r
 187 #   endif\r
 188 #  endif\r
 189 # endif\r
 190 \r
 191 # ifdef YYSTACK_ALLOC\r
 192    /* Pacify GCC's `empty if-body' warning. */\r
 193 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)\r
 194 # else\r
 195 #  if defined (__STDC__) || defined (__cplusplus)\r
 196 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */\r
 197 #   define YYSIZE_T size_t\r
 198 #  endif\r
 199 #  define YYSTACK_ALLOC malloc\r
 200 #  define YYSTACK_FREE free\r
 201 # endif\r
 202 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */\r
 203 \r
 204 \r
 205 #if (! defined (yyoverflow) \\r
 206      && (! defined (__cplusplus) \\r
 207          || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))\r
 208 \r
 209 /* A type that is properly aligned for any stack member.  */\r
 210 union yyalloc\r
 211 {\r
 212   short yyss;\r
 213   YYSTYPE yyvs;\r
 214   };\r
 215 \r
 216 /* The size of the maximum gap between one aligned stack and the next.  */\r
 217 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)\r
 218 \r
 219 /* The size of an array large to enough to hold all stacks, each with\r
 220    N elements.  */\r
 221 # define YYSTACK_BYTES(N) \\r
 222      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \\r
 223       + YYSTACK_GAP_MAX)\r
 224 \r
 225 /* Copy COUNT objects from FROM to TO.  The source and destination do\r
 226    not overlap.  */\r
 227 # ifndef YYCOPY\r
 228 #  if 1 < __GNUC__\r
 229 #   define YYCOPY(To, From, Count) \\r
 230       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))\r
 231 #  else\r
 232 #   define YYCOPY(To, From, Count)              \\r
 233       do                                        \\r
 234         {                                       \\r
 235           register YYSIZE_T yyi;                \\r
 236           for (yyi = 0; yyi < (Count); yyi++)   \\r
 237             (To)[yyi] = (From)[yyi];    \\r
 238         }                                       \\r
 239       while (0)\r
 240 #  endif\r
 241 # endif\r
 242 \r
 243 /* Relocate STACK from its old location to the new one.  The\r
 244    local variables YYSIZE and YYSTACKSIZE give the old and new number of\r
 245    elements in the stack, and YYPTR gives the new location of the\r
 246    stack.  Advance YYPTR to a properly aligned location for the next\r
 247    stack.  */\r
 248 # define YYSTACK_RELOCATE(Stack)                                        \\r
 249     do                                                                  \\r
 250       {                                                                 \\r
 251         YYSIZE_T yynewbytes;                                            \\r
 252         YYCOPY (&yyptr->Stack, Stack, yysize);                          \\r
 253         Stack = &yyptr->Stack;                                          \\r
 254         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \\r
 255         yyptr += yynewbytes / sizeof (*yyptr);                          \\r
 256       }                                                                 \\r
 257     while (0)\r
 258 \r
 259 #endif\r
 260 \r
 261 #if defined (__STDC__) || defined (__cplusplus)\r
 262    typedef signed char yysigned_char;\r
 263 #else\r
 264    typedef short yysigned_char;\r
 265 #endif\r
 266 \r
 267 /* YYFINAL -- State number of the termination state. */\r
 268 #define YYFINAL  11\r
 269 #define YYLAST   136\r
 270 \r
 271 /* YYNTOKENS -- Number of terminals. */\r
 272 #define YYNTOKENS  21\r
 273 /* YYNNTS -- Number of nonterminals. */\r
 274 #define YYNNTS  10\r
 275 /* YYNRULES -- Number of rules. */\r
 276 #define YYNRULES  39\r
 277 /* YYNRULES -- Number of states. */\r
 278 #define YYNSTATES  117\r
 279 \r
 280 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */\r
 281 #define YYUNDEFTOK  2\r
 282 #define YYMAXUTOK   270\r
 283 \r
 284 #define YYTRANSLATE(X) \\r
 285   ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK)\r
 286 \r
 287 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */\r
 288 static const unsigned char yytranslate[] =\r
 289 {\r
 290        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 291        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 292        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 293        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 294       18,    19,     2,     2,    20,     2,     2,     2,     2,     2,\r
 295        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 296        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 297        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 298        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 299        2,    16,     2,    17,     2,     2,     2,     2,     2,     2,\r
 300        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 301        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 302        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 303        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 304        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 305        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 306        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 307        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 308        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 309        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 310        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 311        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 312        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 313        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 314        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,\r
 315        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,\r
 316        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,\r
 317       15\r
 318 };\r
 319 \r
 320 #if YYDEBUG\r
 321 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in\r
 322    YYRHS.  */\r
 323 static const unsigned char yyprhs[] =\r
 324 {\r
 325        0,     0,     3,     5,     7,    10,    22,    31,    41,    48,\r
 326       61,    71,    85,    96,   109,   119,   124,   125,   127,   129,\r
 327      132,   136,   141,   143,   147,   151,   155,   159,   164,   169,\r
 328      172,   173,   177,   179,   182,   185,   188,   192,   197,   202\r
 329 };\r
 330 \r
 331 /* YYRHS -- A `-1'-separated list of the rules' RHS. */\r
 332 static const yysigned_char yyrhs[] =\r
 333 {\r
 334       22,     0,    -1,    23,    -1,    24,    -1,    23,    24,    -1,\r
 335        3,    29,    10,    16,    26,    17,     3,    18,    25,    19,\r
 336        6,    -1,     3,    29,    10,     3,    18,    25,    19,     6,\r
 337       -1,    11,    16,    26,    17,     3,    16,    25,    17,     6,\r
 338       -1,    11,     3,    16,    25,    17,     6,    -1,     3,    29,\r
 339       13,    16,    26,    17,     3,     3,    18,    25,    19,     6,\r
 340       -1,     3,    29,    13,     3,     3,    18,    25,    19,     6,\r
 341       -1,     3,    29,    12,    16,    26,    17,     3,     3,     3,\r
 342       18,    25,    19,     6,    -1,     3,    29,    12,     3,     3,\r
 343        3,    18,    25,    19,     6,    -1,     3,    29,    15,    16,\r
 344       26,    17,     3,     3,    18,    25,    19,     6,    -1,     3,\r
 345       29,    15,     3,     3,    18,    25,    19,     6,    -1,     3,\r
 346       14,     3,     6,    -1,    -1,    27,    -1,     3,    -1,     3,\r
 347        3,    -1,    26,    20,     3,    -1,    26,    20,     3,     3,\r
 348       -1,    28,    -1,    27,    20,    28,    -1,     3,    29,     7,\r
 349       -1,     3,    29,     8,    -1,     3,    29,     9,    -1,     3,\r
 350       29,     7,     9,    -1,     3,    29,     8,     9,    -1,     3,\r
 351       29,    -1,    -1,    18,    30,    19,    -1,     3,    -1,     3,\r
 352        3,    -1,     3,     4,    -1,     3,     5,    -1,    30,    20,\r
 353        3,    -1,    30,    20,     3,     3,    -1,    30,    20,     3,\r
 354        4,    -1,    30,    20,     3,     5,    -1\r
 355 };\r
 356 \r
 357 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */\r
 358 static const unsigned char yyrline[] =\r
 359 {\r
 360        0,    75,    75,    78,    79,    82,    84,    86,    88,    90,\r
 361       92,    94,    96,    98,   100,   102,   107,   109,   112,   114,\r
 362      115,   116,   119,   121,   124,   126,   127,   128,   129,   130,\r
 363      134,   136,   139,   141,   142,   143,   144,   145,   146,   147\r
 364 };\r
 365 #endif\r
 366 \r
 367 #if YYDEBUG || YYERROR_VERBOSE\r
 368 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.\r
 369    First, the terminals, then, starting at YYNTOKENS, nonterminals. */\r
 370 static const char *const yytname[] =\r
 371 {\r
 372   "$end", "error", "$undefined", "NAME", "STRING_TOKEN", "INTNUM", \r
 373   "SEMICOLON", "HANDLE", "CONST", "CLASS", "FUN", "PRED", "EXTR", "UDAF", \r
 374   "STATE", "SFUN", "'['", "']'", "'('", "')'", "','", "$accept", "result", \r
 375   "fcn_list", "fcn_def", "opt_param_commalist", "modifier_list", \r
 376   "param_commalist", "param", "opt_type_param_commalist", \r
 377   "type_param_commalist", 0\r
 378 };\r
 379 #endif\r
 380 \r
 381 # ifdef YYPRINT\r
 382 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to\r
 383    token YYLEX-NUM.  */\r
 384 static const unsigned short yytoknum[] =\r
 385 {\r
 386        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,\r
 387      265,   266,   267,   268,   269,   270,    91,    93,    40,    41,\r
 388       44\r
 389 };\r
 390 # endif\r
 391 \r
 392 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */\r
 393 static const unsigned char yyr1[] =\r
 394 {\r
 395        0,    21,    22,    23,    23,    24,    24,    24,    24,    24,\r
 396       24,    24,    24,    24,    24,    24,    25,    25,    26,    26,\r
 397       26,    26,    27,    27,    28,    28,    28,    28,    28,    28,\r
 398       29,    29,    30,    30,    30,    30,    30,    30,    30,    30\r
 399 };\r
 400 \r
 401 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */\r
 402 static const unsigned char yyr2[] =\r
 403 {\r
 404        0,     2,     1,     1,     2,    11,     8,     9,     6,    12,\r
 405        9,    13,    10,    12,     9,     4,     0,     1,     1,     2,\r
 406        3,     4,     1,     3,     3,     3,     3,     4,     4,     2,\r
 407        0,     3,     1,     2,     2,     2,     3,     4,     4,     4\r
 408 };\r
 409 \r
 410 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state\r
 411    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero\r
 412    means the default is an error.  */\r
 413 static const unsigned char yydefact[] =\r
 414 {\r
 415        0,    30,     0,     0,     2,     3,     0,     0,     0,     0,\r
 416        0,     1,     4,     0,    32,     0,     0,     0,     0,     0,\r
 417       16,    18,     0,    15,    33,    34,    35,    31,     0,     0,\r
 418        0,     0,     0,     0,     0,     0,     0,    30,     0,    17,\r
 419       22,    19,     0,     0,    36,    16,     0,     0,     0,     0,\r
 420        0,     0,     0,    29,     0,     0,     0,    20,    37,    38,\r
 421       39,     0,     0,     0,     0,    16,     0,    16,     0,    24,\r
 422       25,    26,     8,    23,    16,    21,     0,     0,    16,     0,\r
 423        0,     0,     0,     0,    27,    28,     0,     6,    16,     0,\r
 424        0,     0,     0,     0,     0,     0,     0,     0,     0,    10,\r
 425       16,    14,    16,     7,     0,    12,    16,     0,     0,     5,\r
 426        0,     0,     0,     0,     9,    13,    11\r
 427 };\r
 428 \r
 429 /* YYDEFGOTO[NTERM-NUM]. */\r
 430 static const yysigned_char yydefgoto[] =\r
 431 {\r
 432       -1,     3,     4,     5,    38,    22,    39,    40,     8,    15\r
 433 };\r
 434 \r
 435 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing\r
 436    STATE-NUM.  */\r
 437 #define YYPACT_NINF -46\r
 438 static const yysigned_char yypact[] =\r
 439 {\r
 440        8,    -5,    -2,     7,     8,   -46,    25,    35,    11,     9,\r
 441       50,   -46,   -46,    48,    41,    22,    -1,     0,     1,     2,\r
 442       53,    55,    10,   -46,   -46,   -46,   -46,   -46,    56,    42,\r
 443       50,    59,    50,    60,    50,    61,    50,    47,    49,    51,\r
 444      -46,   -46,    64,    65,    44,    53,    14,    66,    15,    52,\r
 445       19,    54,    20,    43,    67,    53,    58,    72,   -46,   -46,\r
 446      -46,    57,    74,    62,    75,    53,    76,    53,    78,    73,\r
 447       77,   -46,   -46,   -46,    53,   -46,    79,    69,    53,    80,\r
 448       70,    81,    71,    85,   -46,   -46,    82,   -46,    53,    83,\r
 449       88,    86,    87,    89,    90,    91,    84,    92,    93,   -46,\r
 450       53,   -46,    53,   -46,    94,   -46,    53,    95,    96,   -46,\r
 451       97,    98,   100,   101,   -46,   -46,   -46\r
 452 };\r
 453 \r
 454 /* YYPGOTO[NTERM-NUM].  */\r
 455 static const yysigned_char yypgoto[] =\r
 456 {\r
 457      -46,   -46,   -46,   105,   -45,   -24,   -46,    38,    99,   -46\r
 458 };\r
 459 \r
 460 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If\r
 461    positive, shift that token.  If negative, reduce the rule which\r
 462    number is the opposite.  If zero, do what YYDEFACT says.\r
 463    If YYTABLE_NINF, parse error.  */\r
 464 #define YYTABLE_NINF -1\r
 465 static const unsigned char yytable[] =\r
 466 {\r
 467       61,     9,    29,    31,    33,    35,    46,    11,    48,     6,\r
 468       50,     1,    52,     7,    10,    30,    32,    34,    36,     2,\r
 469       80,    16,    82,    17,    18,    20,    19,    42,    13,    86,\r
 470       43,    62,    64,    89,    43,    43,    66,    68,    14,    43,\r
 471       43,    27,    28,    96,    24,    25,    26,    58,    59,    60,\r
 472       69,    70,    71,    21,    23,   107,    37,   108,    41,    44,\r
 473       45,   110,    47,    49,    51,     7,    54,    56,    57,    63,\r
 474       65,    55,    67,    72,    74,    75,    76,    77,    79,    81,\r
 475       78,    83,    84,    90,    92,    87,    85,    88,    94,    91,\r
 476       93,    98,    99,    73,     0,   101,     0,   103,   105,    95,\r
 477      109,     0,    97,   104,   114,   100,   115,   116,   102,    12,\r
 478        0,   106,     0,     0,   111,   112,   113,     0,     0,     0,\r
 479        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,\r
 480        0,     0,     0,     0,     0,     0,    53\r
 481 };\r
 482 \r
 483 static const yysigned_char yycheck[] =\r
 484 {\r
 485       45,     3,     3,     3,     3,     3,    30,     0,    32,    14,\r
 486       34,     3,    36,    18,    16,    16,    16,    16,    16,    11,\r
 487       65,    10,    67,    12,    13,    16,    15,    17,     3,    74,\r
 488       20,    17,    17,    78,    20,    20,    17,    17,     3,    20,\r
 489       20,    19,    20,    88,     3,     4,     5,     3,     4,     5,\r
 490        7,     8,     9,     3,     6,   100,     3,   102,     3,     3,\r
 491       18,   106,     3,     3,     3,    18,    17,     3,     3,     3,\r
 492       18,    20,    18,     6,    16,     3,    19,     3,     3,     3,\r
 493       18,     3,     9,     3,     3,     6,     9,    18,     3,    19,\r
 494       19,     3,     6,    55,    -1,     6,    -1,     6,     6,    17,\r
 495        6,    -1,    19,    19,     6,    18,     6,     6,    18,     4,\r
 496       -1,    18,    -1,    -1,    19,    19,    19,    -1,    -1,    -1,\r
 497       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,\r
 498       -1,    -1,    -1,    -1,    -1,    -1,    37\r
 499 };\r
 500 \r
 501 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing\r
 502    symbol of state STATE-NUM.  */\r
 503 static const unsigned char yystos[] =\r
 504 {\r
 505        0,     3,    11,    22,    23,    24,    14,    18,    29,     3,\r
 506       16,     0,    24,     3,     3,    30,    10,    12,    13,    15,\r
 507       16,     3,    26,     6,     3,     4,     5,    19,    20,     3,\r
 508       16,     3,    16,     3,    16,     3,    16,     3,    25,    27,\r
 509       28,     3,    17,    20,     3,    18,    26,     3,    26,     3,\r
 510       26,     3,    26,    29,    17,    20,     3,     3,     3,     4,\r
 511        5,    25,    17,     3,    17,    18,    17,    18,    17,     7,\r
 512        8,     9,     6,    28,    16,     3,    19,     3,    18,     3,\r
 513       25,     3,    25,     3,     9,     9,    25,     6,    18,    25,\r
 514        3,    19,     3,    19,     3,    17,    25,    19,     3,     6,\r
 515       18,     6,    18,     6,    19,     6,    18,    25,    25,     6,\r
 516       25,    19,    19,    19,     6,     6,     6\r
 517 };\r
 518 \r
 519 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)\r
 520 # define YYSIZE_T __SIZE_TYPE__\r
 521 #endif\r
 522 #if ! defined (YYSIZE_T) && defined (size_t)\r
 523 # define YYSIZE_T size_t\r
 524 #endif\r
 525 #if ! defined (YYSIZE_T)\r
 526 # if defined (__STDC__) || defined (__cplusplus)\r
 527 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */\r
 528 #  define YYSIZE_T size_t\r
 529 # endif\r
 530 #endif\r
 531 #if ! defined (YYSIZE_T)\r
 532 # define YYSIZE_T unsigned int\r
 533 #endif\r
 534 \r
 535 #define yyerrok         (yyerrstatus = 0)\r
 536 #define yyclearin       (yychar = YYEMPTY)\r
 537 #define YYEMPTY         -2\r
 538 #define YYEOF           0\r
 539 \r
 540 #define YYACCEPT        goto yyacceptlab\r
 541 #define YYABORT         goto yyabortlab\r
 542 #define YYERROR         goto yyerrlab1\r
 543 \r
 544 /* Like YYERROR except do call yyerror.  This remains here temporarily\r
 545    to ease the transition to the new meaning of YYERROR, for GCC.\r
 546    Once GCC version 2 has supplanted version 1, this can go.  */\r
 547 \r
 548 #define YYFAIL          goto yyerrlab\r
 549 \r
 550 #define YYRECOVERING()  (!!yyerrstatus)\r
 551 \r
 552 #define YYBACKUP(Token, Value)                                  \\r
 553 do                                                              \\r
 554   if (yychar == YYEMPTY && yylen == 1)                          \\r
 555     {                                                           \\r
 556       yychar = (Token);                                         \\r
 557       yylval = (Value);                                         \\r
 558       yychar1 = YYTRANSLATE (yychar);                           \\r
 559       YYPOPSTACK;                                               \\r
 560       goto yybackup;                                            \\r
 561     }                                                           \\r
 562   else                                                          \\r
 563     {                                                           \\r
 564       yyerror ("syntax error: cannot back up");                 \\r
 565       YYERROR;                                                  \\r
 566     }                                                           \\r
 567 while (0)\r
 568 \r
 569 #define YYTERROR        1\r
 570 #define YYERRCODE       256\r
 571 \r
 572 /* YYLLOC_DEFAULT -- Compute the default location (before the actions\r
 573    are run).  */\r
 574 \r
 575 #ifndef YYLLOC_DEFAULT\r
 576 # define YYLLOC_DEFAULT(Current, Rhs, N)           \\r
 577   Current.first_line   = Rhs[1].first_line;      \\r
 578   Current.first_column = Rhs[1].first_column;    \\r
 579   Current.last_line    = Rhs[N].last_line;       \\r
 580   Current.last_column  = Rhs[N].last_column;\r
 581 #endif\r
 582 \r
 583 /* YYLEX -- calling `yylex' with the right arguments.  */\r
 584 \r
 585 #define YYLEX   yylex ()\r
 586 \r
 587 /* Enable debugging if requested.  */\r
 588 #if YYDEBUG\r
 589 \r
 590 # ifndef YYFPRINTF\r
 591 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */\r
 592 #  define YYFPRINTF fprintf\r
 593 # endif\r
 594 \r
 595 # define YYDPRINTF(Args)                        \\r
 596 do {                                            \\r
 597   if (yydebug)                                  \\r
 598     YYFPRINTF Args;                             \\r
 599 } while (0)\r
 600 # define YYDSYMPRINT(Args)                      \\r
 601 do {                                            \\r
 602   if (yydebug)                                  \\r
 603     yysymprint Args;                            \\r
 604 } while (0)\r
 605 /* Nonzero means print parse trace.  It is left uninitialized so that\r
 606    multiple parsers can coexist.  */\r
 607 int yydebug;\r
 608 #else /* !YYDEBUG */\r
 609 # define YYDPRINTF(Args)\r
 610 # define YYDSYMPRINT(Args)\r
 611 #endif /* !YYDEBUG */\r
 612 \r
 613 /* YYINITDEPTH -- initial size of the parser's stacks.  */\r
 614 #ifndef YYINITDEPTH\r
 615 # define YYINITDEPTH 200\r
 616 #endif\r
 617 \r
 618 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only\r
 619    if the built-in stack extension method is used).\r
 620 \r
 621    Do not make this value too large; the results are undefined if\r
 622    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)\r
 623    evaluated with infinite-precision integer arithmetic.  */\r
 624 \r
 625 #if YYMAXDEPTH == 0\r
 626 # undef YYMAXDEPTH\r
 627 #endif\r
 628 \r
 629 #ifndef YYMAXDEPTH\r
 630 # define YYMAXDEPTH 10000\r
 631 #endif\r
 632 \r
 633 \f\r
 634 \r
 635 #if YYERROR_VERBOSE\r
 636 \r
 637 # ifndef yystrlen\r
 638 #  if defined (__GLIBC__) && defined (_STRING_H)\r
 639 #   define yystrlen strlen\r
 640 #  else\r
 641 /* Return the length of YYSTR.  */\r
 642 static YYSIZE_T\r
 643 #   if defined (__STDC__) || defined (__cplusplus)\r
 644 yystrlen (const char *yystr)\r
 645 #   else\r
 646 yystrlen (yystr)\r
 647      const char *yystr;\r
 648 #   endif\r
 649 {\r
 650   register const char *yys = yystr;\r
 651 \r
 652   while (*yys++ != '\0')\r
 653     continue;\r
 654 \r
 655   return yys - yystr - 1;\r
 656 }\r
 657 #  endif\r
 658 # endif\r
 659 \r
 660 # ifndef yystpcpy\r
 661 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)\r
 662 #   define yystpcpy stpcpy\r
 663 #  else\r
 664 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in\r
 665    YYDEST.  */\r
 666 static char *\r
 667 #   if defined (__STDC__) || defined (__cplusplus)\r
 668 yystpcpy (char *yydest, const char *yysrc)\r
 669 #   else\r
 670 yystpcpy (yydest, yysrc)\r
 671      char *yydest;\r
 672      const char *yysrc;\r
 673 #   endif\r
 674 {\r
 675   register char *yyd = yydest;\r
 676   register const char *yys = yysrc;\r
 677 \r
 678   while ((*yyd++ = *yys++) != '\0')\r
 679     continue;\r
 680 \r
 681   return yyd - 1;\r
 682 }\r
 683 #  endif\r
 684 # endif\r
 685 \r
 686 #endif /* !YYERROR_VERBOSE */\r
 687 \r
 688 \f\r
 689 \r
 690 #if YYDEBUG\r
 691 /*-----------------------------.\r
 692 | Print this symbol on YYOUT.  |\r
 693 `-----------------------------*/\r
 694 \r
 695 static void\r
 696 #if defined (__STDC__) || defined (__cplusplus)\r
 697 yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue)\r
 698 #else\r
 699 yysymprint (yyout, yytype, yyvalue)\r
 700     FILE* yyout;\r
 701     int yytype;\r
 702     YYSTYPE yyvalue;\r
 703 #endif\r
 704 {\r
 705   /* Pacify ``unused variable'' warnings.  */\r
 706   (void) yyvalue;\r
 707 \r
 708   if (yytype < YYNTOKENS)\r
 709     {\r
 710       YYFPRINTF (yyout, "token %s (", yytname[yytype]);\r
 711 # ifdef YYPRINT\r
 712       YYPRINT (yyout, yytoknum[yytype], yyvalue);\r
 713 # endif\r
 714     }\r
 715   else\r
 716     YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);\r
 717 \r
 718   switch (yytype)\r
 719     {\r
 720       default:\r
 721         break;\r
 722     }\r
 723   YYFPRINTF (yyout, ")");\r
 724 }\r
 725 #endif /* YYDEBUG. */\r
 726 \r
 727 \r
 728 /*-----------------------------------------------.\r
 729 | Release the memory associated to this symbol.  |\r
 730 `-----------------------------------------------*/\r
 731 \r
 732 static void\r
 733 #if defined (__STDC__) || defined (__cplusplus)\r
 734 yydestruct (int yytype, YYSTYPE yyvalue)\r
 735 #else\r
 736 yydestruct (yytype, yyvalue)\r
 737     int yytype;\r
 738     YYSTYPE yyvalue;\r
 739 #endif\r
 740 {\r
 741   /* Pacify ``unused variable'' warnings.  */\r
 742   (void) yyvalue;\r
 743 \r
 744   switch (yytype)\r
 745     {\r
 746       default:\r
 747         break;\r
 748     }\r
 749 }\r
 750 \r
 751 \f\r
 752 \r
 753 /* The user can define YYPARSE_PARAM as the name of an argument to be passed\r
 754    into yyparse.  The argument should have type void *.\r
 755    It should actually point to an object.\r
 756    Grammar actions can access the variable by casting it\r
 757    to the proper pointer type.  */\r
 758 \r
 759 #ifdef YYPARSE_PARAM\r
 760 # if defined (__STDC__) || defined (__cplusplus)\r
 761 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM\r
 762 #  define YYPARSE_PARAM_DECL\r
 763 # else\r
 764 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM\r
 765 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;\r
 766 # endif\r
 767 #else /* !YYPARSE_PARAM */\r
 768 # define YYPARSE_PARAM_ARG\r
 769 # define YYPARSE_PARAM_DECL\r
 770 #endif /* !YYPARSE_PARAM */\r
 771 \r
 772 /* Prevent warning if -Wstrict-prototypes.  */\r
 773 #ifdef __GNUC__\r
 774 # ifdef YYPARSE_PARAM\r
 775 int yyparse (void *);\r
 776 # else\r
 777 int yyparse (void);\r
 778 # endif\r
 779 #endif\r
 780 \r
 781 \r
 782 /* The lookahead symbol.  */\r
 783 int yychar;\r
 784 \r
 785 /* The semantic value of the lookahead symbol.  */\r
 786 YYSTYPE yylval;\r
 787 \r
 788 /* Number of parse errors so far.  */\r
 789 int yynerrs;\r
 790 \r
 791 \r
 792 int\r
 793 yyparse (YYPARSE_PARAM_ARG)\r
 794      YYPARSE_PARAM_DECL\r
 795 {\r
 796   \r
 797   register int yystate;\r
 798   register int yyn;\r
 799   int yyresult;\r
 800   /* Number of tokens to shift before error messages enabled.  */\r
 801   int yyerrstatus;\r
 802   /* Lookahead token as an internal (translated) token number.  */\r
 803   int yychar1 = 0;\r
 804 \r
 805   /* Three stacks and their tools:\r
 806      `yyss': related to states,\r
 807      `yyvs': related to semantic values,\r
 808      `yyls': related to locations.\r
 809 \r
 810      Refer to the stacks thru separate pointers, to allow yyoverflow\r
 811      to reallocate them elsewhere.  */\r
 812 \r
 813   /* The state stack.  */\r
 814   short yyssa[YYINITDEPTH];\r
 815   short *yyss = yyssa;\r
 816   register short *yyssp;\r
 817 \r
 818   /* The semantic value stack.  */\r
 819   YYSTYPE yyvsa[YYINITDEPTH];\r
 820   YYSTYPE *yyvs = yyvsa;\r
 821   register YYSTYPE *yyvsp;\r
 822 \r
 823 \r
 824 \r
 825 #define YYPOPSTACK   (yyvsp--, yyssp--)\r
 826 \r
 827   YYSIZE_T yystacksize = YYINITDEPTH;\r
 828 \r
 829   /* The variables used to return semantic value and location from the\r
 830      action routines.  */\r
 831   YYSTYPE yyval;\r
 832 \r
 833 \r
 834   /* When reducing, the number of symbols on the RHS of the reduced\r
 835      rule.  */\r
 836   int yylen;\r
 837 \r
 838   YYDPRINTF ((stderr, "Starting parse\n"));\r
 839 \r
 840   yystate = 0;\r
 841   yyerrstatus = 0;\r
 842   yynerrs = 0;\r
 843   yychar = YYEMPTY;             /* Cause a token to be read.  */\r
 844 \r
 845   /* Initialize stack pointers.\r
 846      Waste one element of value and location stack\r
 847      so that they stay on the same level as the state stack.\r
 848      The wasted elements are never initialized.  */\r
 849 \r
 850   yyssp = yyss;\r
 851   yyvsp = yyvs;\r
 852 \r
 853   goto yysetstate;\r
 854 \r
 855 /*------------------------------------------------------------.\r
 856 | yynewstate -- Push a new state, which is found in yystate.  |\r
 857 `------------------------------------------------------------*/\r
 858  yynewstate:\r
 859   /* In all cases, when you get here, the value and location stacks\r
 860      have just been pushed. so pushing a state here evens the stacks.\r
 861      */\r
 862   yyssp++;\r
 863 \r
 864  yysetstate:\r
 865   *yyssp = yystate;\r
 866 \r
 867   if (yyssp >= yyss + yystacksize - 1)\r
 868     {\r
 869       /* Get the current used size of the three stacks, in elements.  */\r
 870       YYSIZE_T yysize = yyssp - yyss + 1;\r
 871 \r
 872 #ifdef yyoverflow\r
 873       {\r
 874         /* Give user a chance to reallocate the stack. Use copies of\r
 875            these so that the &'s don't force the real ones into\r
 876            memory.  */\r
 877         YYSTYPE *yyvs1 = yyvs;\r
 878         short *yyss1 = yyss;\r
 879 \r
 880 \r
 881         /* Each stack pointer address is followed by the size of the\r
 882            data in use in that stack, in bytes.  This used to be a\r
 883            conditional around just the two extra args, but that might\r
 884            be undefined if yyoverflow is a macro.  */\r
 885         yyoverflow ("parser stack overflow",\r
 886                     &yyss1, yysize * sizeof (*yyssp),\r
 887                     &yyvs1, yysize * sizeof (*yyvsp),\r
 888 \r
 889                     &yystacksize);\r
 890 \r
 891         yyss = yyss1;\r
 892         yyvs = yyvs1;\r
 893       }\r
 894 #else /* no yyoverflow */\r
 895 # ifndef YYSTACK_RELOCATE\r
 896       goto yyoverflowlab;\r
 897 # else\r
 898       /* Extend the stack our own way.  */\r
 899       if (yystacksize >= YYMAXDEPTH)\r
 900         goto yyoverflowlab;\r
 901       yystacksize *= 2;\r
 902       if (yystacksize > YYMAXDEPTH)\r
 903         yystacksize = YYMAXDEPTH;\r
 904 \r
 905       {\r
 906         short *yyss1 = yyss;\r
 907         union yyalloc *yyptr =\r
 908           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));\r
 909         if (! yyptr)\r
 910           goto yyoverflowlab;\r
 911         YYSTACK_RELOCATE (yyss);\r
 912         YYSTACK_RELOCATE (yyvs);\r
 913 \r
 914 #  undef YYSTACK_RELOCATE\r
 915         if (yyss1 != yyssa)\r
 916           YYSTACK_FREE (yyss1);\r
 917       }\r
 918 # endif\r
 919 #endif /* no yyoverflow */\r
 920 \r
 921       yyssp = yyss + yysize - 1;\r
 922       yyvsp = yyvs + yysize - 1;\r
 923 \r
 924 \r
 925       YYDPRINTF ((stderr, "Stack size increased to %lu\n",\r
 926                   (unsigned long int) yystacksize));\r
 927 \r
 928       if (yyssp >= yyss + yystacksize - 1)\r
 929         YYABORT;\r
 930     }\r
 931 \r
 932   YYDPRINTF ((stderr, "Entering state %d\n", yystate));\r
 933 \r
 934   goto yybackup;\r
 935 \r
 936 /*-----------.\r
 937 | yybackup.  |\r
 938 `-----------*/\r
 939 yybackup:\r
 940 \r
 941 /* Do appropriate processing given the current state.  */\r
 942 /* Read a lookahead token if we need one and don't already have one.  */\r
 943 /* yyresume: */\r
 944 \r
 945   /* First try to decide what to do without reference to lookahead token.  */\r
 946 \r
 947   yyn = yypact[yystate];\r
 948   if (yyn == YYPACT_NINF)\r
 949     goto yydefault;\r
 950 \r
 951   /* Not known => get a lookahead token if don't already have one.  */\r
 952 \r
 953   /* yychar is either YYEMPTY or YYEOF\r
 954      or a valid token in external form.  */\r
 955 \r
 956   if (yychar == YYEMPTY)\r
 957     {\r
 958       YYDPRINTF ((stderr, "Reading a token: "));\r
 959       yychar = YYLEX;\r
 960     }\r
 961 \r
 962   /* Convert token to internal form (in yychar1) for indexing tables with.  */\r
 963 \r
 964   if (yychar <= 0)              /* This means end of input.  */\r
 965     {\r
 966       yychar1 = 0;\r
 967       yychar = YYEOF;           /* Don't call YYLEX any more.  */\r
 968 \r
 969       YYDPRINTF ((stderr, "Now at end of input.\n"));\r
 970     }\r
 971   else\r
 972     {\r
 973       yychar1 = YYTRANSLATE (yychar);\r
 974 \r
 975       /* We have to keep this `#if YYDEBUG', since we use variables\r
 976          which are defined only if `YYDEBUG' is set.  */\r
 977       YYDPRINTF ((stderr, "Next token is "));\r
 978       YYDSYMPRINT ((stderr, yychar1, yylval));\r
 979       YYDPRINTF ((stderr, "\n"));\r
 980     }\r
 981 \r
 982   /* If the proper action on seeing token YYCHAR1 is to reduce or to\r
 983      detect an error, take that action.  */\r
 984   yyn += yychar1;\r
 985   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)\r
 986     goto yydefault;\r
 987   yyn = yytable[yyn];\r
 988   if (yyn <= 0)\r
 989     {\r
 990       if (yyn == 0 || yyn == YYTABLE_NINF)\r
 991         goto yyerrlab;\r
 992       yyn = -yyn;\r
 993       goto yyreduce;\r
 994     }\r
 995 \r
 996   if (yyn == YYFINAL)\r
 997     YYACCEPT;\r
 998 \r
 999   /* Shift the lookahead token.  */\r
1000   YYDPRINTF ((stderr, "Shifting token %d (%s), ",\r
1001               yychar, yytname[yychar1]));\r
1002 \r
1003   /* Discard the token being shifted unless it is eof.  */\r
1004   if (yychar != YYEOF)\r
1005     yychar = YYEMPTY;\r
1006 \r
1007   *++yyvsp = yylval;\r
1008 \r
1009 \r
1010   /* Count tokens shifted since error; after three, turn off error\r
1011      status.  */\r
1012   if (yyerrstatus)\r
1013     yyerrstatus--;\r
1014 \r
1015   yystate = yyn;\r
1016   goto yynewstate;\r
1017 \r
1018 \r
1019 /*-----------------------------------------------------------.\r
1020 | yydefault -- do the default action for the current state.  |\r
1021 `-----------------------------------------------------------*/\r
1022 yydefault:\r
1023   yyn = yydefact[yystate];\r
1024   if (yyn == 0)\r
1025     goto yyerrlab;\r
1026   goto yyreduce;\r
1027 \r
1028 \r
1029 /*-----------------------------.\r
1030 | yyreduce -- Do a reduction.  |\r
1031 `-----------------------------*/\r
1032 yyreduce:\r
1033   /* yyn is the number of a rule to reduce with.  */\r
1034   yylen = yyr2[yyn];\r
1035 \r
1036   /* If YYLEN is nonzero, implement the default value of the action:\r
1037      `$$ = $1'.\r
1038 \r
1039      Otherwise, the following line sets YYVAL to garbage.\r
1040      This behavior is undocumented and Bison\r
1041      users should not rely upon it.  Assigning to YYVAL\r
1042      unconditionally makes the parser a bit smaller, and it avoids a\r
1043      GCC warning that YYVAL may be used uninitialized.  */\r
1044   yyval = yyvsp[1-yylen];\r
1045 \r
1046 \r
1047 \r
1048 #if YYDEBUG\r
1049   /* We have to keep this `#if YYDEBUG', since we use variables which\r
1050      are defined only if `YYDEBUG' is set.  */\r
1051   if (yydebug)\r
1052     {\r
1053       int yyi;\r
1054 \r
1055       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",\r
1056                  yyn - 1, yyrline[yyn]);\r
1057 \r
1058       /* Print the symbols being reduced, and their result.  */\r
1059       for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)\r
1060         YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);\r
1061       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);\r
1062     }\r
1063 #endif\r
1064   switch (yyn)\r
1065     {\r
1066         case 2:\r
1067 #line 75 "ext_fcns.y"\r
1068     {Ext_fcns = yyvsp[0].ext_fcn_list_t;}\r
1069     break;\r
1070 \r
1071   case 3:\r
1072 #line 78 "ext_fcns.y"\r
1073     {yyval.ext_fcn_list_t = new ext_fcn_list(yyvsp[0].ext_fcn_t);}\r
1074     break;\r
1075 \r
1076   case 4:\r
1077 #line 79 "ext_fcns.y"\r
1078     {yyval.ext_fcn_list_t = yyvsp[-1].ext_fcn_list_t->append_ext_fcn_def(yyvsp[0].ext_fcn_t);}\r
1079     break;\r
1080 \r
1081   case 5:\r
1082 #line 82 "ext_fcns.y"\r
1083     {\r
1084                                         yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-10].strval,yyvsp[-9].tplist_t,yyvsp[-6].modif_t,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-6].modif_t; delete yyvsp[-2].plist_t; }\r
1085     break;\r
1086 \r
1087   case 6:\r
1088 #line 84 "ext_fcns.y"\r
1089     {\r
1090                                         yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-7].strval,yyvsp[-6].tplist_t,NULL,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; }\r
1091     break;\r
1092 \r
1093   case 7:\r
1094 #line 86 "ext_fcns.y"\r
1095     {\r
1096                                         yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-6].modif_t,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-6].modif_t; delete yyvsp[-2].plist_t; }\r
1097     break;\r
1098 \r
1099   case 8:\r
1100 #line 88 "ext_fcns.y"\r
1101     {\r
1102                                         yyval.ext_fcn_t=new ext_fcn_def(NULL,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; }\r
1103     break;\r
1104 \r
1105   case 9:\r
1106 #line 90 "ext_fcns.y"\r
1107     {\r
1108                                         yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-11].strval,yyvsp[-10].tplist_t,yyvsp[-7].modif_t,yyvsp[-5].strval,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-7].modif_t; delete yyvsp[-2].plist_t; }\r
1109     break;\r
1110 \r
1111   case 10:\r
1112 #line 92 "ext_fcns.y"\r
1113     {\r
1114                                         yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-8].strval,yyvsp[-7].tplist_t,NULL,yyvsp[-5].strval,yyvsp[-4].strval, yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; }\r
1115     break;\r
1116 \r
1117   case 11:\r
1118 #line 94 "ext_fcns.y"\r
1119     {\r
1120                                         yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-12].strval,yyvsp[-11].tplist_t,yyvsp[-8].modif_t,yyvsp[-6].strval,yyvsp[-5].strval, yyvsp[-4].strval, yyvsp[-2].plist_t); delete yyvsp[-8].modif_t; delete yyvsp[-2].plist_t; }\r
1121     break;\r
1122 \r
1123   case 12:\r
1124 #line 96 "ext_fcns.y"\r
1125     {\r
1126                                         yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-9].strval,yyvsp[-8].tplist_t,NULL,yyvsp[-6].strval,yyvsp[-5].strval, yyvsp[-4].strval, yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; }\r
1127     break;\r
1128 \r
1129   case 13:\r
1130 #line 98 "ext_fcns.y"\r
1131     {\r
1132                                         yyval.ext_fcn_t=ext_fcn_def::make_sfun_def(yyvsp[-11].strval,yyvsp[-10].tplist_t,yyvsp[-7].modif_t,yyvsp[-5].strval,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; }\r
1133     break;\r
1134 \r
1135   case 14:\r
1136 #line 100 "ext_fcns.y"\r
1137     {\r
1138                                         yyval.ext_fcn_t=ext_fcn_def::make_sfun_def(yyvsp[-8].strval,yyvsp[-7].tplist_t,NULL,yyvsp[-5].strval,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; }\r
1139     break;\r
1140 \r
1141   case 15:\r
1142 #line 102 "ext_fcns.y"\r
1143     {\r
1144                                         yyval.ext_fcn_t=ext_fcn_def::make_state_def(yyvsp[-3].strval,yyvsp[-1].strval); }\r
1145     break;\r
1146 \r
1147   case 16:\r
1148 #line 108 "ext_fcns.y"\r
1149     {yyval.plist_t = NULL;}\r
1150     break;\r
1151 \r
1152   case 17:\r
1153 #line 109 "ext_fcns.y"\r
1154     {yyval.plist_t = yyvsp[0].plist_t;}\r
1155     break;\r
1156 \r
1157   case 18:\r
1158 #line 113 "ext_fcns.y"\r
1159     {yyval.modif_t = new ext_fcn_modifier_list(yyvsp[0].strval);}\r
1160     break;\r
1161 \r
1162   case 19:\r
1163 #line 114 "ext_fcns.y"\r
1164     {yyval.modif_t = new ext_fcn_modifier_list(yyvsp[-1].strval, yyvsp[0].strval);}\r
1165     break;\r
1166 \r
1167   case 20:\r
1168 #line 115 "ext_fcns.y"\r
1169     {yyval.modif_t = yyvsp[-2].modif_t->append(yyvsp[0].strval);        }\r
1170     break;\r
1171 \r
1172   case 21:\r
1173 #line 116 "ext_fcns.y"\r
1174     {yyval.modif_t = yyvsp[-3].modif_t->append(yyvsp[-1].strval, yyvsp[0].strval);      }\r
1175     break;\r
1176 \r
1177   case 22:\r
1178 #line 120 "ext_fcns.y"\r
1179     {yyval.plist_t = new ext_fcn_param_list(yyvsp[0].param_t);}\r
1180     break;\r
1181 \r
1182   case 23:\r
1183 #line 121 "ext_fcns.y"\r
1184     {yyval.plist_t = yyvsp[-2].plist_t->append(yyvsp[0].param_t);}\r
1185     break;\r
1186 \r
1187   case 24:\r
1188 #line 125 "ext_fcns.y"\r
1189     { yyval.param_t = new ext_fcn_param(yyvsp[-2].strval,yyvsp[-1].tplist_t,1,0,0);}\r
1190     break;\r
1191 \r
1192   case 25:\r
1193 #line 126 "ext_fcns.y"\r
1194     { yyval.param_t = new ext_fcn_param(yyvsp[-2].strval,yyvsp[-1].tplist_t,0,1,0);}\r
1195     break;\r
1196 \r
1197   case 26:\r
1198 #line 127 "ext_fcns.y"\r
1199     { yyval.param_t = new ext_fcn_param(yyvsp[-2].strval,yyvsp[-1].tplist_t,0,0,1);}\r
1200     break;\r
1201 \r
1202   case 27:\r
1203 #line 128 "ext_fcns.y"\r
1204     { yyval.param_t = new ext_fcn_param(yyvsp[-3].strval,yyvsp[-2].tplist_t,1,0,1);}\r
1205     break;\r
1206 \r
1207   case 28:\r
1208 #line 129 "ext_fcns.y"\r
1209     { yyval.param_t = new ext_fcn_param(yyvsp[-3].strval,yyvsp[-2].tplist_t,0,1,1);}\r
1210     break;\r
1211 \r
1212   case 29:\r
1213 #line 131 "ext_fcns.y"\r
1214     { yyval.param_t = new ext_fcn_param(yyvsp[-1].strval,yyvsp[0].tplist_t,0,0,0);}\r
1215     break;\r
1216 \r
1217   case 30:\r
1218 #line 135 "ext_fcns.y"\r
1219     {yyval.tplist_t = NULL;}\r
1220     break;\r
1221 \r
1222   case 31:\r
1223 #line 136 "ext_fcns.y"\r
1224     {yyval.tplist_t = yyvsp[-1].tplist_t;}\r
1225     break;\r
1226 \r
1227   case 32:\r
1228 #line 140 "ext_fcns.y"\r
1229     {yyval.tplist_t = new param_list(yyvsp[0].strval);}\r
1230     break;\r
1231 \r
1232   case 33:\r
1233 #line 141 "ext_fcns.y"\r
1234     {yyval.tplist_t = new param_list(yyvsp[-1].strval,yyvsp[0].strval);}\r
1235     break;\r
1236 \r
1237   case 34:\r
1238 #line 142 "ext_fcns.y"\r
1239     {yyval.tplist_t = new param_list(yyvsp[-1].strval,yyvsp[0].strval);}\r
1240     break;\r
1241 \r
1242   case 35:\r
1243 #line 143 "ext_fcns.y"\r
1244     {yyval.tplist_t = new param_list(yyvsp[-1].strval,yyvsp[0].strval);}\r
1245     break;\r
1246 \r
1247   case 36:\r
1248 #line 144 "ext_fcns.y"\r
1249     {yyval.tplist_t = yyvsp[-2].tplist_t->append(yyvsp[0].strval);}\r
1250     break;\r
1251 \r
1252   case 37:\r
1253 #line 145 "ext_fcns.y"\r
1254     {yyval.tplist_t = yyvsp[-3].tplist_t->append(yyvsp[-1].strval,yyvsp[0].strval);}\r
1255     break;\r
1256 \r
1257   case 38:\r
1258 #line 146 "ext_fcns.y"\r
1259     {yyval.tplist_t = yyvsp[-3].tplist_t->append(yyvsp[-1].strval,yyvsp[0].strval);}\r
1260     break;\r
1261 \r
1262   case 39:\r
1263 #line 147 "ext_fcns.y"\r
1264     {yyval.tplist_t = yyvsp[-3].tplist_t->append(yyvsp[-1].strval,yyvsp[0].strval);}\r
1265     break;\r
1266 \r
1267 \r
1268     }\r
1269 \r
1270 /* Line 1016 of /usr/local/share/bison/yacc.c.  */\r
1271 #line 1272 "ext_fcns.tab.cc"\r
1272 \f\r
1273   yyvsp -= yylen;\r
1274   yyssp -= yylen;\r
1275 \r
1276 \r
1277 #if YYDEBUG\r
1278   if (yydebug)\r
1279     {\r
1280       short *yyssp1 = yyss - 1;\r
1281       YYFPRINTF (stderr, "state stack now");\r
1282       while (yyssp1 != yyssp)\r
1283         YYFPRINTF (stderr, " %d", *++yyssp1);\r
1284       YYFPRINTF (stderr, "\n");\r
1285     }\r
1286 #endif\r
1287 \r
1288   *++yyvsp = yyval;\r
1289 \r
1290 \r
1291   /* Now `shift' the result of the reduction.  Determine what state\r
1292      that goes to, based on the state we popped back to and the rule\r
1293      number reduced by.  */\r
1294 \r
1295   yyn = yyr1[yyn];\r
1296 \r
1297   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;\r
1298   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)\r
1299     yystate = yytable[yystate];\r
1300   else\r
1301     yystate = yydefgoto[yyn - YYNTOKENS];\r
1302 \r
1303   goto yynewstate;\r
1304 \r
1305 \r
1306 /*------------------------------------.\r
1307 | yyerrlab -- here on detecting error |\r
1308 `------------------------------------*/\r
1309 yyerrlab:\r
1310   /* If not already recovering from an error, report this error.  */\r
1311   if (!yyerrstatus)\r
1312     {\r
1313       ++yynerrs;\r
1314 #if YYERROR_VERBOSE\r
1315       yyn = yypact[yystate];\r
1316 \r
1317       if (YYPACT_NINF < yyn && yyn < YYLAST)\r
1318         {\r
1319           YYSIZE_T yysize = 0;\r
1320           int yytype = YYTRANSLATE (yychar);\r
1321           char *yymsg;\r
1322           int yyx, yycount;\r
1323 \r
1324           yycount = 0;\r
1325           /* Start YYX at -YYN if negative to avoid negative indexes in\r
1326              YYCHECK.  */\r
1327           for (yyx = yyn < 0 ? -yyn : 0;\r
1328                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)\r
1329             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)\r
1330               yysize += yystrlen (yytname[yyx]) + 15, yycount++;\r
1331           yysize += yystrlen ("parse error, unexpected ") + 1;\r
1332           yysize += yystrlen (yytname[yytype]);\r
1333           yymsg = (char *) YYSTACK_ALLOC (yysize);\r
1334           if (yymsg != 0)\r
1335             {\r
1336               char *yyp = yystpcpy (yymsg, "parse error, unexpected ");\r
1337               yyp = yystpcpy (yyp, yytname[yytype]);\r
1338 \r
1339               if (yycount < 5)\r
1340                 {\r
1341                   yycount = 0;\r
1342                   for (yyx = yyn < 0 ? -yyn : 0;\r
1343                        yyx < (int) (sizeof (yytname) / sizeof (char *));\r
1344                        yyx++)\r
1345                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)\r
1346                       {\r
1347                         const char *yyq = ! yycount ? ", expecting " : " or ";\r
1348                         yyp = yystpcpy (yyp, yyq);\r
1349                         yyp = yystpcpy (yyp, yytname[yyx]);\r
1350                         yycount++;\r
1351                       }\r
1352                 }\r
1353               yyerror (yymsg);\r
1354               YYSTACK_FREE (yymsg);\r
1355             }\r
1356           else\r
1357             yyerror ("parse error; also virtual memory exhausted");\r
1358         }\r
1359       else\r
1360 #endif /* YYERROR_VERBOSE */\r
1361         yyerror ("parse error");\r
1362     }\r
1363   goto yyerrlab1;\r
1364 \r
1365 \r
1366 /*----------------------------------------------------.\r
1367 | yyerrlab1 -- error raised explicitly by an action.  |\r
1368 `----------------------------------------------------*/\r
1369 yyerrlab1:\r
1370   if (yyerrstatus == 3)\r
1371     {\r
1372       /* If just tried and failed to reuse lookahead token after an\r
1373          error, discard it.  */\r
1374 \r
1375       /* Return failure if at end of input.  */\r
1376       if (yychar == YYEOF)\r
1377         {\r
1378           /* Pop the error token.  */\r
1379           YYPOPSTACK;\r
1380           /* Pop the rest of the stack.  */\r
1381           while (yyssp > yyss)\r
1382             {\r
1383               YYDPRINTF ((stderr, "Error: popping "));\r
1384               YYDSYMPRINT ((stderr,\r
1385                             yystos[*yyssp],\r
1386                             *yyvsp));\r
1387               YYDPRINTF ((stderr, "\n"));\r
1388               yydestruct (yystos[*yyssp], *yyvsp);\r
1389               YYPOPSTACK;\r
1390             }\r
1391           YYABORT;\r
1392         }\r
1393 \r
1394       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",\r
1395                   yychar, yytname[yychar1]));\r
1396       yydestruct (yychar1, yylval);\r
1397       yychar = YYEMPTY;\r
1398     }\r
1399 \r
1400   /* Else will try to reuse lookahead token after shifting the error\r
1401      token.  */\r
1402 \r
1403   yyerrstatus = 3;      /* Each real token shifted decrements this.  */\r
1404 \r
1405   for (;;)\r
1406     {\r
1407       yyn = yypact[yystate];\r
1408       if (yyn != YYPACT_NINF)\r
1409         {\r
1410           yyn += YYTERROR;\r
1411           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)\r
1412             {\r
1413               yyn = yytable[yyn];\r
1414               if (0 < yyn)\r
1415                 break;\r
1416             }\r
1417         }\r
1418 \r
1419       /* Pop the current state because it cannot handle the error token.  */\r
1420       if (yyssp == yyss)\r
1421         YYABORT;\r
1422 \r
1423       YYDPRINTF ((stderr, "Error: popping "));\r
1424       YYDSYMPRINT ((stderr,\r
1425                     yystos[*yyssp], *yyvsp));\r
1426       YYDPRINTF ((stderr, "\n"));\r
1427 \r
1428       yydestruct (yystos[yystate], *yyvsp);\r
1429       yyvsp--;\r
1430       yystate = *--yyssp;\r
1431 \r
1432 \r
1433 #if YYDEBUG\r
1434       if (yydebug)\r
1435         {\r
1436           short *yyssp1 = yyss - 1;\r
1437           YYFPRINTF (stderr, "Error: state stack now");\r
1438           while (yyssp1 != yyssp)\r
1439             YYFPRINTF (stderr, " %d", *++yyssp1);\r
1440           YYFPRINTF (stderr, "\n");\r
1441         }\r
1442 #endif\r
1443     }\r
1444 \r
1445   if (yyn == YYFINAL)\r
1446     YYACCEPT;\r
1447 \r
1448   YYDPRINTF ((stderr, "Shifting error token, "));\r
1449 \r
1450   *++yyvsp = yylval;\r
1451 \r
1452 \r
1453   yystate = yyn;\r
1454   goto yynewstate;\r
1455 \r
1456 \r
1457 /*-------------------------------------.\r
1458 | yyacceptlab -- YYACCEPT comes here.  |\r
1459 `-------------------------------------*/\r
1460 yyacceptlab:\r
1461   yyresult = 0;\r
1462   goto yyreturn;\r
1463 \r
1464 /*-----------------------------------.\r
1465 | yyabortlab -- YYABORT comes here.  |\r
1466 `-----------------------------------*/\r
1467 yyabortlab:\r
1468   yyresult = 1;\r
1469   goto yyreturn;\r
1470 \r
1471 #ifndef yyoverflow\r
1472 /*----------------------------------------------.\r
1473 | yyoverflowlab -- parser overflow comes here.  |\r
1474 `----------------------------------------------*/\r
1475 yyoverflowlab:\r
1476   yyerror ("parser stack overflow");\r
1477   yyresult = 2;\r
1478   /* Fall through.  */\r
1479 #endif\r
1480 \r
1481 yyreturn:\r
1482 #ifndef yyoverflow\r
1483   if (yyss != yyssa)\r
1484     YYSTACK_FREE (yyss);\r
1485 #endif\r
1486   return yyresult;\r
1487 }\r
1488 \r
1489 \r
1490 #line 152 "ext_fcns.y"\r
1491 \r
1492  \r
1493 \r