1/* A Bison parser, made by GNU Bison 2.3. */ 2 3/* Skeleton implementation for Bison's Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 6 Free Software Foundation, Inc. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2, or (at your option) 11 any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street, Fifth Floor, 21 Boston, MA 02110-1301, USA. */ 22 23/* As a special exception, you may create a larger work that contains 24 part or all of the Bison parser skeleton and distribute that work 25 under terms of your choice, so long as that work isn't itself a 26 parser generator using the skeleton or a modified version thereof 27 as a parser skeleton. Alternatively, if you modify or redistribute 28 the parser skeleton itself, you may (at your option) remove this 29 special exception, which will cause the skeleton and the resulting 30 Bison output files to be licensed under the GNU General Public 31 License without this special exception. 32 33 This special exception was added by the Free Software Foundation in 34 version 2.2 of Bison. */ 35 36/* C LALR(1) parser skeleton written by Richard Stallman, by 37 simplifying the original so-called "semantic" parser. */ 38 39/* All symbols defined below should begin with yy or YY, to avoid 40 infringing on user name space. This should be done even for local 41 variables, as they might otherwise be expanded by user macros. 42 There are some unavoidable exceptions within include files to 43 define necessary library symbols; they are noted "INFRINGES ON 44 USER NAME SPACE" below. */ 45 46/* Identify Bison output. */ 47#define YYBISON 1 48 49/* Bison version. */ 50#define YYBISON_VERSION "2.3" 51 52/* Skeleton name. */ 53#define YYSKELETON_NAME "yacc.c" 54 55/* Pure parsers. */ 56#define YYPURE 0 57 58/* Using locations. */ 59#define YYLSP_NEEDED 0 60 61 62 63/* Tokens. */ 64#ifndef YYTOKENTYPE 65# define YYTOKENTYPE 66 /* Put the tokens into the symbol table, so that GDB and other debuggers 67 know about them. */ 68 enum yytokentype { 69 ID = 258, 70 HBLOCK = 259, 71 POUND = 260, 72 STRING = 261, 73 INCLUDE = 262, 74 IMPORT = 263, 75 INSERT = 264, 76 CHARCONST = 265, 77 NUM_INT = 266, 78 NUM_FLOAT = 267, 79 NUM_UNSIGNED = 268, 80 NUM_LONG = 269, 81 NUM_ULONG = 270, 82 NUM_LONGLONG = 271, 83 NUM_ULONGLONG = 272, 84 TYPEDEF = 273, 85 TYPE_INT = 274, 86 TYPE_UNSIGNED = 275, 87 TYPE_SHORT = 276, 88 TYPE_LONG = 277, 89 TYPE_FLOAT = 278, 90 TYPE_DOUBLE = 279, 91 TYPE_CHAR = 280, 92 TYPE_WCHAR = 281, 93 TYPE_VOID = 282, 94 TYPE_SIGNED = 283, 95 TYPE_BOOL = 284, 96 TYPE_COMPLEX = 285, 97 TYPE_TYPEDEF = 286, 98 TYPE_RAW = 287, 99 TYPE_NON_ISO_INT8 = 288, 100 TYPE_NON_ISO_INT16 = 289, 101 TYPE_NON_ISO_INT32 = 290, 102 TYPE_NON_ISO_INT64 = 291, 103 LPAREN = 292, 104 RPAREN = 293, 105 COMMA = 294, 106 SEMI = 295, 107 EXTERN = 296, 108 INIT = 297, 109 LBRACE = 298, 110 RBRACE = 299, 111 PERIOD = 300, 112 CONST_QUAL = 301, 113 VOLATILE = 302, 114 REGISTER = 303, 115 STRUCT = 304, 116 UNION = 305, 117 EQUAL = 306, 118 SIZEOF = 307, 119 MODULE = 308, 120 LBRACKET = 309, 121 RBRACKET = 310, 122 ILLEGAL = 311, 123 CONSTANT = 312, 124 NAME = 313, 125 RENAME = 314, 126 NAMEWARN = 315, 127 EXTEND = 316, 128 PRAGMA = 317, 129 FEATURE = 318, 130 VARARGS = 319, 131 ENUM = 320, 132 CLASS = 321, 133 TYPENAME = 322, 134 PRIVATE = 323, 135 PUBLIC = 324, 136 PROTECTED = 325, 137 COLON = 326, 138 STATIC = 327, 139 VIRTUAL = 328, 140 FRIEND = 329, 141 THROW = 330, 142 CATCH = 331, 143 EXPLICIT = 332, 144 USING = 333, 145 NAMESPACE = 334, 146 NATIVE = 335, 147 INLINE = 336, 148 TYPEMAP = 337, 149 EXCEPT = 338, 150 ECHO = 339, 151 APPLY = 340, 152 CLEAR = 341, 153 SWIGTEMPLATE = 342, 154 FRAGMENT = 343, 155 WARN = 344, 156 LESSTHAN = 345, 157 GREATERTHAN = 346, 158 MODULO = 347, 159 DELETE_KW = 348, 160 LESSTHANOREQUALTO = 349, 161 GREATERTHANOREQUALTO = 350, 162 EQUALTO = 351, 163 NOTEQUALTO = 352, 164 QUESTIONMARK = 353, 165 TYPES = 354, 166 PARMS = 355, 167 NONID = 356, 168 DSTAR = 357, 169 DCNOT = 358, 170 TEMPLATE = 359, 171 OPERATOR = 360, 172 COPERATOR = 361, 173 PARSETYPE = 362, 174 PARSEPARM = 363, 175 PARSEPARMS = 364, 176 CAST = 365, 177 LOR = 366, 178 LAND = 367, 179 OR = 368, 180 XOR = 369, 181 AND = 370, 182 RSHIFT = 371, 183 LSHIFT = 372, 184 MINUS = 373, 185 PLUS = 374, 186 MODULUS = 375, 187 SLASH = 376, 188 STAR = 377, 189 LNOT = 378, 190 NOT = 379, 191 UMINUS = 380, 192 DCOLON = 381 193 }; 194#endif 195/* Tokens. */ 196#define ID 258 197#define HBLOCK 259 198#define POUND 260 199#define STRING 261 200#define INCLUDE 262 201#define IMPORT 263 202#define INSERT 264 203#define CHARCONST 265 204#define NUM_INT 266 205#define NUM_FLOAT 267 206#define NUM_UNSIGNED 268 207#define NUM_LONG 269 208#define NUM_ULONG 270 209#define NUM_LONGLONG 271 210#define NUM_ULONGLONG 272 211#define TYPEDEF 273 212#define TYPE_INT 274 213#define TYPE_UNSIGNED 275 214#define TYPE_SHORT 276 215#define TYPE_LONG 277 216#define TYPE_FLOAT 278 217#define TYPE_DOUBLE 279 218#define TYPE_CHAR 280 219#define TYPE_WCHAR 281 220#define TYPE_VOID 282 221#define TYPE_SIGNED 283 222#define TYPE_BOOL 284 223#define TYPE_COMPLEX 285 224#define TYPE_TYPEDEF 286 225#define TYPE_RAW 287 226#define TYPE_NON_ISO_INT8 288 227#define TYPE_NON_ISO_INT16 289 228#define TYPE_NON_ISO_INT32 290 229#define TYPE_NON_ISO_INT64 291 230#define LPAREN 292 231#define RPAREN 293 232#define COMMA 294 233#define SEMI 295 234#define EXTERN 296 235#define INIT 297 236#define LBRACE 298 237#define RBRACE 299 238#define PERIOD 300 239#define CONST_QUAL 301 240#define VOLATILE 302 241#define REGISTER 303 242#define STRUCT 304 243#define UNION 305 244#define EQUAL 306 245#define SIZEOF 307 246#define MODULE 308 247#define LBRACKET 309 248#define RBRACKET 310 249#define ILLEGAL 311 250#define CONSTANT 312 251#define NAME 313 252#define RENAME 314 253#define NAMEWARN 315 254#define EXTEND 316 255#define PRAGMA 317 256#define FEATURE 318 257#define VARARGS 319 258#define ENUM 320 259#define CLASS 321 260#define TYPENAME 322 261#define PRIVATE 323 262#define PUBLIC 324 263#define PROTECTED 325 264#define COLON 326 265#define STATIC 327 266#define VIRTUAL 328 267#define FRIEND 329 268#define THROW 330 269#define CATCH 331 270#define EXPLICIT 332 271#define USING 333 272#define NAMESPACE 334 273#define NATIVE 335 274#define INLINE 336 275#define TYPEMAP 337 276#define EXCEPT 338 277#define ECHO 339 278#define APPLY 340 279#define CLEAR 341 280#define SWIGTEMPLATE 342 281#define FRAGMENT 343 282#define WARN 344 283#define LESSTHAN 345 284#define GREATERTHAN 346 285#define MODULO 347 286#define DELETE_KW 348 287#define LESSTHANOREQUALTO 349 288#define GREATERTHANOREQUALTO 350 289#define EQUALTO 351 290#define NOTEQUALTO 352 291#define QUESTIONMARK 353 292#define TYPES 354 293#define PARMS 355 294#define NONID 356 295#define DSTAR 357 296#define DCNOT 358 297#define TEMPLATE 359 298#define OPERATOR 360 299#define COPERATOR 361 300#define PARSETYPE 362 301#define PARSEPARM 363 302#define PARSEPARMS 364 303#define CAST 365 304#define LOR 366 305#define LAND 367 306#define OR 368 307#define XOR 369 308#define AND 370 309#define RSHIFT 371 310#define LSHIFT 372 311#define MINUS 373 312#define PLUS 374 313#define MODULUS 375 314#define SLASH 376 315#define STAR 377 316#define LNOT 378 317#define NOT 379 318#define UMINUS 380 319#define DCOLON 381 320 321 322 323 324/* Copy the first part of user declarations. */ 325#line 12 "parser.y" 326 327 328#define yylex yylex 329 330char cvsroot_parser_y[] = "$Id: parser.y 11582 2009-08-15 10:40:19Z wsfulton $"; 331 332#include "swig.h" 333#include "cparse.h" 334#include "preprocessor.h" 335#include <ctype.h> 336 337/* We do this for portability */ 338#undef alloca 339#define alloca malloc 340 341/* ----------------------------------------------------------------------------- 342 * Externals 343 * ----------------------------------------------------------------------------- */ 344 345int yyparse(); 346 347/* NEW Variables */ 348 349static Node *top = 0; /* Top of the generated parse tree */ 350static int unnamed = 0; /* Unnamed datatype counter */ 351static Hash *extendhash = 0; /* Hash table of added methods */ 352static Hash *classes = 0; /* Hash table of classes */ 353static Symtab *prev_symtab = 0; 354static Node *current_class = 0; 355String *ModuleName = 0; 356static Node *module_node = 0; 357static String *Classprefix = 0; 358static String *Namespaceprefix = 0; 359static int inclass = 0; 360static char *last_cpptype = 0; 361static int inherit_list = 0; 362static Parm *template_parameters = 0; 363static int extendmode = 0; 364static int compact_default_args = 0; 365static int template_reduce = 0; 366static int cparse_externc = 0; 367 368static int max_class_levels = 0; 369static int class_level = 0; 370static Node **class_decl = NULL; 371 372/* ----------------------------------------------------------------------------- 373 * Assist Functions 374 * ----------------------------------------------------------------------------- */ 375 376 377 378/* Called by the parser (yyparse) when an error is found.*/ 379static void yyerror (const char *e) { 380 (void)e; 381} 382 383static Node *new_node(const_String_or_char_ptr tag) { 384 Node *n = NewHash(); 385 set_nodeType(n,tag); 386 Setfile(n,cparse_file); 387 Setline(n,cparse_line); 388 return n; 389} 390 391/* Copies a node. Does not copy tree links or symbol table data (except for 392 sym:name) */ 393 394static Node *copy_node(Node *n) { 395 Node *nn; 396 Iterator k; 397 nn = NewHash(); 398 Setfile(nn,Getfile(n)); 399 Setline(nn,Getline(n)); 400 for (k = First(n); k.key; k = Next(k)) { 401 String *ci; 402 String *key = k.key; 403 char *ckey = Char(key); 404 if ((strcmp(ckey,"nextSibling") == 0) || 405 (strcmp(ckey,"previousSibling") == 0) || 406 (strcmp(ckey,"parentNode") == 0) || 407 (strcmp(ckey,"lastChild") == 0)) { 408 continue; 409 } 410 if (Strncmp(key,"csym:",5) == 0) continue; 411 /* We do copy sym:name. For templates */ 412 if ((strcmp(ckey,"sym:name") == 0) || 413 (strcmp(ckey,"sym:weak") == 0) || 414 (strcmp(ckey,"sym:typename") == 0)) { 415 String *ci = Copy(k.item); 416 Setattr(nn,key, ci); 417 Delete(ci); 418 continue; 419 } 420 if (strcmp(ckey,"sym:symtab") == 0) { 421 Setattr(nn,"sym:needs_symtab", "1"); 422 } 423 /* We don't copy any other symbol table attributes */ 424 if (strncmp(ckey,"sym:",4) == 0) { 425 continue; 426 } 427 /* If children. We copy them recursively using this function */ 428 if (strcmp(ckey,"firstChild") == 0) { 429 /* Copy children */ 430 Node *cn = k.item; 431 while (cn) { 432 Node *copy = copy_node(cn); 433 appendChild(nn,copy); 434 Delete(copy); 435 cn = nextSibling(cn); 436 } 437 continue; 438 } 439 /* We don't copy the symbol table. But we drop an attribute 440 requires_symtab so that functions know it needs to be built */ 441 442 if (strcmp(ckey,"symtab") == 0) { 443 /* Node defined a symbol table. */ 444 Setattr(nn,"requires_symtab","1"); 445 continue; 446 } 447 /* Can't copy nodes */ 448 if (strcmp(ckey,"node") == 0) { 449 continue; 450 } 451 if ((strcmp(ckey,"parms") == 0) || (strcmp(ckey,"pattern") == 0) || (strcmp(ckey,"throws") == 0) 452 || (strcmp(ckey,"kwargs") == 0)) { 453 ParmList *pl = CopyParmList(k.item); 454 Setattr(nn,key,pl); 455 Delete(pl); 456 continue; 457 } 458 /* Looks okay. Just copy the data using Copy */ 459 ci = Copy(k.item); 460 Setattr(nn, key, ci); 461 Delete(ci); 462 } 463 return nn; 464} 465 466/* ----------------------------------------------------------------------------- 467 * Variables 468 * ----------------------------------------------------------------------------- */ 469 470static char *typemap_lang = 0; /* Current language setting */ 471 472static int cplus_mode = 0; 473static String *class_rename = 0; 474 475/* C++ modes */ 476 477#define CPLUS_PUBLIC 1 478#define CPLUS_PRIVATE 2 479#define CPLUS_PROTECTED 3 480 481/* include types */ 482static int import_mode = 0; 483 484void SWIG_typemap_lang(const char *tm_lang) { 485 typemap_lang = Swig_copy_string(tm_lang); 486} 487 488void SWIG_cparse_set_compact_default_args(int defargs) { 489 compact_default_args = defargs; 490} 491 492int SWIG_cparse_template_reduce(int treduce) { 493 template_reduce = treduce; 494 return treduce; 495} 496 497/* ----------------------------------------------------------------------------- 498 * Assist functions 499 * ----------------------------------------------------------------------------- */ 500 501static int promote_type(int t) { 502 if (t <= T_UCHAR || t == T_CHAR) return T_INT; 503 return t; 504} 505 506/* Perform type-promotion for binary operators */ 507static int promote(int t1, int t2) { 508 t1 = promote_type(t1); 509 t2 = promote_type(t2); 510 return t1 > t2 ? t1 : t2; 511} 512 513static String *yyrename = 0; 514 515/* Forward renaming operator */ 516 517static String *resolve_node_scope(String *cname); 518 519 520Hash *Swig_cparse_features(void) { 521 static Hash *features_hash = 0; 522 if (!features_hash) features_hash = NewHash(); 523 return features_hash; 524} 525 526static String *feature_identifier_fix(String *s) { 527 if (SwigType_istemplate(s)) { 528 String *tp, *ts, *ta, *tq; 529 tp = SwigType_templateprefix(s); 530 ts = SwigType_templatesuffix(s); 531 ta = SwigType_templateargs(s); 532 tq = Swig_symbol_type_qualify(ta,0); 533 Append(tp,tq); 534 Append(tp,ts); 535 Delete(ts); 536 Delete(ta); 537 Delete(tq); 538 return tp; 539 } else { 540 return NewString(s); 541 } 542} 543 544/* Generate the symbol table name for an object */ 545/* This is a bit of a mess. Need to clean up */ 546static String *add_oldname = 0; 547 548 549 550static String *make_name(Node *n, String *name,SwigType *decl) { 551 int destructor = name && (*(Char(name)) == '~'); 552 553 if (yyrename) { 554 String *s = NewString(yyrename); 555 Delete(yyrename); 556 yyrename = 0; 557 if (destructor && (*(Char(s)) != '~')) { 558 Insert(s,0,"~"); 559 } 560 return s; 561 } 562 563 if (!name) return 0; 564 return Swig_name_make(n,Namespaceprefix,name,decl,add_oldname); 565} 566 567/* Generate an unnamed identifier */ 568static String *make_unnamed() { 569 unnamed++; 570 return NewStringf("$unnamed%d$",unnamed); 571} 572 573/* Return if the node is a friend declaration */ 574static int is_friend(Node *n) { 575 return Cmp(Getattr(n,"storage"),"friend") == 0; 576} 577 578static int is_operator(String *name) { 579 return Strncmp(name,"operator ", 9) == 0; 580} 581 582 583/* Add declaration list to symbol table */ 584static int add_only_one = 0; 585 586static void add_symbols(Node *n) { 587 String *decl; 588 String *wrn = 0; 589 if (inclass && n) { 590 cparse_normalize_void(n); 591 } 592 while (n) { 593 String *symname = 0; 594 /* for friends, we need to pop the scope once */ 595 String *old_prefix = 0; 596 Symtab *old_scope = 0; 597 int isfriend = inclass && is_friend(n); 598 int iscdecl = Cmp(nodeType(n),"cdecl") == 0; 599 int only_csymbol = 0; 600 if (extendmode) { 601 Setattr(n,"isextension","1"); 602 } 603 604 if (inclass) { 605 String *name = Getattr(n, "name"); 606 if (isfriend) { 607 /* for friends, we need to add the scopename if needed */ 608 String *prefix = name ? Swig_scopename_prefix(name) : 0; 609 old_prefix = Namespaceprefix; 610 old_scope = Swig_symbol_popscope(); 611 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 612 if (!prefix) { 613 if (name && !is_operator(name) && Namespaceprefix) { 614 String *nname = NewStringf("%s::%s", Namespaceprefix, name); 615 Setattr(n,"name",nname); 616 Delete(nname); 617 } 618 } else { 619 Symtab *st = Swig_symbol_getscope(prefix); 620 String *ns = st ? Getattr(st,"name") : prefix; 621 String *base = Swig_scopename_last(name); 622 String *nname = NewStringf("%s::%s", ns, base); 623 Setattr(n,"name",nname); 624 Delete(nname); 625 Delete(base); 626 Delete(prefix); 627 } 628 Namespaceprefix = 0; 629 } else { 630 /* for member functions, we need to remove the redundant 631 class scope if provided, as in 632 633 struct Foo { 634 int Foo::method(int a); 635 }; 636 637 */ 638 String *prefix = name ? Swig_scopename_prefix(name) : 0; 639 if (prefix) { 640 if (Classprefix && (Equal(prefix,Classprefix))) { 641 String *base = Swig_scopename_last(name); 642 Setattr(n,"name",base); 643 Delete(base); 644 } 645 Delete(prefix); 646 } 647 648 /* 649 if (!Getattr(n,"parentNode") && class_level) set_parentNode(n,class_decl[class_level - 1]); 650 */ 651 Setattr(n,"ismember","1"); 652 } 653 } 654 if (!isfriend && inclass) { 655 if ((cplus_mode != CPLUS_PUBLIC)) { 656 only_csymbol = 1; 657 if (cplus_mode == CPLUS_PROTECTED) { 658 Setattr(n,"access", "protected"); 659 only_csymbol = !Swig_need_protected(n); 660 } else { 661 Setattr(n,"access", "private"); 662 /* private are needed only when they are pure virtuals - why? */ 663 if ((Cmp(Getattr(n,"storage"),"virtual") == 0) && (Cmp(Getattr(n,"value"),"0") == 0)) { 664 only_csymbol = 0; 665 } 666 } 667 } else { 668 Setattr(n,"access", "public"); 669 } 670 } 671 if (Getattr(n,"sym:name")) { 672 n = nextSibling(n); 673 continue; 674 } 675 decl = Getattr(n,"decl"); 676 if (!SwigType_isfunction(decl)) { 677 String *name = Getattr(n,"name"); 678 String *makename = Getattr(n,"parser:makename"); 679 if (iscdecl) { 680 String *storage = Getattr(n, "storage"); 681 if (Cmp(storage,"typedef") == 0) { 682 Setattr(n,"kind","typedef"); 683 } else { 684 SwigType *type = Getattr(n,"type"); 685 String *value = Getattr(n,"value"); 686 Setattr(n,"kind","variable"); 687 if (value && Len(value)) { 688 Setattr(n,"hasvalue","1"); 689 } 690 if (type) { 691 SwigType *ty; 692 SwigType *tmp = 0; 693 if (decl) { 694 ty = tmp = Copy(type); 695 SwigType_push(ty,decl); 696 } else { 697 ty = type; 698 } 699 if (!SwigType_ismutable(ty)) { 700 SetFlag(n,"hasconsttype"); 701 SetFlag(n,"feature:immutable"); 702 } 703 if (tmp) Delete(tmp); 704 } 705 if (!type) { 706 Printf(stderr,"notype name %s\n", name); 707 } 708 } 709 } 710 Swig_features_get(Swig_cparse_features(), Namespaceprefix, name, 0, n); 711 if (makename) { 712 symname = make_name(n, makename,0); 713 Delattr(n,"parser:makename"); /* temporary information, don't leave it hanging around */ 714 } else { 715 makename = name; 716 symname = make_name(n, makename,0); 717 } 718 719 if (!symname) { 720 symname = Copy(Getattr(n,"unnamed")); 721 } 722 if (symname) { 723 wrn = Swig_name_warning(n, Namespaceprefix, symname,0); 724 } 725 } else { 726 String *name = Getattr(n,"name"); 727 SwigType *fdecl = Copy(decl); 728 SwigType *fun = SwigType_pop_function(fdecl); 729 if (iscdecl) { 730 Setattr(n,"kind","function"); 731 } 732 733 Swig_features_get(Swig_cparse_features(),Namespaceprefix,name,fun,n); 734 735 symname = make_name(n, name,fun); 736 wrn = Swig_name_warning(n, Namespaceprefix,symname,fun); 737 738 Delete(fdecl); 739 Delete(fun); 740 741 } 742 if (!symname) { 743 n = nextSibling(n); 744 continue; 745 } 746 if (only_csymbol || GetFlag(n,"feature:ignore")) { 747 /* Only add to C symbol table and continue */ 748 Swig_symbol_add(0, n); 749 } else if (strncmp(Char(symname),"$ignore",7) == 0) { 750 char *c = Char(symname)+7; 751 SetFlag(n,"feature:ignore"); 752 if (strlen(c)) { 753 SWIG_WARN_NODE_BEGIN(n); 754 Swig_warning(0,Getfile(n), Getline(n), "%s\n",c+1); 755 SWIG_WARN_NODE_END(n); 756 } 757 Swig_symbol_add(0, n); 758 } else { 759 Node *c; 760 if ((wrn) && (Len(wrn))) { 761 String *metaname = symname; 762 if (!Getmeta(metaname,"already_warned")) { 763 SWIG_WARN_NODE_BEGIN(n); 764 Swig_warning(0,Getfile(n),Getline(n), "%s\n", wrn); 765 SWIG_WARN_NODE_END(n); 766 Setmeta(metaname,"already_warned","1"); 767 } 768 } 769 c = Swig_symbol_add(symname,n); 770 771 if (c != n) { 772 /* symbol conflict attempting to add in the new symbol */ 773 if (Getattr(n,"sym:weak")) { 774 Setattr(n,"sym:name",symname); 775 } else { 776 String *e = NewStringEmpty(); 777 String *en = NewStringEmpty(); 778 String *ec = NewStringEmpty(); 779 int redefined = Swig_need_redefined_warn(n,c,inclass); 780 if (redefined) { 781 Printf(en,"Identifier '%s' redefined (ignored)",symname); 782 Printf(ec,"previous definition of '%s'",symname); 783 } else { 784 Printf(en,"Redundant redeclaration of '%s'",symname); 785 Printf(ec,"previous declaration of '%s'",symname); 786 } 787 if (Cmp(symname,Getattr(n,"name"))) { 788 Printf(en," (Renamed from '%s')", SwigType_namestr(Getattr(n,"name"))); 789 } 790 Printf(en,","); 791 if (Cmp(symname,Getattr(c,"name"))) { 792 Printf(ec," (Renamed from '%s')", SwigType_namestr(Getattr(c,"name"))); 793 } 794 Printf(ec,"."); 795 SWIG_WARN_NODE_BEGIN(n); 796 if (redefined) { 797 Swig_warning(WARN_PARSE_REDEFINED,Getfile(n),Getline(n),"%s\n",en); 798 Swig_warning(WARN_PARSE_REDEFINED,Getfile(c),Getline(c),"%s\n",ec); 799 } else if (!is_friend(n) && !is_friend(c)) { 800 Swig_warning(WARN_PARSE_REDUNDANT,Getfile(n),Getline(n),"%s\n",en); 801 Swig_warning(WARN_PARSE_REDUNDANT,Getfile(c),Getline(c),"%s\n",ec); 802 } 803 SWIG_WARN_NODE_END(n); 804 Printf(e,"%s:%d:%s\n%s:%d:%s\n",Getfile(n),Getline(n),en, 805 Getfile(c),Getline(c),ec); 806 Setattr(n,"error",e); 807 Delete(e); 808 Delete(en); 809 Delete(ec); 810 } 811 } 812 } 813 /* restore the class scope if needed */ 814 if (isfriend) { 815 Swig_symbol_setscope(old_scope); 816 if (old_prefix) { 817 Delete(Namespaceprefix); 818 Namespaceprefix = old_prefix; 819 } 820 } 821 Delete(symname); 822 823 if (add_only_one) return; 824 n = nextSibling(n); 825 } 826} 827 828 829/* add symbols a parse tree node copy */ 830 831static void add_symbols_copy(Node *n) { 832 String *name; 833 int emode = 0; 834 while (n) { 835 char *cnodeType = Char(nodeType(n)); 836 837 if (strcmp(cnodeType,"access") == 0) { 838 String *kind = Getattr(n,"kind"); 839 if (Strcmp(kind,"public") == 0) { 840 cplus_mode = CPLUS_PUBLIC; 841 } else if (Strcmp(kind,"private") == 0) { 842 cplus_mode = CPLUS_PRIVATE; 843 } else if (Strcmp(kind,"protected") == 0) { 844 cplus_mode = CPLUS_PROTECTED; 845 } 846 n = nextSibling(n); 847 continue; 848 } 849 850 add_oldname = Getattr(n,"sym:name"); 851 if ((add_oldname) || (Getattr(n,"sym:needs_symtab"))) { 852 if (add_oldname) { 853 DohIncref(add_oldname); 854 /* Disable this, it prevents %rename to work with templates */ 855 /* If already renamed, we used that name */ 856 /* 857 if (Strcmp(add_oldname, Getattr(n,"name")) != 0) { 858 Delete(yyrename); 859 yyrename = Copy(add_oldname); 860 } 861 */ 862 } 863 Delattr(n,"sym:needs_symtab"); 864 Delattr(n,"sym:name"); 865 866 add_only_one = 1; 867 add_symbols(n); 868 869 if (Getattr(n,"partialargs")) { 870 Swig_symbol_cadd(Getattr(n,"partialargs"),n); 871 } 872 add_only_one = 0; 873 name = Getattr(n,"name"); 874 if (Getattr(n,"requires_symtab")) { 875 Swig_symbol_newscope(); 876 Swig_symbol_setscopename(name); 877 Delete(Namespaceprefix); 878 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 879 } 880 if (strcmp(cnodeType,"class") == 0) { 881 inclass = 1; 882 current_class = n; 883 if (Strcmp(Getattr(n,"kind"),"class") == 0) { 884 cplus_mode = CPLUS_PRIVATE; 885 } else { 886 cplus_mode = CPLUS_PUBLIC; 887 } 888 } 889 if (strcmp(cnodeType,"extend") == 0) { 890 emode = cplus_mode; 891 cplus_mode = CPLUS_PUBLIC; 892 } 893 add_symbols_copy(firstChild(n)); 894 if (strcmp(cnodeType,"extend") == 0) { 895 cplus_mode = emode; 896 } 897 if (Getattr(n,"requires_symtab")) { 898 Setattr(n,"symtab", Swig_symbol_popscope()); 899 Delattr(n,"requires_symtab"); 900 Delete(Namespaceprefix); 901 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 902 } 903 if (add_oldname) { 904 Delete(add_oldname); 905 add_oldname = 0; 906 } 907 if (strcmp(cnodeType,"class") == 0) { 908 inclass = 0; 909 current_class = 0; 910 } 911 } else { 912 if (strcmp(cnodeType,"extend") == 0) { 913 emode = cplus_mode; 914 cplus_mode = CPLUS_PUBLIC; 915 } 916 add_symbols_copy(firstChild(n)); 917 if (strcmp(cnodeType,"extend") == 0) { 918 cplus_mode = emode; 919 } 920 } 921 n = nextSibling(n); 922 } 923} 924 925/* Extension merge. This function is used to handle the %extend directive 926 when it appears before a class definition. To handle this, the %extend 927 actually needs to take precedence. Therefore, we will selectively nuke symbols 928 from the current symbol table, replacing them with the added methods */ 929 930static void merge_extensions(Node *cls, Node *am) { 931 Node *n; 932 Node *csym; 933 934 n = firstChild(am); 935 while (n) { 936 String *symname; 937 if (Strcmp(nodeType(n),"constructor") == 0) { 938 symname = Getattr(n,"sym:name"); 939 if (symname) { 940 if (Strcmp(symname,Getattr(n,"name")) == 0) { 941 /* If the name and the sym:name of a constructor are the same, 942 then it hasn't been renamed. However---the name of the class 943 itself might have been renamed so we need to do a consistency 944 check here */ 945 if (Getattr(cls,"sym:name")) { 946 Setattr(n,"sym:name", Getattr(cls,"sym:name")); 947 } 948 } 949 } 950 } 951 952 symname = Getattr(n,"sym:name"); 953 DohIncref(symname); 954 if ((symname) && (!Getattr(n,"error"))) { 955 /* Remove node from its symbol table */ 956 Swig_symbol_remove(n); 957 csym = Swig_symbol_add(symname,n); 958 if (csym != n) { 959 /* Conflict with previous definition. Nuke previous definition */ 960 String *e = NewStringEmpty(); 961 String *en = NewStringEmpty(); 962 String *ec = NewStringEmpty(); 963 Printf(ec,"Identifier '%s' redefined by %%extend (ignored),",symname); 964 Printf(en,"%%extend definition of '%s'.",symname); 965 SWIG_WARN_NODE_BEGIN(n); 966 Swig_warning(WARN_PARSE_REDEFINED,Getfile(csym),Getline(csym),"%s\n",ec); 967 Swig_warning(WARN_PARSE_REDEFINED,Getfile(n),Getline(n),"%s\n",en); 968 SWIG_WARN_NODE_END(n); 969 Printf(e,"%s:%d:%s\n%s:%d:%s\n",Getfile(csym),Getline(csym),ec, 970 Getfile(n),Getline(n),en); 971 Setattr(csym,"error",e); 972 Delete(e); 973 Delete(en); 974 Delete(ec); 975 Swig_symbol_remove(csym); /* Remove class definition */ 976 Swig_symbol_add(symname,n); /* Insert extend definition */ 977 } 978 } 979 n = nextSibling(n); 980 } 981} 982 983static void append_previous_extension(Node *cls, Node *am) { 984 Node *n, *ne; 985 Node *pe = 0; 986 Node *ae = 0; 987 988 if (!am) return; 989 990 n = firstChild(am); 991 while (n) { 992 ne = nextSibling(n); 993 set_nextSibling(n,0); 994 /* typemaps and fragments need to be prepended */ 995 if (((Cmp(nodeType(n),"typemap") == 0) || (Cmp(nodeType(n),"fragment") == 0))) { 996 if (!pe) pe = new_node("extend"); 997 appendChild(pe, n); 998 } else { 999 if (!ae) ae = new_node("extend"); 1000 appendChild(ae, n); 1001 } 1002 n = ne; 1003 } 1004 if (pe) prependChild(cls,pe); 1005 if (ae) appendChild(cls,ae); 1006} 1007 1008 1009/* Check for unused %extend. Special case, don't report unused 1010 extensions for templates */ 1011 1012static void check_extensions() { 1013 Iterator ki; 1014 1015 if (!extendhash) return; 1016 for (ki = First(extendhash); ki.key; ki = Next(ki)) { 1017 if (!Strchr(ki.key,'<')) { 1018 SWIG_WARN_NODE_BEGIN(ki.item); 1019 Swig_warning(WARN_PARSE_EXTEND_UNDEF,Getfile(ki.item), Getline(ki.item), "%%extend defined for an undeclared class %s.\n", ki.key); 1020 SWIG_WARN_NODE_END(ki.item); 1021 } 1022 } 1023} 1024 1025/* Check a set of declarations to see if any are pure-abstract */ 1026 1027static List *pure_abstract(Node *n) { 1028 List *abs = 0; 1029 while (n) { 1030 if (Cmp(nodeType(n),"cdecl") == 0) { 1031 String *decl = Getattr(n,"decl"); 1032 if (SwigType_isfunction(decl)) { 1033 String *init = Getattr(n,"value"); 1034 if (Cmp(init,"0") == 0) { 1035 if (!abs) { 1036 abs = NewList(); 1037 } 1038 Append(abs,n); 1039 Setattr(n,"abstract","1"); 1040 } 1041 } 1042 } else if (Cmp(nodeType(n),"destructor") == 0) { 1043 if (Cmp(Getattr(n,"value"),"0") == 0) { 1044 if (!abs) { 1045 abs = NewList(); 1046 } 1047 Append(abs,n); 1048 Setattr(n,"abstract","1"); 1049 } 1050 } 1051 n = nextSibling(n); 1052 } 1053 return abs; 1054} 1055 1056/* Make a classname */ 1057 1058static String *make_class_name(String *name) { 1059 String *nname = 0; 1060 if (Namespaceprefix) { 1061 nname= NewStringf("%s::%s", Namespaceprefix, name); 1062 } else { 1063 nname = NewString(name); 1064 } 1065 if (SwigType_istemplate(nname)) { 1066 String *prefix, *args, *qargs; 1067 prefix = SwigType_templateprefix(nname); 1068 args = SwigType_templateargs(nname); 1069 qargs = Swig_symbol_type_qualify(args,0); 1070 Append(prefix,qargs); 1071 Delete(nname); 1072 Delete(args); 1073 Delete(qargs); 1074 nname = prefix; 1075 } 1076 return nname; 1077} 1078 1079static List *make_inherit_list(String *clsname, List *names) { 1080 int i, ilen; 1081 String *derived; 1082 List *bases = NewList(); 1083 1084 if (Namespaceprefix) derived = NewStringf("%s::%s", Namespaceprefix,clsname); 1085 else derived = NewString(clsname); 1086 1087 ilen = Len(names); 1088 for (i = 0; i < ilen; i++) { 1089 Node *s; 1090 String *base; 1091 String *n = Getitem(names,i); 1092 /* Try to figure out where this symbol is */ 1093 s = Swig_symbol_clookup(n,0); 1094 if (s) { 1095 while (s && (Strcmp(nodeType(s),"class") != 0)) { 1096 /* Not a class. Could be a typedef though. */ 1097 String *storage = Getattr(s,"storage"); 1098 if (storage && (Strcmp(storage,"typedef") == 0)) { 1099 String *nn = Getattr(s,"type"); 1100 s = Swig_symbol_clookup(nn,Getattr(s,"sym:symtab")); 1101 } else { 1102 break; 1103 } 1104 } 1105 if (s && ((Strcmp(nodeType(s),"class") == 0) || (Strcmp(nodeType(s),"template") == 0))) { 1106 String *q = Swig_symbol_qualified(s); 1107 Append(bases,s); 1108 if (q) { 1109 base = NewStringf("%s::%s", q, Getattr(s,"name")); 1110 Delete(q); 1111 } else { 1112 base = NewString(Getattr(s,"name")); 1113 } 1114 } else { 1115 base = NewString(n); 1116 } 1117 } else { 1118 base = NewString(n); 1119 } 1120 if (base) { 1121 Swig_name_inherit(base,derived); 1122 Delete(base); 1123 } 1124 } 1125 return bases; 1126} 1127 1128/* If the class name is qualified. We need to create or lookup namespace entries */ 1129 1130static Symtab *get_global_scope() { 1131 Symtab *symtab = Swig_symbol_current(); 1132 Node *pn = parentNode(symtab); 1133 while (pn) { 1134 symtab = pn; 1135 pn = parentNode(symtab); 1136 if (!pn) break; 1137 } 1138 Swig_symbol_setscope(symtab); 1139 return symtab; 1140} 1141 1142/* Remove the block braces, { and }, if the 'noblock' attribute is set. 1143 * Node *kw can be either a Hash or Parmlist. */ 1144static String *remove_block(Node *kw, const String *inputcode) { 1145 String *modified_code = 0; 1146 while (kw) { 1147 String *name = Getattr(kw,"name"); 1148 if (name && (Cmp(name,"noblock") == 0)) { 1149 char *cstr = Char(inputcode); 1150 size_t len = Len(inputcode); 1151 if (len && cstr[0] == '{') { 1152 --len; ++cstr; 1153 if (len && cstr[len - 1] == '}') { --len; } 1154 /* we now remove the extra spaces */ 1155 while (len && isspace((int)cstr[0])) { --len; ++cstr; } 1156 while (len && isspace((int)cstr[len - 1])) { --len; } 1157 modified_code = NewStringWithSize(cstr, len); 1158 break; 1159 } 1160 } 1161 kw = nextSibling(kw); 1162 } 1163 return modified_code; 1164} 1165 1166 1167static Node *nscope = 0; 1168static Node *nscope_inner = 0; 1169static String *resolve_node_scope(String *cname) { 1170 Symtab *gscope = 0; 1171 nscope = 0; 1172 nscope_inner = 0; 1173 if (Swig_scopename_check(cname)) { 1174 Node *ns; 1175 String *prefix = Swig_scopename_prefix(cname); 1176 String *base = Swig_scopename_last(cname); 1177 if (prefix && (Strncmp(prefix,"::",2) == 0)) { 1178 /* Use the global scope */ 1179 String *nprefix = NewString(Char(prefix)+2); 1180 Delete(prefix); 1181 prefix= nprefix; 1182 gscope = get_global_scope(); 1183 } 1184 if (!prefix || (Len(prefix) == 0)) { 1185 /* Use the global scope, but we need to add a 'global' namespace. */ 1186 if (!gscope) gscope = get_global_scope(); 1187 /* note that this namespace is not the "unnamed" one, 1188 and we don't use Setattr(nscope,"name", ""), 1189 because the unnamed namespace is private */ 1190 nscope = new_node("namespace"); 1191 Setattr(nscope,"symtab", gscope);; 1192 nscope_inner = nscope; 1193 return base; 1194 } 1195 /* Try to locate the scope */ 1196 ns = Swig_symbol_clookup(prefix,0); 1197 if (!ns) { 1198 Swig_error(cparse_file,cparse_line,"Undefined scope '%s'\n", prefix); 1199 } else { 1200 Symtab *nstab = Getattr(ns,"symtab"); 1201 if (!nstab) { 1202 Swig_error(cparse_file,cparse_line, 1203 "'%s' is not defined as a valid scope.\n", prefix); 1204 ns = 0; 1205 } else { 1206 /* Check if the node scope is the current scope */ 1207 String *tname = Swig_symbol_qualifiedscopename(0); 1208 String *nname = Swig_symbol_qualifiedscopename(nstab); 1209 if (tname && (Strcmp(tname,nname) == 0)) { 1210 ns = 0; 1211 cname = base; 1212 } 1213 Delete(tname); 1214 Delete(nname); 1215 } 1216 if (ns) { 1217 /* we will try to create a new node using the namespaces we 1218 can find in the scope name */ 1219 List *scopes; 1220 String *sname; 1221 Iterator si; 1222 String *name = NewString(prefix); 1223 scopes = NewList(); 1224 while (name) { 1225 String *base = Swig_scopename_last(name); 1226 String *tprefix = Swig_scopename_prefix(name); 1227 Insert(scopes,0,base); 1228 Delete(base); 1229 Delete(name); 1230 name = tprefix; 1231 } 1232 for (si = First(scopes); si.item; si = Next(si)) { 1233 Node *ns1,*ns2; 1234 sname = si.item; 1235 ns1 = Swig_symbol_clookup(sname,0); 1236 assert(ns1); 1237 if (Strcmp(nodeType(ns1),"namespace") == 0) { 1238 if (Getattr(ns1,"alias")) { 1239 ns1 = Getattr(ns1,"namespace"); 1240 } 1241 } else { 1242 /* now this last part is a class */ 1243 si = Next(si); 1244 ns1 = Swig_symbol_clookup(sname,0); 1245 /* or a nested class tree, which is unrolled here */ 1246 for (; si.item; si = Next(si)) { 1247 if (si.item) { 1248 Printf(sname,"::%s",si.item); 1249 } 1250 } 1251 /* we get the 'inner' class */ 1252 nscope_inner = Swig_symbol_clookup(sname,0); 1253 /* set the scope to the inner class */ 1254 Swig_symbol_setscope(Getattr(nscope_inner,"symtab")); 1255 /* save the last namespace prefix */ 1256 Delete(Namespaceprefix); 1257 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 1258 /* and return the node name, including the inner class prefix */ 1259 break; 1260 } 1261 /* here we just populate the namespace tree as usual */ 1262 ns2 = new_node("namespace"); 1263 Setattr(ns2,"name",sname); 1264 Setattr(ns2,"symtab", Getattr(ns1,"symtab")); 1265 add_symbols(ns2); 1266 Swig_symbol_setscope(Getattr(ns1,"symtab")); 1267 Delete(Namespaceprefix); 1268 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 1269 if (nscope_inner) { 1270 if (Getattr(nscope_inner,"symtab") != Getattr(ns2,"symtab")) { 1271 appendChild(nscope_inner,ns2); 1272 Delete(ns2); 1273 } 1274 } 1275 nscope_inner = ns2; 1276 if (!nscope) nscope = ns2; 1277 } 1278 cname = base; 1279 Delete(scopes); 1280 } 1281 } 1282 Delete(prefix); 1283 } 1284 return cname; 1285} 1286 1287 1288 1289 1290 1291/* Structures for handling code fragments built for nested classes */ 1292 1293typedef struct Nested { 1294 String *code; /* Associated code fragment */ 1295 int line; /* line number where it starts */ 1296 char *name; /* Name associated with this nested class */ 1297 char *kind; /* Kind of class */ 1298 int unnamed; /* unnamed class */ 1299 SwigType *type; /* Datatype associated with the name */ 1300 struct Nested *next; /* Next code fragment in list */ 1301} Nested; 1302 1303/* Some internal variables for saving nested class information */ 1304 1305static Nested *nested_list = 0; 1306 1307/* Add a function to the nested list */ 1308 1309static void add_nested(Nested *n) { 1310 Nested *n1; 1311 if (!nested_list) nested_list = n; 1312 else { 1313 n1 = nested_list; 1314 while (n1->next) n1 = n1->next; 1315 n1->next = n; 1316 } 1317} 1318 1319/* Strips C-style and C++-style comments from string in-place. */ 1320static void strip_comments(char *string) { 1321 int state = 0; /* 1322 * 0 - not in comment 1323 * 1 - in c-style comment 1324 * 2 - in c++-style comment 1325 * 3 - in string 1326 * 4 - after reading / not in comments 1327 * 5 - after reading * in c-style comments 1328 * 6 - after reading \ in strings 1329 */ 1330 char * c = string; 1331 while (*c) { 1332 switch (state) { 1333 case 0: 1334 if (*c == '\"') 1335 state = 3; 1336 else if (*c == '/') 1337 state = 4; 1338 break; 1339 case 1: 1340 if (*c == '*') 1341 state = 5; 1342 *c = ' '; 1343 break; 1344 case 2: 1345 if (*c == '\n') 1346 state = 0; 1347 else 1348 *c = ' '; 1349 break; 1350 case 3: 1351 if (*c == '\"') 1352 state = 0; 1353 else if (*c == '\\') 1354 state = 6; 1355 break; 1356 case 4: 1357 if (*c == '/') { 1358 *(c-1) = ' '; 1359 *c = ' '; 1360 state = 2; 1361 } else if (*c == '*') { 1362 *(c-1) = ' '; 1363 *c = ' '; 1364 state = 1; 1365 } else 1366 state = 0; 1367 break; 1368 case 5: 1369 if (*c == '/') 1370 state = 0; 1371 else 1372 state = 1; 1373 *c = ' '; 1374 break; 1375 case 6: 1376 state = 3; 1377 break; 1378 } 1379 ++c; 1380 } 1381} 1382 1383/* Dump all of the nested class declarations to the inline processor 1384 * However. We need to do a few name replacements and other munging 1385 * first. This function must be called before closing a class! */ 1386 1387static Node *dump_nested(const char *parent) { 1388 Nested *n,*n1; 1389 Node *ret = 0; 1390 n = nested_list; 1391 if (!parent) { 1392 nested_list = 0; 1393 return 0; 1394 } 1395 while (n) { 1396 Node *retx; 1397 SwigType *nt; 1398 /* Token replace the name of the parent class */ 1399 Replace(n->code, "$classname", parent, DOH_REPLACE_ANY); 1400 1401 /* Fix up the name of the datatype (for building typedefs and other stuff) */ 1402 Append(n->type,parent); 1403 Append(n->type,"_"); 1404 Append(n->type,n->name); 1405 1406 /* Add the appropriate declaration to the C++ processor */ 1407 retx = new_node("cdecl"); 1408 Setattr(retx,"name",n->name); 1409 nt = Copy(n->type); 1410 Setattr(retx,"type",nt); 1411 Delete(nt); 1412 Setattr(retx,"nested",parent); 1413 if (n->unnamed) { 1414 Setattr(retx,"unnamed","1"); 1415 } 1416 1417 add_symbols(retx); 1418 if (ret) { 1419 set_nextSibling(retx,ret); 1420 Delete(ret); 1421 } 1422 ret = retx; 1423 1424 /* Insert a forward class declaration */ 1425 /* Disabled: [ 597599 ] union in class: incorrect scope 1426 retx = new_node("classforward"); 1427 Setattr(retx,"kind",n->kind); 1428 Setattr(retx,"name",Copy(n->type)); 1429 Setattr(retx,"sym:name", make_name(n->type,0)); 1430 set_nextSibling(retx,ret); 1431 ret = retx; 1432 */ 1433 1434 /* Strip comments - further code may break in presence of comments. */ 1435 strip_comments(Char(n->code)); 1436 1437 /* Make all SWIG created typedef structs/unions/classes unnamed else 1438 redefinition errors occur - nasty hack alert.*/ 1439 1440 { 1441 const char* types_array[3] = {"struct", "union", "class"}; 1442 int i; 1443 for (i=0; i<3; i++) { 1444 char* code_ptr = Char(n->code); 1445 while (code_ptr) { 1446 /* Replace struct name (as in 'struct name {...}' ) with whitespace 1447 name will be between struct and opening brace */ 1448 1449 code_ptr = strstr(code_ptr, types_array[i]); 1450 if (code_ptr) { 1451 char *open_bracket_pos; 1452 code_ptr += strlen(types_array[i]); 1453 open_bracket_pos = strchr(code_ptr, '{'); 1454 if (open_bracket_pos) { 1455 /* Make sure we don't have something like struct A a; */ 1456 char* semi_colon_pos = strchr(code_ptr, ';'); 1457 if (!(semi_colon_pos && (semi_colon_pos < open_bracket_pos))) 1458 while (code_ptr < open_bracket_pos) 1459 *code_ptr++ = ' '; 1460 } 1461 } 1462 } 1463 } 1464 } 1465 1466 { 1467 /* Remove SWIG directive %constant which may be left in the SWIG created typedefs */ 1468 char* code_ptr = Char(n->code); 1469 while (code_ptr) { 1470 code_ptr = strstr(code_ptr, "%constant"); 1471 if (code_ptr) { 1472 char* directive_end_pos = strchr(code_ptr, ';'); 1473 if (directive_end_pos) { 1474 while (code_ptr <= directive_end_pos) 1475 *code_ptr++ = ' '; 1476 } 1477 } 1478 } 1479 } 1480 { 1481 Node *head = new_node("insert"); 1482 String *code = NewStringf("\n%s\n",n->code); 1483 Setattr(head,"code", code); 1484 Delete(code); 1485 set_nextSibling(head,ret); 1486 Delete(ret); 1487 ret = head; 1488 } 1489 1490 /* Dump the code to the scanner */ 1491 start_inline(Char(n->code),n->line); 1492 1493 n1 = n->next; 1494 Delete(n->code); 1495 free(n); 1496 n = n1; 1497 } 1498 nested_list = 0; 1499 return ret; 1500} 1501 1502Node *Swig_cparse(File *f) { 1503 scanner_file(f); 1504 top = 0; 1505 yyparse(); 1506 return top; 1507} 1508 1509static void single_new_feature(const char *featurename, String *val, Hash *featureattribs, char *declaratorid, SwigType *type, ParmList *declaratorparms, String *qualifier) { 1510 String *fname; 1511 String *name; 1512 String *fixname; 1513 SwigType *t = Copy(type); 1514 1515 /* Printf(stdout, "single_new_feature: [%s] [%s] [%s] [%s] [%s] [%s]\n", featurename, val, declaratorid, t, ParmList_str_defaultargs(declaratorparms), qualifier); */ 1516 1517 fname = NewStringf("feature:%s",featurename); 1518 if (declaratorid) { 1519 fixname = feature_identifier_fix(declaratorid); 1520 } else { 1521 fixname = NewStringEmpty(); 1522 } 1523 if (Namespaceprefix) { 1524 name = NewStringf("%s::%s",Namespaceprefix, fixname); 1525 } else { 1526 name = fixname; 1527 } 1528 1529 if (declaratorparms) Setmeta(val,"parms",declaratorparms); 1530 if (!Len(t)) t = 0; 1531 if (t) { 1532 if (qualifier) SwigType_push(t,qualifier); 1533 if (SwigType_isfunction(t)) { 1534 SwigType *decl = SwigType_pop_function(t); 1535 if (SwigType_ispointer(t)) { 1536 String *nname = NewStringf("*%s",name); 1537 Swig_feature_set(Swig_cparse_features(), nname, decl, fname, val, featureattribs); 1538 Delete(nname); 1539 } else { 1540 Swig_feature_set(Swig_cparse_features(), name, decl, fname, val, featureattribs); 1541 } 1542 Delete(decl); 1543 } else if (SwigType_ispointer(t)) { 1544 String *nname = NewStringf("*%s",name); 1545 Swig_feature_set(Swig_cparse_features(),nname,0,fname,val, featureattribs); 1546 Delete(nname); 1547 } 1548 } else { 1549 /* Global feature, that is, feature not associated with any particular symbol */ 1550 Swig_feature_set(Swig_cparse_features(),name,0,fname,val, featureattribs); 1551 } 1552 Delete(fname); 1553 Delete(name); 1554} 1555 1556/* Add a new feature to the Hash. Additional features are added if the feature has a parameter list (declaratorparms) 1557 * and one or more of the parameters have a default argument. An extra feature is added for each defaulted parameter, 1558 * simulating the equivalent overloaded method. */ 1559static void new_feature(const char *featurename, String *val, Hash *featureattribs, char *declaratorid, SwigType *type, ParmList *declaratorparms, String *qualifier) { 1560 1561 ParmList *declparms = declaratorparms; 1562 1563 /* remove the { and } braces if the noblock attribute is set */ 1564 String *newval = remove_block(featureattribs, val); 1565 val = newval ? newval : val; 1566 1567 /* Add the feature */ 1568 single_new_feature(featurename, val, featureattribs, declaratorid, type, declaratorparms, qualifier); 1569 1570 /* Add extra features if there are default parameters in the parameter list */ 1571 if (type) { 1572 while (declparms) { 1573 if (ParmList_has_defaultargs(declparms)) { 1574 1575 /* Create a parameter list for the new feature by copying all 1576 but the last (defaulted) parameter */ 1577 ParmList* newparms = CopyParmListMax(declparms, ParmList_len(declparms)-1); 1578 1579 /* Create new declaration - with the last parameter removed */ 1580 SwigType *newtype = Copy(type); 1581 Delete(SwigType_pop_function(newtype)); /* remove the old parameter list from newtype */ 1582 SwigType_add_function(newtype,newparms); 1583 1584 single_new_feature(featurename, Copy(val), featureattribs, declaratorid, newtype, newparms, qualifier); 1585 declparms = newparms; 1586 } else { 1587 declparms = 0; 1588 } 1589 } 1590 } 1591} 1592 1593/* check if a function declaration is a plain C object */ 1594static int is_cfunction(Node *n) { 1595 if (!cparse_cplusplus || cparse_externc) return 1; 1596 if (Cmp(Getattr(n,"storage"),"externc") == 0) { 1597 return 1; 1598 } 1599 return 0; 1600} 1601 1602/* If the Node is a function with parameters, check to see if any of the parameters 1603 * have default arguments. If so create a new function for each defaulted argument. 1604 * The additional functions form a linked list of nodes with the head being the original Node n. */ 1605static void default_arguments(Node *n) { 1606 Node *function = n; 1607 1608 if (function) { 1609 ParmList *varargs = Getattr(function,"feature:varargs"); 1610 if (varargs) { 1611 /* Handles the %varargs directive by looking for "feature:varargs" and 1612 * substituting ... with an alternative set of arguments. */ 1613 Parm *p = Getattr(function,"parms"); 1614 Parm *pp = 0; 1615 while (p) { 1616 SwigType *t = Getattr(p,"type"); 1617 if (Strcmp(t,"v(...)") == 0) { 1618 if (pp) { 1619 ParmList *cv = Copy(varargs); 1620 set_nextSibling(pp,cv); 1621 Delete(cv); 1622 } else { 1623 ParmList *cv = Copy(varargs); 1624 Setattr(function,"parms", cv); 1625 Delete(cv); 1626 } 1627 break; 1628 } 1629 pp = p; 1630 p = nextSibling(p); 1631 } 1632 } 1633 1634 /* Do not add in functions if kwargs is being used or if user wants old default argument wrapping 1635 (one wrapped method per function irrespective of number of default arguments) */ 1636 if (compact_default_args 1637 || is_cfunction(function) 1638 || GetFlag(function,"feature:compactdefaultargs") 1639 || GetFlag(function,"feature:kwargs")) { 1640 ParmList *p = Getattr(function,"parms"); 1641 if (p) 1642 Setattr(p,"compactdefargs", "1"); /* mark parameters for special handling */ 1643 function = 0; /* don't add in extra methods */ 1644 } 1645 } 1646 1647 while (function) { 1648 ParmList *parms = Getattr(function,"parms"); 1649 if (ParmList_has_defaultargs(parms)) { 1650 1651 /* Create a parameter list for the new function by copying all 1652 but the last (defaulted) parameter */ 1653 ParmList* newparms = CopyParmListMax(parms,ParmList_len(parms)-1); 1654 1655 /* Create new function and add to symbol table */ 1656 { 1657 SwigType *ntype = Copy(nodeType(function)); 1658 char *cntype = Char(ntype); 1659 Node *new_function = new_node(ntype); 1660 SwigType *decl = Copy(Getattr(function,"decl")); 1661 int constqualifier = SwigType_isconst(decl); 1662 String *ccode = Copy(Getattr(function,"code")); 1663 String *cstorage = Copy(Getattr(function,"storage")); 1664 String *cvalue = Copy(Getattr(function,"value")); 1665 SwigType *ctype = Copy(Getattr(function,"type")); 1666 String *cthrow = Copy(Getattr(function,"throw")); 1667 1668 Delete(SwigType_pop_function(decl)); /* remove the old parameter list from decl */ 1669 SwigType_add_function(decl,newparms); 1670 if (constqualifier) 1671 SwigType_add_qualifier(decl,"const"); 1672 1673 Setattr(new_function,"name", Getattr(function,"name")); 1674 Setattr(new_function,"code", ccode); 1675 Setattr(new_function,"decl", decl); 1676 Setattr(new_function,"parms", newparms); 1677 Setattr(new_function,"storage", cstorage); 1678 Setattr(new_function,"value", cvalue); 1679 Setattr(new_function,"type", ctype); 1680 Setattr(new_function,"throw", cthrow); 1681 1682 Delete(ccode); 1683 Delete(cstorage); 1684 Delete(cvalue); 1685 Delete(ctype); 1686 Delete(cthrow); 1687 Delete(decl); 1688 1689 { 1690 Node *throws = Getattr(function,"throws"); 1691 ParmList *pl = CopyParmList(throws); 1692 if (throws) Setattr(new_function,"throws",pl); 1693 Delete(pl); 1694 } 1695 1696 /* copy specific attributes for global (or in a namespace) template functions - these are not templated class methods */ 1697 if (strcmp(cntype,"template") == 0) { 1698 Node *templatetype = Getattr(function,"templatetype"); 1699 Node *symtypename = Getattr(function,"sym:typename"); 1700 Parm *templateparms = Getattr(function,"templateparms"); 1701 if (templatetype) { 1702 Node *tmp = Copy(templatetype); 1703 Setattr(new_function,"templatetype",tmp); 1704 Delete(tmp); 1705 } 1706 if (symtypename) { 1707 Node *tmp = Copy(symtypename); 1708 Setattr(new_function,"sym:typename",tmp); 1709 Delete(tmp); 1710 } 1711 if (templateparms) { 1712 Parm *tmp = CopyParmList(templateparms); 1713 Setattr(new_function,"templateparms",tmp); 1714 Delete(tmp); 1715 } 1716 } else if (strcmp(cntype,"constructor") == 0) { 1717 /* only copied for constructors as this is not a user defined feature - it is hard coded in the parser */ 1718 if (GetFlag(function,"feature:new")) SetFlag(new_function,"feature:new"); 1719 } 1720 1721 add_symbols(new_function); 1722 /* mark added functions as ones with overloaded parameters and point to the parsed method */ 1723 Setattr(new_function,"defaultargs", n); 1724 1725 /* Point to the new function, extending the linked list */ 1726 set_nextSibling(function, new_function); 1727 Delete(new_function); 1728 function = new_function; 1729 1730 Delete(ntype); 1731 } 1732 } else { 1733 function = 0; 1734 } 1735 } 1736} 1737 1738/* ----------------------------------------------------------------------------- 1739 * tag_nodes() 1740 * 1741 * Used by the parser to mark subtypes with extra information. 1742 * ----------------------------------------------------------------------------- */ 1743 1744static void tag_nodes(Node *n, const_String_or_char_ptr attrname, DOH *value) { 1745 while (n) { 1746 Setattr(n, attrname, value); 1747 tag_nodes(firstChild(n), attrname, value); 1748 n = nextSibling(n); 1749 } 1750} 1751 1752 1753 1754/* Enabling traces. */ 1755#ifndef YYDEBUG 1756# define YYDEBUG 0 1757#endif 1758 1759/* Enabling verbose error messages. */ 1760#ifdef YYERROR_VERBOSE 1761# undef YYERROR_VERBOSE 1762# define YYERROR_VERBOSE 1 1763#else 1764# define YYERROR_VERBOSE 0 1765#endif 1766 1767/* Enabling the token table. */ 1768#ifndef YYTOKEN_TABLE 1769# define YYTOKEN_TABLE 0 1770#endif 1771 1772#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 1773typedef union YYSTYPE 1774#line 1440 "parser.y" 1775{ 1776 char *id; 1777 List *bases; 1778 struct Define { 1779 String *val; 1780 String *rawval; 1781 int type; 1782 String *qualifier; 1783 String *bitfield; 1784 Parm *throws; 1785 String *throwf; 1786 } dtype; 1787 struct { 1788 char *type; 1789 String *filename; 1790 int line; 1791 } loc; 1792 struct { 1793 char *id; 1794 SwigType *type; 1795 String *defarg; 1796 ParmList *parms; 1797 short have_parms; 1798 ParmList *throws; 1799 String *throwf; 1800 } decl; 1801 Parm *tparms; 1802 struct { 1803 String *method; 1804 Hash *kwargs; 1805 } tmap; 1806 struct { 1807 String *type; 1808 String *us; 1809 } ptype; 1810 SwigType *type; 1811 String *str; 1812 Parm *p; 1813 ParmList *pl; 1814 int ivalue; 1815 Node *node; 1816} 1817/* Line 187 of yacc.c. */ 1818#line 1819 "y.tab.c" 1819 YYSTYPE; 1820# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 1821# define YYSTYPE_IS_DECLARED 1 1822# define YYSTYPE_IS_TRIVIAL 1 1823#endif 1824 1825 1826 1827/* Copy the second part of user declarations. */ 1828 1829 1830/* Line 216 of yacc.c. */ 1831#line 1832 "y.tab.c" 1832 1833#ifdef short 1834# undef short 1835#endif 1836 1837#ifdef YYTYPE_UINT8 1838typedef YYTYPE_UINT8 yytype_uint8; 1839#else 1840typedef unsigned char yytype_uint8; 1841#endif 1842 1843#ifdef YYTYPE_INT8 1844typedef YYTYPE_INT8 yytype_int8; 1845#elif (defined __STDC__ || defined __C99__FUNC__ \ 1846 || defined __cplusplus || defined _MSC_VER) 1847typedef signed char yytype_int8; 1848#else 1849typedef short int yytype_int8; 1850#endif 1851 1852#ifdef YYTYPE_UINT16 1853typedef YYTYPE_UINT16 yytype_uint16; 1854#else 1855typedef unsigned short int yytype_uint16; 1856#endif 1857 1858#ifdef YYTYPE_INT16 1859typedef YYTYPE_INT16 yytype_int16; 1860#else 1861typedef short int yytype_int16; 1862#endif 1863 1864#ifndef YYSIZE_T 1865# ifdef __SIZE_TYPE__ 1866# define YYSIZE_T __SIZE_TYPE__ 1867# elif defined size_t 1868# define YYSIZE_T size_t 1869# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 1870 || defined __cplusplus || defined _MSC_VER) 1871# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 1872# define YYSIZE_T size_t 1873# else 1874# define YYSIZE_T unsigned int 1875# endif 1876#endif 1877 1878#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 1879 1880#ifndef YY_ 1881# if YYENABLE_NLS 1882# if ENABLE_NLS 1883# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 1884# define YY_(msgid) dgettext ("bison-runtime", msgid) 1885# endif 1886# endif 1887# ifndef YY_ 1888# define YY_(msgid) msgid 1889# endif 1890#endif 1891 1892/* Suppress unused-variable warnings by "using" E. */ 1893#if ! defined lint || defined __GNUC__ 1894# define YYUSE(e) ((void) (e)) 1895#else 1896# define YYUSE(e) /* empty */ 1897#endif 1898 1899/* Identity function, used to suppress warnings about constant conditions. */ 1900#ifndef lint 1901# define YYID(n) (n) 1902#else 1903#if (defined __STDC__ || defined __C99__FUNC__ \ 1904 || defined __cplusplus || defined _MSC_VER) 1905static int 1906YYID (int i) 1907#else 1908static int 1909YYID (i) 1910 int i; 1911#endif 1912{ 1913 return i; 1914} 1915#endif 1916 1917#if ! defined yyoverflow || YYERROR_VERBOSE 1918 1919/* The parser invokes alloca or malloc; define the necessary symbols. */ 1920 1921# ifdef YYSTACK_USE_ALLOCA 1922# if YYSTACK_USE_ALLOCA 1923# ifdef __GNUC__ 1924# define YYSTACK_ALLOC __builtin_alloca 1925# elif defined __BUILTIN_VA_ARG_INCR 1926# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 1927# elif defined _AIX 1928# define YYSTACK_ALLOC __alloca 1929# elif defined _MSC_VER 1930# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 1931# define alloca _alloca 1932# else 1933# define YYSTACK_ALLOC alloca 1934# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 1935 || defined __cplusplus || defined _MSC_VER) 1936# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 1937# ifndef _STDLIB_H 1938# define _STDLIB_H 1 1939# endif 1940# endif 1941# endif 1942# endif 1943# endif 1944 1945# ifdef YYSTACK_ALLOC 1946 /* Pacify GCC's `empty if-body' warning. */ 1947# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 1948# ifndef YYSTACK_ALLOC_MAXIMUM 1949 /* The OS might guarantee only one guard page at the bottom of the stack, 1950 and a page size can be as small as 4096 bytes. So we cannot safely 1951 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 1952 to allow for a few compiler-allocated temporary stack slots. */ 1953# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 1954# endif 1955# else 1956# define YYSTACK_ALLOC YYMALLOC 1957# define YYSTACK_FREE YYFREE 1958# ifndef YYSTACK_ALLOC_MAXIMUM 1959# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 1960# endif 1961# if (defined __cplusplus && ! defined _STDLIB_H \ 1962 && ! ((defined YYMALLOC || defined malloc) \ 1963 && (defined YYFREE || defined free))) 1964# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 1965# ifndef _STDLIB_H 1966# define _STDLIB_H 1 1967# endif 1968# endif 1969# ifndef YYMALLOC 1970# define YYMALLOC malloc 1971# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 1972 || defined __cplusplus || defined _MSC_VER) 1973void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 1974# endif 1975# endif 1976# ifndef YYFREE 1977# define YYFREE free 1978# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 1979 || defined __cplusplus || defined _MSC_VER) 1980void free (void *); /* INFRINGES ON USER NAME SPACE */ 1981# endif 1982# endif 1983# endif 1984#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 1985 1986 1987#if (! defined yyoverflow \ 1988 && (! defined __cplusplus \ 1989 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 1990 1991/* A type that is properly aligned for any stack member. */ 1992union yyalloc 1993{ 1994 yytype_int16 yyss; 1995 YYSTYPE yyvs; 1996 }; 1997 1998/* The size of the maximum gap between one aligned stack and the next. */ 1999# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 2000 2001/* The size of an array large to enough to hold all stacks, each with 2002 N elements. */ 2003# define YYSTACK_BYTES(N) \ 2004 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 2005 + YYSTACK_GAP_MAXIMUM) 2006 2007/* Copy COUNT objects from FROM to TO. The source and destination do 2008 not overlap. */ 2009# ifndef YYCOPY 2010# if defined __GNUC__ && 1 < __GNUC__ 2011# define YYCOPY(To, From, Count) \ 2012 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 2013# else 2014# define YYCOPY(To, From, Count) \ 2015 do \ 2016 { \ 2017 YYSIZE_T yyi; \ 2018 for (yyi = 0; yyi < (Count); yyi++) \ 2019 (To)[yyi] = (From)[yyi]; \ 2020 } \ 2021 while (YYID (0)) 2022# endif 2023# endif 2024 2025/* Relocate STACK from its old location to the new one. The 2026 local variables YYSIZE and YYSTACKSIZE give the old and new number of 2027 elements in the stack, and YYPTR gives the new location of the 2028 stack. Advance YYPTR to a properly aligned location for the next 2029 stack. */ 2030# define YYSTACK_RELOCATE(Stack) \ 2031 do \ 2032 { \ 2033 YYSIZE_T yynewbytes; \ 2034 YYCOPY (&yyptr->Stack, Stack, yysize); \ 2035 Stack = &yyptr->Stack; \ 2036 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 2037 yyptr += yynewbytes / sizeof (*yyptr); \ 2038 } \ 2039 while (YYID (0)) 2040 2041#endif 2042 2043/* YYFINAL -- State number of the termination state. */ 2044#define YYFINAL 55 2045/* YYLAST -- Last index in YYTABLE. */ 2046#define YYLAST 3902 2047 2048/* YYNTOKENS -- Number of terminals. */ 2049#define YYNTOKENS 127 2050/* YYNNTS -- Number of nonterminals. */ 2051#define YYNNTS 148 2052/* YYNRULES -- Number of rules. */ 2053#define YYNRULES 467 2054/* YYNRULES -- Number of states. */ 2055#define YYNSTATES 904 2056 2057/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 2058#define YYUNDEFTOK 2 2059#define YYMAXUTOK 381 2060 2061#define YYTRANSLATE(YYX) \ 2062 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 2063 2064/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 2065static const yytype_uint8 yytranslate[] = 2066{ 2067 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2068 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2069 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2070 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2071 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2072 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2073 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2074 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2075 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2076 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2077 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2078 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2079 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2080 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2081 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2082 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2083 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2084 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2085 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2086 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2087 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2088 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2089 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2090 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2091 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2092 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 2093 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 2094 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 2095 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 2096 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 2097 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 2098 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 2099 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 2100 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 2101 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 2102 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 2103 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 2104 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 2105 125, 126 2106}; 2107 2108#if YYDEBUG 2109/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 2110 YYRHS. */ 2111static const yytype_uint16 yyprhs[] = 2112{ 2113 0, 0, 3, 5, 9, 12, 16, 19, 25, 29, 2114 32, 34, 36, 38, 40, 42, 44, 46, 49, 51, 2115 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 2116 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 2117 92, 100, 106, 110, 116, 122, 126, 129, 132, 138, 2118 141, 147, 150, 155, 157, 159, 167, 175, 181, 182, 2119 190, 192, 194, 197, 200, 202, 208, 214, 220, 224, 2120 229, 233, 241, 250, 256, 260, 262, 264, 268, 270, 2121 275, 283, 290, 292, 294, 302, 312, 321, 332, 338, 2122 346, 353, 362, 364, 366, 372, 377, 383, 391, 393, 2123 397, 404, 411, 420, 422, 425, 429, 431, 434, 438, 2124 445, 451, 461, 464, 466, 468, 470, 471, 478, 484, 2125 486, 491, 493, 495, 498, 504, 511, 516, 524, 533, 2126 540, 542, 544, 546, 548, 550, 552, 553, 563, 564, 2127 573, 575, 578, 583, 584, 591, 595, 597, 599, 601, 2128 603, 605, 607, 609, 612, 614, 616, 618, 622, 624, 2129 628, 633, 634, 641, 642, 648, 654, 657, 658, 665, 2130 667, 669, 670, 674, 676, 678, 680, 682, 684, 686, 2131 688, 690, 694, 696, 698, 700, 702, 704, 706, 708, 2132 710, 712, 719, 726, 734, 743, 752, 760, 766, 769, 2133 772, 775, 776, 784, 785, 792, 793, 802, 804, 806, 2134 808, 810, 812, 814, 816, 818, 820, 822, 824, 826, 2135 828, 831, 834, 837, 842, 845, 851, 853, 856, 858, 2136 860, 862, 864, 866, 868, 870, 873, 875, 879, 881, 2137 884, 892, 896, 898, 901, 903, 907, 909, 911, 913, 2138 916, 922, 925, 928, 930, 933, 936, 938, 940, 942, 2139 944, 947, 951, 953, 956, 960, 965, 971, 976, 978, 2140 981, 985, 990, 996, 1000, 1005, 1010, 1012, 1015, 1020, 2141 1025, 1031, 1035, 1040, 1045, 1047, 1050, 1053, 1057, 1059, 2142 1062, 1064, 1067, 1071, 1076, 1080, 1085, 1088, 1092, 1096, 2143 1101, 1105, 1109, 1112, 1115, 1117, 1119, 1122, 1124, 1126, 2144 1128, 1130, 1133, 1135, 1138, 1142, 1144, 1146, 1148, 1151, 2145 1154, 1156, 1158, 1161, 1163, 1165, 1168, 1170, 1172, 1174, 2146 1176, 1178, 1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 2147 1196, 1197, 1200, 1202, 1204, 1208, 1210, 1212, 1216, 1218, 2148 1220, 1222, 1224, 1226, 1228, 1234, 1236, 1238, 1242, 1247, 2149 1253, 1259, 1266, 1269, 1272, 1274, 1276, 1278, 1280, 1282, 2150 1284, 1286, 1290, 1294, 1298, 1302, 1306, 1310, 1314, 1318, 2151 1322, 1326, 1330, 1334, 1338, 1342, 1346, 1350, 1356, 1359, 2152 1362, 1365, 1368, 1371, 1373, 1374, 1378, 1380, 1382, 1386, 2153 1389, 1394, 1396, 1398, 1400, 1402, 1404, 1406, 1408, 1410, 2154 1412, 1414, 1416, 1421, 1427, 1429, 1433, 1437, 1442, 1447, 2155 1451, 1454, 1456, 1458, 1462, 1465, 1469, 1471, 1473, 1475, 2156 1477, 1479, 1482, 1487, 1489, 1493, 1495, 1499, 1503, 1506, 2157 1509, 1512, 1515, 1518, 1523, 1525, 1529, 1531, 1535, 1539, 2158 1542, 1545, 1548, 1551, 1553, 1555, 1557, 1559, 1563, 1565, 2159 1569, 1575, 1577, 1581, 1585, 1591, 1593, 1595 2160}; 2161 2162/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 2163static const yytype_int16 yyrhs[] = 2164{ 2165 128, 0, -1, 129, -1, 107, 215, 40, -1, 107, 2166 1, -1, 108, 215, 40, -1, 108, 1, -1, 109, 2167 37, 212, 38, 40, -1, 109, 1, 40, -1, 129, 2168 130, -1, 274, -1, 131, -1, 168, -1, 176, -1, 2169 40, -1, 1, -1, 175, -1, 1, 106, -1, 132, 2170 -1, 134, -1, 135, -1, 136, -1, 137, -1, 138, 2171 -1, 141, -1, 142, -1, 145, -1, 146, -1, 147, 2172 -1, 148, -1, 149, -1, 150, -1, 153, -1, 155, 2173 -1, 158, -1, 160, -1, 165, -1, 166, -1, 167, 2174 -1, -1, 61, 271, 264, 43, 133, 193, 44, -1, 2175 85, 164, 43, 162, 44, -1, 86, 162, 40, -1, 2176 57, 3, 51, 237, 40, -1, 57, 231, 223, 220, 2177 40, -1, 57, 1, 40, -1, 84, 4, -1, 84, 2178 269, -1, 83, 37, 3, 38, 43, -1, 83, 43, 2179 -1, 83, 37, 3, 38, 40, -1, 83, 40, -1, 2180 269, 43, 215, 44, -1, 269, -1, 139, -1, 88, 2181 37, 140, 39, 272, 38, 4, -1, 88, 37, 140, 2182 39, 272, 38, 43, -1, 88, 37, 140, 38, 40, 2183 -1, -1, 144, 271, 269, 54, 143, 129, 55, -1, 2184 7, -1, 8, -1, 81, 4, -1, 81, 43, -1, 2185 4, -1, 9, 37, 262, 38, 269, -1, 9, 37, 2186 262, 38, 4, -1, 9, 37, 262, 38, 43, -1, 2187 53, 271, 262, -1, 58, 37, 262, 38, -1, 58, 2188 37, 38, -1, 80, 37, 3, 38, 211, 3, 40, 2189 -1, 80, 37, 3, 38, 211, 231, 223, 40, -1, 2190 62, 152, 3, 51, 151, -1, 62, 152, 3, -1, 2191 269, -1, 4, -1, 37, 3, 38, -1, 274, -1, 2192 154, 223, 262, 40, -1, 154, 37, 272, 38, 223, 2193 256, 40, -1, 154, 37, 272, 38, 269, 40, -1, 2194 59, -1, 60, -1, 63, 37, 262, 38, 223, 256, 2195 156, -1, 63, 37, 262, 39, 273, 38, 223, 256, 2196 40, -1, 63, 37, 262, 157, 38, 223, 256, 156, 2197 -1, 63, 37, 262, 39, 273, 157, 38, 223, 256, 2198 40, -1, 63, 37, 262, 38, 156, -1, 63, 37, 2199 262, 39, 273, 38, 40, -1, 63, 37, 262, 157, 2200 38, 156, -1, 63, 37, 262, 39, 273, 157, 38, 2201 40, -1, 270, -1, 40, -1, 100, 37, 212, 38, 2202 40, -1, 39, 262, 51, 273, -1, 39, 262, 51, 2203 273, 157, -1, 64, 37, 159, 38, 223, 256, 40, 2204 -1, 212, -1, 11, 39, 215, -1, 82, 37, 161, 2205 38, 162, 270, -1, 82, 37, 161, 38, 162, 40, 2206 -1, 82, 37, 161, 38, 162, 51, 164, 40, -1, 2207 272, -1, 164, 163, -1, 39, 164, 163, -1, 274, 2208 -1, 231, 222, -1, 37, 212, 38, -1, 37, 212, 2209 38, 37, 212, 38, -1, 99, 37, 212, 38, 156, 2210 -1, 87, 37, 263, 38, 267, 90, 216, 91, 40, 2211 -1, 89, 269, -1, 170, -1, 174, -1, 173, -1, 2212 -1, 41, 269, 43, 169, 129, 44, -1, 211, 231, 2213 223, 172, 171, -1, 40, -1, 39, 223, 172, 171, 2214 -1, 43, -1, 220, -1, 229, 220, -1, 75, 37, 2215 212, 38, 220, -1, 229, 75, 37, 212, 38, 220, 2216 -1, 211, 65, 3, 40, -1, 211, 65, 239, 43, 2217 240, 44, 40, -1, 211, 65, 239, 43, 240, 44, 2218 223, 171, -1, 211, 231, 37, 212, 38, 257, -1, 2219 177, -1, 181, -1, 182, -1, 189, -1, 190, -1, 2220 200, -1, -1, 211, 254, 264, 247, 43, 178, 193, 2221 44, 180, -1, -1, 211, 254, 43, 179, 193, 44, 2222 223, 171, -1, 40, -1, 223, 171, -1, 211, 254, 2223 264, 40, -1, -1, 104, 90, 185, 91, 183, 184, 2224 -1, 104, 254, 264, -1, 170, -1, 177, -1, 197, 2225 -1, 182, -1, 181, -1, 199, -1, 186, -1, 187, 2226 188, -1, 274, -1, 253, -1, 215, -1, 39, 187, 2227 188, -1, 274, -1, 78, 264, 40, -1, 78, 79, 2228 264, 40, -1, -1, 79, 264, 43, 191, 129, 44, 2229 -1, -1, 79, 43, 192, 129, 44, -1, 79, 3, 2230 51, 264, 40, -1, 196, 193, -1, -1, 61, 43, 2231 194, 193, 44, 193, -1, 142, -1, 274, -1, -1, 2232 1, 195, 193, -1, 168, -1, 197, -1, 198, -1, 2233 201, -1, 207, -1, 199, -1, 181, -1, 202, -1, 2234 211, 264, 40, -1, 189, -1, 182, -1, 200, -1, 2235 166, -1, 167, -1, 210, -1, 141, -1, 165, -1, 2236 40, -1, 211, 231, 37, 212, 38, 257, -1, 124, 2237 266, 37, 212, 38, 208, -1, 73, 124, 266, 37, 2238 212, 38, 209, -1, 211, 106, 231, 228, 37, 212, 2239 38, 209, -1, 211, 106, 231, 115, 37, 212, 38, 2240 209, -1, 211, 106, 231, 37, 212, 38, 209, -1, 2241 76, 37, 212, 38, 43, -1, 69, 71, -1, 68, 2242 71, -1, 70, 71, -1, -1, 211, 254, 3, 43, 2243 203, 206, 40, -1, -1, 211, 254, 43, 204, 206, 2244 40, -1, -1, 211, 254, 264, 71, 250, 43, 205, 2245 40, -1, 223, -1, 274, -1, 150, -1, 136, -1, 2246 148, -1, 153, -1, 155, -1, 158, -1, 146, -1, 2247 160, -1, 134, -1, 135, -1, 137, -1, 256, 40, 2248 -1, 256, 43, -1, 256, 40, -1, 256, 51, 237, 2249 40, -1, 256, 43, -1, 211, 231, 71, 243, 40, 2250 -1, 41, -1, 41, 269, -1, 72, -1, 18, -1, 2251 73, -1, 74, -1, 77, -1, 274, -1, 213, -1, 2252 215, 214, -1, 274, -1, 39, 215, 214, -1, 274, 2253 -1, 232, 221, -1, 104, 90, 254, 91, 254, 264, 2254 220, -1, 45, 45, 45, -1, 217, -1, 219, 218, 2255 -1, 274, -1, 39, 219, 218, -1, 274, -1, 215, 2256 -1, 244, -1, 51, 237, -1, 51, 237, 54, 243, 2257 55, -1, 51, 43, -1, 71, 243, -1, 274, -1, 2258 223, 220, -1, 226, 220, -1, 220, -1, 223, -1, 2259 226, -1, 274, -1, 228, 224, -1, 228, 115, 224, 2260 -1, 225, -1, 115, 224, -1, 264, 102, 224, -1, 2261 228, 264, 102, 224, -1, 228, 264, 102, 115, 224, 2262 -1, 264, 102, 115, 224, -1, 264, -1, 124, 264, 2263 -1, 37, 264, 38, -1, 37, 228, 224, 38, -1, 2264 37, 264, 102, 224, 38, -1, 224, 54, 55, -1, 2265 224, 54, 243, 55, -1, 224, 37, 212, 38, -1, 2266 264, -1, 124, 264, -1, 37, 228, 225, 38, -1, 2267 37, 115, 225, 38, -1, 37, 264, 102, 225, 38, 2268 -1, 225, 54, 55, -1, 225, 54, 243, 55, -1, 2269 225, 37, 212, 38, -1, 228, -1, 228, 227, -1, 2270 228, 115, -1, 228, 115, 227, -1, 227, -1, 115, 2271 227, -1, 115, -1, 264, 102, -1, 228, 264, 102, 2272 -1, 228, 264, 102, 227, -1, 227, 54, 55, -1, 2273 227, 54, 243, 55, -1, 54, 55, -1, 54, 243, 2274 55, -1, 37, 226, 38, -1, 227, 37, 212, 38, 2275 -1, 37, 212, 38, -1, 122, 229, 228, -1, 122, 2276 228, -1, 122, 229, -1, 122, -1, 230, -1, 230, 2277 229, -1, 46, -1, 47, -1, 48, -1, 232, -1, 2278 229, 233, -1, 233, -1, 233, 229, -1, 229, 233, 2279 229, -1, 234, -1, 29, -1, 27, -1, 31, 261, 2280 -1, 65, 264, -1, 32, -1, 264, -1, 254, 264, 2281 -1, 235, -1, 236, -1, 236, 235, -1, 19, -1, 2282 21, -1, 22, -1, 25, -1, 26, -1, 23, -1, 2283 24, -1, 28, -1, 20, -1, 30, -1, 33, -1, 2284 34, -1, 35, -1, 36, -1, -1, 238, 243, -1, 2285 3, -1, 274, -1, 240, 39, 241, -1, 241, -1, 2286 3, -1, 3, 51, 242, -1, 274, -1, 243, -1, 2287 244, -1, 231, -1, 245, -1, 269, -1, 52, 37, 2288 231, 221, 38, -1, 246, -1, 10, -1, 37, 243, 2289 38, -1, 37, 243, 38, 243, -1, 37, 243, 228, 2290 38, 243, -1, 37, 243, 115, 38, 243, -1, 37, 2291 243, 228, 115, 38, 243, -1, 115, 243, -1, 122, 2292 243, -1, 11, -1, 12, -1, 13, -1, 14, -1, 2293 15, -1, 16, -1, 17, -1, 243, 119, 243, -1, 2294 243, 118, 243, -1, 243, 122, 243, -1, 243, 121, 2295 243, -1, 243, 120, 243, -1, 243, 115, 243, -1, 2296 243, 113, 243, -1, 243, 114, 243, -1, 243, 117, 2297 243, -1, 243, 116, 243, -1, 243, 112, 243, -1, 2298 243, 111, 243, -1, 243, 96, 243, -1, 243, 97, 2299 243, -1, 243, 95, 243, -1, 243, 94, 243, -1, 2300 243, 98, 243, 71, 243, -1, 118, 243, -1, 119, 2301 243, -1, 124, 243, -1, 123, 243, -1, 231, 37, 2302 -1, 248, -1, -1, 71, 249, 250, -1, 274, -1, 2303 251, -1, 250, 39, 251, -1, 255, 264, -1, 255, 2304 252, 255, 264, -1, 69, -1, 68, -1, 70, -1, 2305 66, -1, 67, -1, 253, -1, 49, -1, 50, -1, 2306 73, -1, 274, -1, 229, -1, 75, 37, 212, 38, 2307 -1, 229, 75, 37, 212, 38, -1, 274, -1, 256, 2308 258, 40, -1, 256, 258, 43, -1, 37, 212, 38, 2309 40, -1, 37, 212, 38, 43, -1, 51, 237, 40, 2310 -1, 71, 259, -1, 274, -1, 260, -1, 259, 39, 2311 260, -1, 264, 37, -1, 90, 216, 91, -1, 274, 2312 -1, 3, -1, 269, -1, 262, -1, 274, -1, 266, 2313 265, -1, 101, 126, 266, 265, -1, 266, -1, 101, 2314 126, 266, -1, 105, -1, 101, 126, 105, -1, 126, 2315 266, 265, -1, 126, 266, -1, 126, 105, -1, 103, 2316 266, -1, 3, 261, -1, 3, 268, -1, 101, 126, 2317 3, 268, -1, 3, -1, 101, 126, 3, -1, 105, 2318 -1, 101, 126, 105, -1, 126, 3, 268, -1, 126, 2319 3, -1, 126, 105, -1, 103, 3, -1, 269, 6, 2320 -1, 6, -1, 269, -1, 43, -1, 4, -1, 37, 2321 272, 38, -1, 274, -1, 262, 51, 273, -1, 262, 2322 51, 273, 39, 272, -1, 262, -1, 262, 39, 272, 2323 -1, 262, 51, 139, -1, 262, 51, 139, 39, 272, 2324 -1, 269, -1, 245, -1, -1 2325}; 2326 2327/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 2328static const yytype_uint16 yyrline[] = 2329{ 2330 0, 1593, 1593, 1606, 1610, 1613, 1616, 1619, 1622, 1627, 2331 1632, 1637, 1638, 1639, 1640, 1641, 1647, 1663, 1673, 1674, 2332 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 2333 1685, 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1700, 2334 1700, 1772, 1782, 1793, 1814, 1836, 1847, 1856, 1875, 1881, 2335 1887, 1892, 1899, 1906, 1910, 1923, 1932, 1947, 1960, 1960, 2336 2015, 2016, 2023, 2043, 2074, 2078, 2088, 2093, 2111, 2151, 2337 2157, 2170, 2176, 2202, 2208, 2215, 2216, 2219, 2220, 2228, 2338 2274, 2320, 2331, 2334, 2361, 2367, 2373, 2379, 2387, 2393, 2339 2399, 2405, 2413, 2414, 2415, 2418, 2423, 2433, 2469, 2470, 2340 2500, 2517, 2525, 2538, 2563, 2569, 2573, 2576, 2587, 2592, 2341 2605, 2617, 2890, 2900, 2907, 2908, 2912, 2912, 2943, 3004, 2342 3008, 3030, 3036, 3042, 3048, 3054, 3067, 3082, 3092, 3170, 2343 3221, 3222, 3223, 3224, 3225, 3226, 3232, 3232, 3464, 3464, 2344 3586, 3587, 3599, 3619, 3619, 3854, 3860, 3863, 3866, 3869, 2345 3872, 3875, 3880, 3910, 3914, 3917, 3920, 3925, 3929, 3934, 2346 3944, 3975, 3975, 4004, 4004, 4026, 4053, 4068, 4068, 4078, 2347 4079, 4080, 4080, 4096, 4097, 4114, 4115, 4116, 4117, 4118, 2348 4119, 4120, 4121, 4122, 4123, 4124, 4125, 4126, 4127, 4128, 2349 4129, 4138, 4163, 4187, 4228, 4243, 4261, 4280, 4287, 4294, 2350 4302, 4325, 4325, 4360, 4360, 4391, 4391, 4409, 4410, 4416, 2351 4419, 4423, 4426, 4427, 4428, 4429, 4430, 4431, 4432, 4433, 2352 4436, 4441, 4448, 4456, 4464, 4475, 4481, 4482, 4490, 4491, 2353 4492, 4493, 4494, 4495, 4502, 4513, 4517, 4520, 4524, 4528, 2354 4538, 4546, 4554, 4567, 4571, 4574, 4578, 4582, 4610, 4618, 2355 4629, 4643, 4652, 4660, 4670, 4674, 4678, 4685, 4702, 4719, 2356 4727, 4735, 4744, 4748, 4757, 4768, 4780, 4790, 4803, 4810, 2357 4818, 4834, 4842, 4853, 4864, 4875, 4894, 4902, 4919, 4927, 2358 4934, 4945, 4956, 4967, 4986, 4992, 4998, 5005, 5014, 5017, 2359 5026, 5033, 5040, 5050, 5061, 5072, 5083, 5090, 5097, 5100, 2360 5117, 5127, 5134, 5140, 5145, 5151, 5155, 5161, 5162, 5163, 2361 5169, 5175, 5179, 5180, 5184, 5191, 5194, 5195, 5196, 5197, 2362 5198, 5200, 5203, 5208, 5233, 5236, 5290, 5294, 5298, 5302, 2363 5306, 5310, 5314, 5318, 5322, 5326, 5330, 5334, 5338, 5342, 2364 5348, 5348, 5374, 5375, 5378, 5391, 5399, 5407, 5424, 5427, 2365 5442, 5443, 5462, 5463, 5467, 5472, 5473, 5487, 5494, 5511, 2366 5518, 5525, 5533, 5537, 5543, 5544, 5545, 5546, 5547, 5548, 2367 5549, 5552, 5556, 5560, 5564, 5568, 5572, 5576, 5580, 5584, 2368 5588, 5592, 5596, 5600, 5604, 5618, 5625, 5629, 5635, 5639, 2369 5643, 5647, 5651, 5667, 5672, 5672, 5673, 5676, 5693, 5702, 2370 5715, 5728, 5729, 5730, 5734, 5738, 5744, 5747, 5751, 5757, 2371 5758, 5761, 5766, 5771, 5776, 5783, 5790, 5797, 5805, 5813, 2372 5821, 5822, 5825, 5826, 5829, 5835, 5841, 5844, 5845, 5848, 2373 5849, 5852, 5857, 5861, 5864, 5867, 5870, 5875, 5879, 5882, 2374 5889, 5895, 5904, 5909, 5913, 5916, 5919, 5922, 5927, 5931, 2375 5934, 5937, 5943, 5948, 5951, 5954, 5958, 5963, 5976, 5980, 2376 5985, 5991, 5995, 6000, 6004, 6011, 6014, 6019 2377}; 2378#endif 2379 2380#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 2381/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 2382 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 2383static const char *const yytname[] = 2384{ 2385 "$end", "error", "$undefined", "ID", "HBLOCK", "POUND", "STRING", 2386 "INCLUDE", "IMPORT", "INSERT", "CHARCONST", "NUM_INT", "NUM_FLOAT", 2387 "NUM_UNSIGNED", "NUM_LONG", "NUM_ULONG", "NUM_LONGLONG", "NUM_ULONGLONG", 2388 "TYPEDEF", "TYPE_INT", "TYPE_UNSIGNED", "TYPE_SHORT", "TYPE_LONG", 2389 "TYPE_FLOAT", "TYPE_DOUBLE", "TYPE_CHAR", "TYPE_WCHAR", "TYPE_VOID", 2390 "TYPE_SIGNED", "TYPE_BOOL", "TYPE_COMPLEX", "TYPE_TYPEDEF", "TYPE_RAW", 2391 "TYPE_NON_ISO_INT8", "TYPE_NON_ISO_INT16", "TYPE_NON_ISO_INT32", 2392 "TYPE_NON_ISO_INT64", "LPAREN", "RPAREN", "COMMA", "SEMI", "EXTERN", 2393 "INIT", "LBRACE", "RBRACE", "PERIOD", "CONST_QUAL", "VOLATILE", 2394 "REGISTER", "STRUCT", "UNION", "EQUAL", "SIZEOF", "MODULE", "LBRACKET", 2395 "RBRACKET", "ILLEGAL", "CONSTANT", "NAME", "RENAME", "NAMEWARN", 2396 "EXTEND", "PRAGMA", "FEATURE", "VARARGS", "ENUM", "CLASS", "TYPENAME", 2397 "PRIVATE", "PUBLIC", "PROTECTED", "COLON", "STATIC", "VIRTUAL", "FRIEND", 2398 "THROW", "CATCH", "EXPLICIT", "USING", "NAMESPACE", "NATIVE", "INLINE", 2399 "TYPEMAP", "EXCEPT", "ECHO", "APPLY", "CLEAR", "SWIGTEMPLATE", 2400 "FRAGMENT", "WARN", "LESSTHAN", "GREATERTHAN", "MODULO", "DELETE_KW", 2401 "LESSTHANOREQUALTO", "GREATERTHANOREQUALTO", "EQUALTO", "NOTEQUALTO", 2402 "QUESTIONMARK", "TYPES", "PARMS", "NONID", "DSTAR", "DCNOT", "TEMPLATE", 2403 "OPERATOR", "COPERATOR", "PARSETYPE", "PARSEPARM", "PARSEPARMS", "CAST", 2404 "LOR", "LAND", "OR", "XOR", "AND", "RSHIFT", "LSHIFT", "MINUS", "PLUS", 2405 "MODULUS", "SLASH", "STAR", "LNOT", "NOT", "UMINUS", "DCOLON", "$accept", 2406 "program", "interface", "declaration", "swig_directive", 2407 "extend_directive", "@1", "apply_directive", "clear_directive", 2408 "constant_directive", "echo_directive", "except_directive", "stringtype", 2409 "fname", "fragment_directive", "include_directive", "@2", "includetype", 2410 "inline_directive", "insert_directive", "module_directive", 2411 "name_directive", "native_directive", "pragma_directive", "pragma_arg", 2412 "pragma_lang", "rename_directive", "rename_namewarn", 2413 "feature_directive", "stringbracesemi", "featattr", "varargs_directive", 2414 "varargs_parms", "typemap_directive", "typemap_type", "tm_list", 2415 "tm_tail", "typemap_parm", "types_directive", "template_directive", 2416 "warn_directive", "c_declaration", "@3", "c_decl", "c_decl_tail", 2417 "initializer", "c_enum_forward_decl", "c_enum_decl", 2418 "c_constructor_decl", "cpp_declaration", "cpp_class_decl", "@4", "@5", 2419 "cpp_opt_declarators", "cpp_forward_class_decl", "cpp_template_decl", 2420 "@6", "cpp_temp_possible", "template_parms", "templateparameters", 2421 "templateparameter", "templateparameterstail", "cpp_using_decl", 2422 "cpp_namespace_decl", "@7", "@8", "cpp_members", "@9", "@10", 2423 "cpp_member", "cpp_constructor_decl", "cpp_destructor_decl", 2424 "cpp_conversion_operator", "cpp_catch_decl", "cpp_protection_decl", 2425 "cpp_nested", "@11", "@12", "@13", "nested_decl", "cpp_swig_directive", 2426 "cpp_end", "cpp_vend", "anonymous_bitfield", "storage_class", "parms", 2427 "rawparms", "ptail", "parm", "valparms", "rawvalparms", "valptail", 2428 "valparm", "def_args", "parameter_declarator", 2429 "typemap_parameter_declarator", "declarator", "notso_direct_declarator", 2430 "direct_declarator", "abstract_declarator", "direct_abstract_declarator", 2431 "pointer", "type_qualifier", "type_qualifier_raw", "type", "rawtype", 2432 "type_right", "primitive_type", "primitive_type_list", "type_specifier", 2433 "definetype", "@14", "ename", "enumlist", "edecl", "etype", "expr", 2434 "valexpr", "exprnum", "exprcompound", "inherit", "raw_inherit", "@15", 2435 "base_list", "base_specifier", "access_specifier", "templcpptype", 2436 "cpptype", "opt_virtual", "cpp_const", "ctor_end", "ctor_initializer", 2437 "mem_initializer_list", "mem_initializer", "template_decl", "idstring", 2438 "idstringopt", "idcolon", "idcolontail", "idtemplate", "idcolonnt", 2439 "idcolontailnt", "string", "stringbrace", "options", "kwargs", 2440 "stringnum", "empty", 0 2441}; 2442#endif 2443 2444# ifdef YYPRINT 2445/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 2446 token YYLEX-NUM. */ 2447static const yytype_uint16 yytoknum[] = 2448{ 2449 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 2450 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 2451 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 2452 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 2453 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 2454 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 2455 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 2456 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 2457 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 2458 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 2459 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 2460 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 2461 375, 376, 377, 378, 379, 380, 381 2462}; 2463# endif 2464 2465/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 2466static const yytype_uint16 yyr1[] = 2467{ 2468 0, 127, 128, 128, 128, 128, 128, 128, 128, 129, 2469 129, 130, 130, 130, 130, 130, 130, 130, 131, 131, 2470 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 2471 131, 131, 131, 131, 131, 131, 131, 131, 131, 133, 2472 132, 134, 135, 136, 136, 136, 137, 137, 138, 138, 2473 138, 138, 139, 140, 140, 141, 141, 141, 143, 142, 2474 144, 144, 145, 145, 146, 146, 146, 146, 147, 148, 2475 148, 149, 149, 150, 150, 151, 151, 152, 152, 153, 2476 153, 153, 154, 154, 155, 155, 155, 155, 155, 155, 2477 155, 155, 156, 156, 156, 157, 157, 158, 159, 159, 2478 160, 160, 160, 161, 162, 163, 163, 164, 164, 164, 2479 165, 166, 167, 168, 168, 168, 169, 168, 170, 171, 2480 171, 171, 172, 172, 172, 172, 173, 174, 174, 175, 2481 176, 176, 176, 176, 176, 176, 178, 177, 179, 177, 2482 180, 180, 181, 183, 182, 182, 184, 184, 184, 184, 2483 184, 184, 185, 186, 186, 187, 187, 188, 188, 189, 2484 189, 191, 190, 192, 190, 190, 193, 194, 193, 193, 2485 193, 195, 193, 196, 196, 196, 196, 196, 196, 196, 2486 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 2487 196, 197, 198, 198, 199, 199, 199, 200, 201, 201, 2488 201, 203, 202, 204, 202, 205, 202, 206, 206, 207, 2489 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 2490 208, 208, 209, 209, 209, 210, 211, 211, 211, 211, 2491 211, 211, 211, 211, 212, 213, 213, 214, 214, 215, 2492 215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 2493 220, 220, 220, 220, 221, 221, 221, 222, 222, 222, 2494 223, 223, 223, 223, 223, 223, 223, 223, 224, 224, 2495 224, 224, 224, 224, 224, 224, 225, 225, 225, 225, 2496 225, 225, 225, 225, 226, 226, 226, 226, 226, 226, 2497 226, 226, 226, 226, 227, 227, 227, 227, 227, 227, 2498 227, 228, 228, 228, 228, 229, 229, 230, 230, 230, 2499 231, 232, 232, 232, 232, 233, 233, 233, 233, 233, 2500 233, 233, 233, 234, 235, 235, 236, 236, 236, 236, 2501 236, 236, 236, 236, 236, 236, 236, 236, 236, 236, 2502 238, 237, 239, 239, 240, 240, 241, 241, 241, 242, 2503 243, 243, 244, 244, 244, 244, 244, 244, 244, 244, 2504 244, 244, 244, 244, 245, 245, 245, 245, 245, 245, 2505 245, 246, 246, 246, 246, 246, 246, 246, 246, 246, 2506 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, 2507 246, 246, 246, 247, 249, 248, 248, 250, 250, 251, 2508 251, 252, 252, 252, 253, 253, 254, 254, 254, 255, 2509 255, 256, 256, 256, 256, 257, 257, 257, 257, 257, 2510 258, 258, 259, 259, 260, 261, 261, 262, 262, 263, 2511 263, 264, 264, 264, 264, 264, 264, 265, 265, 265, 2512 265, 266, 267, 267, 267, 267, 267, 267, 268, 268, 2513 268, 268, 269, 269, 270, 270, 270, 271, 271, 272, 2514 272, 272, 272, 272, 272, 273, 273, 274 2515}; 2516 2517/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 2518static const yytype_uint8 yyr2[] = 2519{ 2520 0, 2, 1, 3, 2, 3, 2, 5, 3, 2, 2521 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2522 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2523 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2524 7, 5, 3, 5, 5, 3, 2, 2, 5, 2, 2525 5, 2, 4, 1, 1, 7, 7, 5, 0, 7, 2526 1, 1, 2, 2, 1, 5, 5, 5, 3, 4, 2527 3, 7, 8, 5, 3, 1, 1, 3, 1, 4, 2528 7, 6, 1, 1, 7, 9, 8, 10, 5, 7, 2529 6, 8, 1, 1, 5, 4, 5, 7, 1, 3, 2530 6, 6, 8, 1, 2, 3, 1, 2, 3, 6, 2531 5, 9, 2, 1, 1, 1, 0, 6, 5, 1, 2532 4, 1, 1, 2, 5, 6, 4, 7, 8, 6, 2533 1, 1, 1, 1, 1, 1, 0, 9, 0, 8, 2534 1, 2, 4, 0, 6, 3, 1, 1, 1, 1, 2535 1, 1, 1, 2, 1, 1, 1, 3, 1, 3, 2536 4, 0, 6, 0, 5, 5, 2, 0, 6, 1, 2537 1, 0, 3, 1, 1, 1, 1, 1, 1, 1, 2538 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 2539 1, 6, 6, 7, 8, 8, 7, 5, 2, 2, 2540 2, 0, 7, 0, 6, 0, 8, 1, 1, 1, 2541 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2542 2, 2, 2, 4, 2, 5, 1, 2, 1, 1, 2543 1, 1, 1, 1, 1, 2, 1, 3, 1, 2, 2544 7, 3, 1, 2, 1, 3, 1, 1, 1, 2, 2545 5, 2, 2, 1, 2, 2, 1, 1, 1, 1, 2546 2, 3, 1, 2, 3, 4, 5, 4, 1, 2, 2547 3, 4, 5, 3, 4, 4, 1, 2, 4, 4, 2548 5, 3, 4, 4, 1, 2, 2, 3, 1, 2, 2549 1, 2, 3, 4, 3, 4, 2, 3, 3, 4, 2550 3, 3, 2, 2, 1, 1, 2, 1, 1, 1, 2551 1, 2, 1, 2, 3, 1, 1, 1, 2, 2, 2552 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 2553 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2554 0, 2, 1, 1, 3, 1, 1, 3, 1, 1, 2555 1, 1, 1, 1, 5, 1, 1, 3, 4, 5, 2556 5, 6, 2, 2, 1, 1, 1, 1, 1, 1, 2557 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2558 3, 3, 3, 3, 3, 3, 3, 5, 2, 2, 2559 2, 2, 2, 1, 0, 3, 1, 1, 3, 2, 2560 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2561 1, 1, 4, 5, 1, 3, 3, 4, 4, 3, 2562 2, 1, 1, 3, 2, 3, 1, 1, 1, 1, 2563 1, 2, 4, 1, 3, 1, 3, 3, 2, 2, 2564 2, 2, 2, 4, 1, 3, 1, 3, 3, 2, 2565 2, 2, 2, 1, 1, 1, 1, 3, 1, 3, 2566 5, 1, 3, 3, 5, 1, 1, 0 2567}; 2568 2569/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 2570 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 2571 means the default is an error. */ 2572static const yytype_uint16 yydefact[] = 2573{ 2574 467, 0, 0, 0, 0, 0, 10, 4, 467, 326, 2575 334, 327, 328, 331, 332, 329, 330, 317, 333, 316, 2576 335, 467, 320, 336, 337, 338, 339, 0, 307, 308, 2577 309, 407, 408, 0, 404, 405, 0, 0, 435, 0, 2578 0, 305, 467, 312, 315, 323, 324, 406, 0, 321, 2579 433, 6, 0, 0, 467, 1, 15, 64, 60, 61, 2580 0, 229, 14, 226, 467, 0, 0, 82, 83, 467, 2581 467, 0, 0, 228, 230, 231, 0, 232, 0, 0, 2582 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2583 0, 0, 9, 11, 18, 19, 20, 21, 22, 23, 2584 24, 25, 467, 26, 27, 28, 29, 30, 31, 32, 2585 0, 33, 34, 35, 36, 37, 38, 12, 113, 115, 2586 114, 16, 13, 130, 131, 132, 133, 134, 135, 0, 2587 233, 467, 441, 426, 318, 0, 319, 0, 0, 3, 2588 311, 306, 467, 340, 0, 0, 290, 304, 0, 256, 2589 239, 467, 262, 467, 288, 284, 276, 253, 313, 325, 2590 322, 0, 0, 431, 5, 8, 0, 234, 467, 236, 2591 17, 0, 453, 227, 0, 0, 458, 0, 467, 0, 2592 310, 0, 0, 0, 0, 78, 0, 467, 467, 0, 2593 0, 467, 163, 0, 0, 62, 63, 0, 0, 51, 2594 49, 46, 47, 467, 0, 467, 0, 467, 467, 0, 2595 112, 467, 467, 0, 0, 0, 0, 0, 0, 276, 2596 467, 0, 0, 356, 364, 365, 366, 367, 368, 369, 2597 370, 0, 0, 0, 0, 0, 0, 0, 0, 247, 2598 0, 242, 467, 351, 310, 0, 350, 352, 355, 353, 2599 244, 241, 436, 434, 0, 314, 467, 290, 0, 0, 2600 284, 321, 251, 249, 0, 296, 0, 350, 252, 467, 2601 0, 263, 289, 268, 302, 303, 277, 254, 467, 0, 2602 255, 467, 0, 286, 260, 285, 268, 291, 440, 439, 2603 438, 0, 0, 235, 238, 427, 0, 428, 452, 116, 2604 461, 0, 68, 45, 340, 0, 467, 70, 0, 0, 2605 0, 74, 0, 0, 0, 98, 0, 0, 159, 0, 2606 467, 161, 0, 0, 103, 0, 0, 0, 107, 257, 2607 258, 259, 42, 0, 104, 106, 429, 0, 430, 54, 2608 0, 53, 0, 0, 152, 467, 156, 406, 154, 145, 2609 0, 427, 0, 0, 0, 0, 0, 0, 0, 268, 2610 0, 467, 0, 343, 467, 467, 138, 322, 0, 0, 2611 362, 388, 389, 363, 391, 390, 425, 0, 243, 246, 2612 392, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2613 0, 0, 0, 0, 0, 0, 0, 0, 432, 0, 2614 290, 284, 321, 0, 276, 300, 298, 286, 0, 276, 2615 291, 0, 341, 297, 284, 321, 269, 467, 0, 301, 2616 0, 281, 0, 0, 294, 0, 261, 287, 292, 0, 2617 264, 437, 7, 467, 0, 467, 0, 0, 457, 0, 2618 0, 69, 39, 77, 0, 0, 0, 0, 0, 0, 2619 0, 160, 0, 0, 467, 467, 0, 0, 108, 0, 2620 467, 0, 0, 0, 0, 0, 143, 0, 153, 158, 2621 58, 0, 0, 0, 0, 79, 0, 126, 467, 0, 2622 321, 0, 0, 122, 467, 0, 142, 394, 0, 393, 2623 396, 357, 0, 304, 0, 467, 467, 386, 385, 383, 2624 384, 0, 382, 381, 377, 378, 376, 380, 379, 372, 2625 371, 375, 374, 373, 0, 0, 291, 279, 278, 292, 2626 0, 0, 0, 268, 270, 291, 0, 273, 0, 283, 2627 282, 299, 295, 0, 265, 293, 267, 237, 66, 67, 2628 65, 0, 462, 463, 466, 465, 459, 43, 44, 0, 2629 76, 73, 75, 456, 93, 455, 0, 88, 467, 454, 2630 92, 0, 465, 0, 0, 99, 467, 197, 165, 164, 2631 0, 226, 0, 0, 50, 48, 467, 41, 105, 444, 2632 0, 446, 0, 57, 0, 0, 110, 467, 467, 467, 2633 467, 0, 0, 346, 0, 345, 348, 467, 467, 0, 2634 119, 121, 118, 0, 123, 171, 190, 0, 0, 0, 2635 0, 230, 0, 217, 218, 210, 219, 188, 169, 215, 2636 211, 209, 212, 213, 214, 216, 189, 185, 186, 173, 2637 179, 183, 182, 0, 0, 174, 175, 178, 184, 176, 2638 180, 177, 187, 0, 233, 467, 136, 358, 0, 304, 2639 303, 0, 0, 0, 245, 0, 467, 280, 250, 271, 2640 0, 275, 274, 266, 117, 0, 0, 0, 467, 0, 2641 411, 0, 414, 0, 0, 0, 0, 90, 467, 0, 2642 162, 227, 467, 0, 101, 0, 100, 0, 0, 0, 2643 442, 0, 467, 0, 52, 146, 147, 150, 149, 144, 2644 148, 151, 0, 157, 0, 0, 81, 0, 467, 0, 2645 467, 340, 467, 129, 0, 467, 467, 0, 167, 199, 2646 198, 200, 0, 0, 0, 166, 0, 0, 0, 321, 2647 409, 395, 397, 0, 410, 0, 360, 359, 0, 354, 2648 387, 240, 272, 464, 460, 40, 0, 467, 0, 84, 2649 465, 95, 89, 467, 0, 0, 97, 71, 0, 0, 2650 109, 451, 449, 450, 445, 447, 0, 55, 56, 0, 2651 59, 80, 347, 349, 344, 127, 0, 0, 0, 0, 2652 0, 421, 467, 0, 0, 172, 0, 0, 467, 0, 2653 0, 467, 0, 467, 203, 322, 181, 467, 402, 401, 2654 403, 467, 399, 0, 361, 0, 0, 467, 96, 0, 2655 91, 467, 86, 72, 102, 448, 443, 0, 128, 0, 2656 419, 420, 422, 0, 415, 416, 124, 120, 467, 0, 2657 467, 0, 139, 467, 0, 0, 0, 0, 201, 467, 2658 467, 398, 0, 0, 94, 412, 0, 85, 0, 111, 2659 417, 418, 0, 424, 125, 0, 0, 467, 0, 467, 2660 467, 467, 225, 467, 0, 207, 208, 0, 400, 140, 2661 137, 0, 413, 87, 423, 168, 467, 192, 0, 467, 2662 0, 0, 191, 0, 204, 205, 141, 193, 0, 220, 2663 221, 196, 467, 467, 202, 0, 222, 224, 340, 195, 2664 194, 206, 0, 223 2665}; 2666 2667/* YYDEFGOTO[NTERM-NUM]. */ 2668static const yytype_int16 yydefgoto[] = 2669{ 2670 -1, 4, 5, 92, 93, 94, 549, 613, 614, 615, 2671 616, 99, 339, 340, 617, 618, 589, 102, 103, 619, 2672 105, 620, 107, 621, 551, 184, 622, 110, 623, 557, 2673 447, 624, 314, 625, 323, 206, 334, 207, 626, 627, 2674 628, 629, 435, 118, 602, 482, 119, 120, 121, 122, 2675 123, 735, 485, 870, 630, 631, 587, 699, 343, 344, 2676 345, 468, 632, 127, 454, 320, 633, 786, 717, 634, 2677 635, 636, 637, 638, 639, 640, 863, 839, 895, 864, 2678 641, 877, 887, 642, 643, 258, 167, 293, 168, 240, 2679 241, 378, 242, 149, 150, 328, 151, 271, 152, 153, 2680 154, 218, 40, 41, 243, 180, 43, 44, 45, 46, 2681 263, 264, 362, 594, 595, 772, 245, 267, 247, 248, 2682 488, 489, 645, 731, 732, 801, 47, 48, 733, 888, 2683 713, 780, 821, 822, 132, 300, 337, 49, 163, 50, 2684 582, 690, 249, 560, 175, 301, 546, 169 2685}; 2686 2687/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 2688 STATE-NUM. */ 2689#define YYPACT_NINF -550 2690static const yytype_int16 yypact[] = 2691{ 2692 590, 3291, 3341, 121, 117, 2846, -550, -550, -67, -550, 2693 -550, -550, -550, -550, -550, -550, -550, -550, -550, -550, 2694 -550, -67, -550, -550, -550, -550, -550, 115, -550, -550, 2695 -550, -550, -550, 191, -550, -550, 75, 161, -550, 156, 2696 3797, 717, 325, 717, -550, -550, 1803, -550, 191, -550, 2697 100, -550, 221, 227, 3549, -550, 166, -550, -550, -550, 2698 288, -550, -550, 318, 298, 3401, 303, -550, -550, 298, 2699 311, 333, 366, -550, -550, -550, 392, -550, 116, 42, 2700 420, 106, 431, 429, 384, 3599, 3599, 442, 455, 318, 2701 465, 600, -550, -550, -550, -550, -550, -550, -550, -550, 2702 -550, -550, 298, -550, -550, -550, -550, -550, -550, -550, 2703 983, -550, -550, -550, -550, -550, -550, -550, -550, -550, 2704 -550, -550, -550, -550, -550, -550, -550, -550, -550, 3648, 2705 -550, 1740, -550, -550, -550, 296, -550, 49, 461, -550, 2706 717, -550, 2522, 463, 1862, 2350, 87, 241, 191, -550, 2707 -550, 104, 323, 104, 356, 176, 252, -550, -550, -550, 2708 -550, 518, 77, -550, -550, -550, 484, -550, 487, -550, 2709 -550, 377, -550, 126, 377, 377, -550, 532, 108, 1003, 2710 -550, 256, 191, 530, 571, -550, 377, 1522, 3549, 191, 2711 562, 129, -550, 573, 616, -550, -550, 377, 620, -550, 2712 -550, -550, 623, 3549, 583, 228, 592, 596, 377, 318, 2713 623, 3549, 3549, 191, 318, 270, 381, 377, 312, 535, 2714 194, 1014, 85, -550, -550, -550, -550, -550, -550, -550, 2715 -550, 2350, 610, 2350, 2350, 2350, 2350, 2350, 2350, -550, 2716 557, -550, 613, 621, 113, 1699, -8, -550, -550, 623, 2717 -550, -550, -550, 100, 568, -550, 2626, 742, 615, 626, 2718 928, 561, -550, 614, 2350, -550, 1825, -550, 1699, 2626, 2719 191, 387, 356, -550, -550, 552, -550, -550, 3549, 1984, 2720 -550, 3549, 2106, 87, 387, 356, 575, 720, -550, -550, 2721 100, 635, 3549, -550, -550, -550, 641, 623, -550, -550, 2722 330, 646, -550, -550, -550, 715, 104, -550, 649, 650, 2723 657, 652, 53, 667, 669, -550, 673, 684, -550, 191, 2724 -550, -550, 688, 698, -550, 700, 703, 3599, -550, -550, 2725 -550, -550, -550, 3599, -550, -550, -550, 705, -550, -550, 2726 207, 131, 706, 655, -550, 708, -550, 43, -550, -550, 2727 20, 317, 933, 933, 648, 722, 105, 738, 381, 681, 2728 720, 83, 745, -550, 2687, 625, -550, 287, 1197, 3698, 2729 1163, -550, -550, -550, -550, -550, -550, 1740, -550, -550, 2730 -550, 2350, 2350, 2350, 2350, 2350, 2350, 2350, 2350, 2350, 2731 2350, 2350, 2350, 2350, 2350, 2350, 2350, 2350, -550, 461, 2732 443, 341, 689, 284, -550, -550, -550, 443, 394, 696, 2733 933, 2350, 1699, -550, 970, 13, -550, 3549, 2228, -550, 2734 752, -550, 1947, 762, -550, 2069, 387, 356, 1027, 381, 2735 387, -550, -550, 487, 304, -550, 377, 1212, -550, 765, 2736 766, -550, -550, -550, 509, 651, 1958, 770, 3549, 1003, 2737 779, -550, 769, 2935, -550, 865, 3599, 497, 787, 782, 2738 596, 281, 789, 377, 3549, 538, -550, 3549, -550, -550, 2739 -550, 933, 299, 381, 25, -550, 874, -550, 829, 793, 2740 648, 801, 690, -550, 203, 1621, -550, -550, 798, -550, 2741 -550, 2350, 1404, 2472, 15, 325, 613, 1057, 1057, 1122, 2742 1122, 2716, 1382, 1479, 1489, 1249, 1163, 828, 828, 692, 2743 692, -550, -550, -550, 191, 696, -550, -550, -550, 443, 2744 407, 2191, 493, 696, -550, 381, 808, -550, 2313, -550, 2745 -550, -550, -550, 381, 387, 356, 387, -550, -550, -550, 2746 623, 3024, -550, 809, -550, 131, 811, -550, -550, 1621, 2747 -550, -550, 623, -550, -550, -550, 814, -550, 674, 623, 2748 -550, 802, 78, 265, 651, -550, 674, -550, -550, -550, 2749 3113, 318, 3747, 351, -550, -550, 3549, -550, -550, 213, 2750 736, -550, 774, -550, 818, 821, -550, 730, 708, -550, 2751 674, 230, 381, 816, 94, -550, -550, 823, 3549, 1003, 2752 -550, -550, -550, 831, -550, -550, -550, 830, 813, 815, 2753 817, 748, 518, -550, -550, -550, -550, -550, -550, -550, 2754 -550, -550, -550, -550, -550, -550, -550, -550, -550, -550, 2755 -550, -550, -550, 836, 1621, -550, -550, -550, -550, -550, 2756 -550, -550, -550, 3450, 845, 822, -550, 1699, 2350, 2472, 2757 2740, 2350, 852, 853, -550, 2350, 104, -550, -550, -550, 2758 498, -550, -550, 387, -550, 377, 377, 855, 3549, 871, 2759 835, 538, -550, 1212, 879, 377, 875, -550, 674, 877, 2760 -550, 623, -1, 1003, -550, 3599, -550, 882, 912, 84, 2761 -550, 111, 1740, 196, -550, -550, -550, -550, -550, -550, 2762 -550, -550, 3500, -550, 3202, 884, -550, 2350, 829, 926, 2763 3549, -550, 851, -550, 887, 625, 3549, 1621, -550, -550, 2764 -550, -550, 518, 889, 1003, -550, 3698, 41, 212, 890, 2765 -550, 888, -550, 369, -550, 1621, 1699, 1699, 2350, -550, 2766 1837, -550, -550, -550, -550, -550, 894, 3549, 916, -550, 2767 623, 917, -550, 674, 948, 538, -550, -550, 918, 922, 2768 -550, -550, 213, -550, 213, -550, 873, -550, -550, 1032, 2769 -550, -550, -550, 1699, -550, -550, 690, 929, 931, 191, 2770 505, -550, 104, 690, 930, -550, 1621, 932, 3549, 690, 2771 -15, 2687, 2350, 19, -550, 198, -550, 822, -550, -550, 2772 -550, 822, -550, 934, 1699, 936, 949, 3549, -550, 950, 2773 -550, 674, -550, -550, -550, -550, -550, 951, -550, 514, 2774 -550, 953, -550, 935, -550, -550, -550, -550, 104, 956, 2775 3549, 959, -550, 3549, 965, 967, 972, 1618, -550, 1003, 2776 822, -550, 191, 978, -550, -550, 973, -550, 974, -550, 2777 -550, -550, 191, -550, -550, 1621, 975, 674, 985, 3549, 2778 3549, 823, -550, 1003, 981, -550, -550, 372, -550, -550, 2779 -550, 690, -550, -550, -550, -550, 674, -550, 543, 674, 2780 987, 990, -550, 996, -550, -550, -550, -550, 447, -550, 2781 -550, -550, 674, 674, -550, 997, -550, -550, -550, -550, 2782 -550, -550, 999, -550 2783}; 2784 2785/* YYPGOTO[NTERM-NUM]. */ 2786static const yytype_int16 yypgoto[] = 2787{ 2788 -550, -550, -314, -550, -550, -550, -550, 10, 12, 23, 2789 24, -550, 605, -550, 28, 30, -550, -550, -550, 35, 2790 -550, 36, -550, 38, -550, -550, 50, -550, 54, -446, 2791 -549, 55, -550, 63, -550, -311, 545, -84, 66, 70, 2792 72, 76, -550, 425, -377, 332, -550, -550, -550, -550, 2793 467, -550, -550, -550, -2, 5, -550, -550, -550, -550, 2794 588, 468, 81, -550, -550, -550, -536, -550, -550, -550, 2795 472, -550, 473, 90, -550, -550, -550, -550, -550, 199, 2796 -550, -550, -375, -550, -3, 186, -550, 628, 222, 373, 2797 -550, 570, 691, -97, 572, -550, -44, -117, -181, -112, 2798 -121, -22, -34, -550, 576, 45, -36, -550, 1028, -550, 2799 -286, -550, -550, -550, 365, -550, 966, -119, -410, -550, 2800 -550, -550, -550, 236, 280, -550, -201, -33, 277, -493, 2801 219, -550, -550, 234, 1061, -114, -550, 739, -142, -113, 2802 -550, -202, 726, 516, 183, -165, -409, 0 2803}; 2804 2805/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 2806 positive, shift that token. If negative, reduce the rule which 2807 number is the opposite. If zero, do what YYDEFACT says. 2808 If YYTABLE_NINF, syntax error. */ 2809#define YYTABLE_NINF -468 2810static const yytype_int16 yytable[] = 2811{ 2812 6, 204, 129, 124, 140, 130, 453, 141, 133, 158, 2813 125, 347, 246, 667, 676, 95, 459, 96, 439, 586, 2814 155, 133, 833, 131, 253, 272, 298, 544, 97, 98, 2815 259, -248, 324, 100, 285, 101, 544, 563, 284, 757, 2816 104, 106, 157, 108, 8, 191, 42, 42, 288, 290, 2817 355, 524, 8, 651, 277, 109, 280, 296, 213, 111, 2818 112, 302, 838, 524, 176, 671, 217, 308, 113, 176, 2819 185, 114, 312, 679, 470, 115, 403, 116, 791, 408, 2820 8, 117, -155, -248, 298, 192, 126, 762, 8, 131, 2821 8, 445, 446, 330, 336, 128, 222, 705, 725, 42, 2822 834, 284, 176, 357, 712, 254, 255, 147, 8, 131, 2823 195, 398, 792, 275, 764, 525, 8, 55, 677, 8, 2824 260, 541, 53, 477, 269, 274, -342, 592, 366, -428, 2825 652, 250, 298, 708, -155, 306, 272, 298, 709, 285, 2826 570, 144, 36, 36, 259, 573, 38, 38, 431, 196, 2827 142, 157, -467, 157, 252, 143, 216, 259, 54, 304, 2828 135, 329, 427, 147, 143, 148, 426, 144, 294, 299, 2829 430, 403, 408, 131, 464, 145, 244, 365, 133, 8, 2830 319, 785, 289, 155, 145, 755, 36, 42, 36, 763, 2831 38, 133, 38, 353, 8, 189, 139, 361, 131, 803, 2832 767, 137, 808, 161, -467, 331, 36, 335, 338, 440, 2833 38, 270, 348, 269, 36, 793, 765, 36, 38, 131, 2834 363, 38, 155, 39, 52, 749, 162, 147, 146, 520, 2835 144, 8, 42, 42, 401, 147, 298, 148, 486, 768, 2836 166, 426, 379, 430, 157, 462, 463, 414, 42, 460, 2837 829, 138, 182, 419, 143, 794, 42, 42, 246, 295, 2838 809, 164, 172, 544, 751, 142, 347, 165, 483, 840, 2839 706, 542, 170, 351, 145, 704, 172, 36, 603, 272, 2840 285, 38, 144, 353, 579, 214, 427, 28, 29, 30, 2841 520, 283, 36, 285, 307, 36, 38, 522, 584, 38, 2842 270, 42, 8, 674, 675, 172, 157, 535, 538, 812, 2843 172, 534, 536, 36, 42, 8, 688, 38, 848, 875, 2844 6, 278, 517, 42, 172, 171, 42, 486, 8, 36, 2845 -467, 484, 561, 38, 473, 174, 305, 42, 279, 689, 2846 181, 251, 353, 146, 8, 469, 494, 539, 183, 356, 2847 147, 133, 148, 239, 287, 553, 522, 172, 487, 534, 2848 278, 133, 142, 147, 878, 157, 514, 490, 712, 436, 2849 186, 36, 8, 315, 316, 38, 143, 279, 256, 144, 2850 295, 437, 580, 172, 8, 352, 581, 604, 201, 326, 2851 172, 684, 147, 281, 555, 144, 145, 342, 535, 818, 2852 36, 558, 685, 187, 38, 566, 827, 131, 660, 42, 2853 282, 797, 832, 36, 216, 885, 663, 38, 356, -467, 2854 -467, 147, 244, 148, 417, 778, 36, 358, 590, 188, 2855 38, 278, 518, 294, 346, 6, 270, 798, 799, 800, 2856 146, 418, 36, -467, 278, 657, 38, 147, 279, 148, 2857 129, 124, 572, 130, 6, 130, 407, 194, 125, 650, 2858 335, 279, 42, 95, 420, 96, 198, 423, 197, 199, 2859 36, 274, 200, 155, 38, 660, 97, 98, 596, 208, 2860 256, 100, 36, 101, 157, 644, 38, 896, 104, 106, 2861 897, 108, 209, 42, 886, 157, 379, 144, 898, 723, 2862 743, 744, 211, 109, 891, 270, 262, 111, 112, 42, 2863 31, 32, 42, 550, 433, 172, 113, 899, 900, 114, 2864 678, 8, 291, 115, 670, 116, 292, 34, 35, 117, 2865 417, 659, 670, 310, 126, 417, 742, 574, 129, 124, 2866 575, 130, 553, 128, 172, 824, 125, 418, 825, 644, 2867 479, 95, 418, 96, 850, 715, 670, 851, 672, 741, 2868 815, 561, 816, 670, 97, 98, 672, 129, 124, 100, 2869 130, 101, 303, 246, 311, 125, 104, 106, 554, 108, 2870 95, 555, 96, 889, 702, 697, 890, 130, 469, 6, 2871 672, 109, 698, 97, 98, 111, 112, 672, 100, 239, 2872 101, 759, 318, 526, 113, 104, 106, 114, 108, 787, 2873 728, 115, 902, 116, 140, 650, 321, 117, 483, 322, 2874 109, 42, 126, 325, 111, 112, 327, 274, 419, 298, 2875 753, 128, 332, 113, 644, 333, 114, 360, 556, 758, 2876 115, 179, 116, 42, 670, 734, 117, 369, 376, 31, 2877 32, 126, 377, 405, 8, 553, 157, 172, 380, 399, 2878 128, 205, 205, 410, 406, 776, 34, 35, 411, 222, 2879 565, 28, 29, 30, 147, 432, 143, 428, 672, 434, 2880 789, 484, 133, 365, 438, 826, 585, 441, 305, 346, 2881 212, 554, 250, 442, 555, 443, 145, 1, 2, 3, 2882 481, 129, 124, 444, 130, 221, 448, 449, 596, 125, 2883 811, 450, 781, 42, 95, 157, 96, 644, 8, 670, 2884 28, 29, 30, 8, 451, 365, 455, 97, 98, 599, 2885 600, 854, 100, 601, 101, 644, 456, 244, 457, 104, 2886 106, 458, 108, 461, 465, 8, 466, 467, 61, 669, 2887 471, 556, 36, 672, 109, 42, 38, 356, 111, 112, 2888 472, 42, 687, 28, 29, 30, 216, 113, 835, 353, 2889 114, 571, 136, 147, 115, 148, 116, 670, 475, 142, 2890 117, 156, 157, 476, 714, 126, 644, 160, 478, 173, 2891 529, 516, 42, 133, 128, 865, 144, 734, 519, 871, 2892 531, 734, 73, 74, 75, 547, 548, 77, 564, 568, 2893 202, 672, 395, 396, 397, 210, 36, 190, 193, 865, 2894 38, 36, 567, 670, 576, 38, 577, 670, 157, 583, 2895 352, 597, 593, 42, 91, 429, 42, 147, 598, 866, 2896 734, 646, 670, 36, 270, 670, 661, 38, 665, 219, 2897 666, 668, 42, 673, 746, 644, 693, 672, 670, 670, 2898 710, 672, 691, 866, 692, 694, 148, 707, 716, 28, 2899 29, 30, 722, 718, 711, 42, 672, 8, 42, 672, 2900 724, 261, 8, 61, 719, 273, 720, 276, 721, -170, 2901 738, 739, 672, 672, 286, 730, 777, 297, 669, 745, 2902 297, 297, 784, 205, 42, 42, 571, 297, 747, 205, 2903 748, 356, 297, 754, 239, 761, 305, 756, 219, 752, 2904 760, 309, 779, 297, 771, 782, 788, 797, 317, 8, 2905 796, 8, 805, 806, 297, 341, 8, 73, 74, 75, 2906 350, 297, 77, 297, 156, 495, 393, 394, 395, 396, 2907 397, 8, 349, 807, 354, 273, 675, 359, 813, 136, 2908 219, 367, 814, 305, 817, 142, 775, 819, 828, 830, 2909 305, 820, 853, 8, 831, 36, 844, 836, 843, 38, 2910 36, 8, 144, 156, 38, 305, 8, 845, 810, 533, 2911 847, 849, 852, 846, 216, 402, 404, 857, 270, 409, 2912 855, 147, 859, 148, 860, 578, 8, 269, 415, 416, 2913 861, 872, 695, 876, 873, 305, 856, 8, 869, 858, 2914 215, 884, 273, 879, 144, 892, 273, 36, 893, 36, 2915 8, 38, 205, 38, 36, 8, 894, 901, 38, 903, 2916 305, 216, 543, 407, 354, 880, 881, 783, 147, 36, 2917 148, 364, 148, 38, 696, 588, 703, 148, 452, 700, 2918 701, 537, 883, 216, 269, 766, 654, 653, 496, 791, 2919 147, 36, 148, 774, 159, 38, 867, 841, 842, 36, 2920 882, 144, 134, 38, 36, 407, 874, 0, 38, 686, 2921 0, 404, 404, 216, 270, 474, 0, 273, 216, 273, 2922 147, 0, 148, 480, 36, 147, 0, 148, 38, 0, 2923 266, 268, 0, 0, 0, 36, 0, 0, 216, 38, 2924 0, 0, 0, 0, 0, 147, 0, 148, 36, 216, 2925 0, 0, 38, 36, 0, 0, 147, 38, 148, 0, 2926 515, 0, 533, 0, 0, 0, 0, 216, 683, 404, 2927 0, 270, 0, 523, 147, 0, 148, 0, 0, 0, 2928 540, 0, 297, 545, 0, 0, 0, 273, 273, 0, 2929 552, 559, 562, 391, 392, 393, 394, 395, 396, 397, 2930 0, 0, 0, 0, 219, 0, 0, 0, 219, 297, 2931 0, 559, 0, 0, 0, 0, 0, 368, 591, 370, 2932 371, 372, 373, 374, 375, 0, 0, 0, 0, 0, 2933 404, 219, 273, 0, 0, 273, 381, 382, 172, 727, 2934 0, 0, 0, 224, 225, 226, 227, 228, 229, 230, 2935 412, 0, 0, 0, 156, 491, 0, 0, 391, 392, 2936 393, 394, 395, 396, 397, 422, 0, 0, 425, 0, 2937 0, 0, 0, 656, 0, 0, 0, 381, 382, 383, 2938 384, 205, 0, 0, 273, 0, 0, 0, 0, 0, 2939 0, 0, 273, 0, 0, 0, 0, 0, 769, 391, 2940 392, 393, 394, 395, 396, 397, 0, 0, 0, 0, 2941 559, 381, 382, 383, 384, 385, 0, 681, 0, 559, 2942 0, 0, 790, 219, 0, 0, 0, 0, 386, 387, 2943 388, 389, 492, 391, 392, 393, 394, 395, 396, 493, 2944 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2945 0, 273, 0, 0, 0, 0, 0, 0, 219, 0, 2946 0, 0, 0, 381, 382, 383, 384, 497, 498, 499, 2947 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 2948 510, 511, 512, 513, 390, 391, 392, 393, 394, 395, 2949 396, 397, 0, 0, 0, 0, 0, 521, 0, 0, 2950 0, 0, 729, 0, 528, 0, 0, 0, 0, 0, 2951 0, 297, 297, 0, 0, 0, 0, 559, 0, 750, 2952 0, 297, 0, 0, 0, 0, 0, 8, 0, 0, 2953 172, 0, 0, 219, 223, 224, 225, 226, 227, 228, 2954 229, 230, 219, 9, 10, 11, 12, 13, 14, 15, 2955 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 2956 26, 231, 648, 0, 0, 0, 0, 0, 219, 0, 2957 28, 29, 30, 31, 32, 0, 232, 647, 506, 513, 2958 0, 0, 0, 219, 0, 0, 219, 795, 0, 33, 2959 34, 35, 802, 0, 0, 0, 381, 382, 383, 384, 2960 0, 559, 0, 0, 0, 0, 0, 0, 0, 0, 2961 0, 0, 0, 219, 387, 388, 389, 390, 391, 392, 2962 393, 394, 395, 396, 397, 36, 0, 0, 219, 38, 2963 0, 0, 0, 0, 0, 0, 0, 0, 823, 233, 2964 0, 0, 234, 235, 0, 8, 236, 237, 238, 0, 2965 480, 0, 0, 313, 0, 0, 0, 0, 0, 0, 2966 0, 9, 10, 11, 12, 13, 14, 15, 16, 17, 2967 18, 19, 20, 21, 22, 23, 24, 25, 26, 0, 2968 0, 0, 0, 0, 0, 0, 0, 27, 28, 29, 2969 30, 31, 32, 381, 382, 383, 384, 0, 219, 0, 2970 0, 868, 219, 381, 382, 383, 384, 33, 34, 35, 2971 0, 823, 388, 389, 390, 391, 392, 393, 394, 395, 2972 396, 397, 219, 389, 390, 391, 392, 393, 394, 395, 2973 396, 397, 0, 0, 736, 373, 0, 737, 0, 0, 2974 0, 740, 605, 36, -467, 57, 37, 38, 58, 59, 2975 60, 0, 0, 0, 0, 0, 0, 0, 0, 61, 2976 -467, -467, -467, -467, -467, -467, -467, -467, -467, -467, 2977 -467, -467, -467, -467, -467, -467, -467, -467, 862, 0, 2978 0, 606, 63, 0, 0, -467, 0, -467, -467, -467, 2979 -467, -467, 0, 773, 0, 0, 0, 0, 65, 66, 2980 67, 68, 607, 70, 71, 72, -467, -467, -467, 608, 2981 609, 610, 0, 73, 611, 75, 0, 76, 77, 78, 2982 0, 0, 0, 82, 804, 84, 85, 86, 87, 88, 2983 89, 0, 381, 382, 383, 384, 385, 0, 0, 0, 2984 90, 0, -467, 0, 0, 91, -467, -467, 0, 386, 2985 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 2986 397, 0, 0, 8, 0, 612, 172, 0, 0, 0, 2987 223, 224, 225, 226, 227, 228, 229, 230, 837, 9, 2988 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2989 20, 21, 22, 23, 24, 25, 26, 231, 0, 0, 2990 0, 0, 0, 0, 0, 27, 28, 29, 30, 31, 2991 32, 0, 232, 381, 382, 383, 384, 385, 0, 0, 2992 0, 0, 0, 0, 0, 33, 34, 35, 0, 0, 2993 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 2994 396, 397, 9, 10, 11, 12, 13, 14, 15, 16, 2995 0, 18, 0, 20, 0, 0, 23, 24, 25, 26, 2996 0, 36, 0, 0, 37, 38, 0, 0, 0, 0, 2997 0, 0, 0, 0, 0, 233, 0, 0, 234, 235, 2998 0, 0, 236, 237, 238, 8, 0, 0, 172, 0, 2999 0, 0, 223, 224, 225, 226, 227, 228, 229, 230, 3000 413, 9, 10, 11, 12, 13, 14, 15, 16, 17, 3001 18, 19, 20, 21, 22, 23, 24, 25, 26, 231, 3002 0, 0, 0, 0, 0, 0, 0, 0, 28, 29, 3003 30, 31, 32, 0, 232, 0, 0, 265, 0, 381, 3004 382, 383, 384, 385, 0, 0, 0, 33, 34, 35, 3005 0, 381, 382, 383, 384, 0, 386, 387, 388, 389, 3006 390, 391, 392, 393, 394, 395, 396, 397, 386, 387, 3007 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 3008 0, 295, 0, 36, 172, 0, 0, 38, 0, 224, 3009 225, 226, 227, 228, 229, 230, 0, 233, 0, 0, 3010 234, 235, 0, 0, 236, 237, 238, 8, 0, 0, 3011 172, 0, 0, 0, 223, 224, 225, 226, 227, 228, 3012 229, 230, 530, 9, 10, 11, 12, 13, 14, 15, 3013 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3014 26, 231, 0, 0, 0, 0, 0, 0, 0, 0, 3015 28, 29, 30, 31, 32, 0, 232, 0, 0, 421, 3016 0, 381, 382, 383, 384, 385, 0, 0, 0, 33, 3017 34, 35, 0, 0, 0, 0, 0, 0, 386, 387, 3018 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 3019 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3020 0, 0, 0, 0, 0, 36, 0, 0, 0, 38, 3021 0, 0, 0, 0, 0, 0, 0, 0, 0, 233, 3022 0, 0, 234, 235, 0, 0, 236, 237, 238, 8, 3023 0, 0, 172, 0, 0, 0, 223, 224, 225, 226, 3024 227, 228, 229, 230, 532, 9, 10, 11, 12, 13, 3025 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 3026 24, 25, 26, 231, 0, 0, 0, 0, 0, 0, 3027 0, 0, 28, 29, 30, 31, 32, 0, 232, 0, 3028 0, 424, 0, 381, 382, 383, 384, 385, 0, 0, 3029 0, 33, 34, 35, 0, 0, 0, 0, 0, 0, 3030 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 3031 396, 397, 0, 0, 0, 0, 0, 0, 0, 0, 3032 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 3033 0, 38, 0, 0, 0, 0, 0, 0, 0, 0, 3034 0, 233, 0, 0, 234, 235, 0, 0, 236, 237, 3035 238, 8, 0, 0, 172, 0, 0, 0, 223, 224, 3036 225, 226, 227, 228, 229, 230, 658, 9, 10, 11, 3037 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 3038 22, 23, 24, 25, 26, 231, 0, 0, 0, 0, 3039 0, 0, 0, 0, 28, 29, 30, 31, 32, 0, 3040 232, 0, 0, 527, 0, 381, 382, 383, 384, 385, 3041 0, 0, 0, 33, 34, 35, 0, 0, 0, 0, 3042 0, 0, 386, 387, 388, 389, 390, 391, 392, 393, 3043 394, 395, 396, 397, 0, 0, 0, 0, 0, 0, 3044 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 3045 0, 0, 0, 38, 0, 0, 0, 0, 0, 0, 3046 0, 0, 0, 233, 0, 0, 234, 235, 0, 0, 3047 236, 237, 238, 8, 0, 0, 172, 0, 0, 0, 3048 223, 224, 225, 226, 227, 228, 229, 230, 662, 9, 3049 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 3050 20, 21, 22, 23, 24, 25, 26, 231, 0, 0, 3051 0, 0, 0, 0, 0, 0, 28, 29, 30, 31, 3052 32, 0, 232, 0, 0, 0, 0, 381, 382, 383, 3053 384, 385, 0, 0, 0, 33, 34, 35, 0, 0, 3054 0, 0, 0, 0, 386, 387, 388, 389, 390, 391, 3055 392, 393, 394, 395, 396, 397, 0, 0, 0, 0, 3056 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3057 0, 36, 0, 0, 0, 38, 0, 0, 0, 0, 3058 0, 0, 0, 0, 0, 233, 0, 0, 234, 235, 3059 0, 0, 236, 237, 238, 8, 0, 0, 172, 0, 3060 0, 0, 223, 224, 225, 226, 227, 228, 229, 230, 3061 0, 9, 10, 11, 12, 13, 14, 15, 16, 17, 3062 18, 19, 20, 21, 22, 23, 24, 25, 26, 231, 3063 0, 0, 0, 0, 0, 0, 0, 0, 28, 29, 3064 30, 31, 32, 0, 232, 8, 0, 0, 0, 0, 3065 0, 0, 0, 0, 0, 0, 0, 33, 34, 35, 3066 0, 9, 10, 11, 12, 13, 14, 15, 16, 17, 3067 18, 19, 20, 21, 22, 23, 24, 25, 26, 256, 3068 0, 0, 0, 0, 0, 0, 0, 27, 28, 29, 3069 30, 31, 32, 36, 0, 0, 144, 38, 0, 0, 3070 0, 0, 0, 0, 0, 0, 0, 33, 34, 35, 3071 234, 235, 0, 0, 649, 237, 238, 0, 0, 0, 3072 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3073 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3074 0, 0, 0, 36, 0, 0, 37, 38, 0, 8, 3075 0, 0, 0, 0, 0, 0, 0, 257, 0, 0, 3076 0, 0, 0, 0, 147, 9, 10, 11, 12, 13, 3077 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 3078 24, 25, 26, 256, 0, 0, 0, 0, 0, 0, 3079 0, 27, 28, 29, 30, 31, 32, 0, 0, 0, 3080 144, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3081 8, 33, 34, 35, 0, 0, 0, 0, 0, 0, 3082 0, 0, 0, 0, 0, 0, 9, 10, 11, 12, 3083 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 3084 23, 24, 25, 26, 0, 0, 0, 36, 0, 0, 3085 37, 38, 27, 28, 29, 30, 31, 32, 0, 0, 3086 0, 400, 0, 8, 0, 0, 0, 0, 147, 0, 3087 0, 0, 33, 34, 35, 0, 0, 0, 0, 9, 3088 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 3089 20, 21, 22, 23, 24, 25, 26, 0, 0, 0, 3090 0, 0, 0, 0, 0, 0, 0, 655, 36, 31, 3091 32, 37, 38, 0, 0, 0, 0, 0, 0, 0, 3092 0, 0, 352, 0, 0, 33, 34, 35, 0, 147, 3093 381, 382, 383, 384, 385, 0, 0, 0, 0, 0, 3094 0, 0, 0, 0, 0, 0, 0, 386, 387, 388, 3095 389, 390, 391, 392, 393, 394, 395, 396, 397, 0, 3096 0, 36, 0, 0, 0, 38, -2, 56, 0, -467, 3097 57, 0, 0, 58, 59, 60, 0, 0, 0, 0, 3098 0, 0, 147, 0, 61, -467, -467, -467, -467, -467, 3099 -467, -467, -467, -467, -467, -467, -467, -467, -467, -467, 3100 -467, -467, -467, 0, 0, 0, 62, 63, 0, 0, 3101 0, 0, -467, -467, -467, -467, -467, 0, 0, 64, 3102 0, 0, 0, 65, 66, 67, 68, 69, 70, 71, 3103 72, -467, -467, -467, 0, 0, 0, 0, 73, 74, 3104 75, 0, 76, 77, 78, 79, 80, 81, 82, 83, 3105 84, 85, 86, 87, 88, 89, 56, 0, -467, 57, 3106 0, 0, 58, 59, 60, 90, 0, -467, 0, 0, 3107 91, -467, 0, 61, -467, -467, -467, -467, -467, -467, 3108 -467, -467, -467, -467, -467, -467, -467, -467, -467, -467, 3109 -467, -467, 0, 0, 0, 62, 63, 0, 0, 569, 3110 0, -467, -467, -467, -467, -467, 0, 0, 64, 0, 3111 0, 0, 65, 66, 67, 68, 69, 70, 71, 72, 3112 -467, -467, -467, 0, 0, 0, 0, 73, 74, 75, 3113 0, 76, 77, 78, 79, 80, 81, 82, 83, 84, 3114 85, 86, 87, 88, 89, 56, 0, -467, 57, 0, 3115 0, 58, 59, 60, 90, 0, -467, 0, 0, 91, 3116 -467, 0, 61, -467, -467, -467, -467, -467, -467, -467, 3117 -467, -467, -467, -467, -467, -467, -467, -467, -467, -467, 3118 -467, 0, 0, 0, 62, 63, 0, 0, 664, 0, 3119 -467, -467, -467, -467, -467, 0, 0, 64, 0, 0, 3120 0, 65, 66, 67, 68, 69, 70, 71, 72, -467, 3121 -467, -467, 0, 0, 0, 0, 73, 74, 75, 0, 3122 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 3123 86, 87, 88, 89, 56, 0, -467, 57, 0, 0, 3124 58, 59, 60, 90, 0, -467, 0, 0, 91, -467, 3125 0, 61, -467, -467, -467, -467, -467, -467, -467, -467, 3126 -467, -467, -467, -467, -467, -467, -467, -467, -467, -467, 3127 0, 0, 0, 62, 63, 0, 0, 680, 0, -467, 3128 -467, -467, -467, -467, 0, 0, 64, 0, 0, 0, 3129 65, 66, 67, 68, 69, 70, 71, 72, -467, -467, 3130 -467, 0, 0, 0, 0, 73, 74, 75, 0, 76, 3131 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 3132 87, 88, 89, 56, 0, -467, 57, 0, 0, 58, 3133 59, 60, 90, 0, -467, 0, 0, 91, -467, 0, 3134 61, -467, -467, -467, -467, -467, -467, -467, -467, -467, 3135 -467, -467, -467, -467, -467, -467, -467, -467, -467, 0, 3136 0, 0, 62, 63, 0, 0, 0, 0, -467, -467, 3137 -467, -467, -467, 0, 0, 64, 0, 770, 0, 65, 3138 66, 67, 68, 69, 70, 71, 72, -467, -467, -467, 3139 0, 0, 0, 0, 73, 74, 75, 0, 76, 77, 3140 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 3141 88, 89, 7, 0, 8, 0, 0, 0, 0, 0, 3142 0, 90, 0, -467, 0, 0, 91, -467, 0, 0, 3143 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 3144 19, 20, 21, 22, 23, 24, 25, 26, 0, 0, 3145 0, 0, 0, 0, 0, 0, 27, 28, 29, 30, 3146 31, 32, 51, 0, 8, 0, 0, 0, 0, 0, 3147 0, 0, 0, 0, 0, 0, 33, 34, 35, 0, 3148 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 3149 19, 20, 21, 22, 23, 24, 25, 26, 0, 0, 3150 0, 0, 0, 0, 0, 0, 27, 28, 29, 30, 3151 31, 32, 36, 0, 0, 37, 38, 0, 0, 0, 3152 0, 0, 177, 0, 178, 0, 33, 34, 35, 0, 3153 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3154 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 3155 19, 20, 21, 22, 23, 24, 25, 26, 0, 0, 3156 0, 0, 36, 0, 0, 37, 38, 28, 29, 30, 3157 31, 32, 0, 8, 0, 0, 0, 0, 0, 0, 3158 0, 0, 0, 0, 0, 0, 33, 34, 35, 9, 3159 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 3160 20, 21, 22, 23, 24, 25, 26, 0, 0, 0, 3161 0, 0, 0, 0, 0, 0, 28, 29, 30, 31, 3162 32, 0, 36, 8, 0, 0, 38, 0, 0, 0, 3163 0, 0, 0, 0, 0, 220, 34, 35, 0, 9, 3164 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 3165 20, 21, 22, 23, 24, 25, 26, 0, 0, 0, 3166 0, 0, 0, 0, 0, 0, 28, 29, 30, 31, 3167 32, 36, 8, 0, 0, 38, 726, 0, 0, 0, 3168 0, 0, 0, 0, 0, 33, 34, 35, 9, 10, 3169 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 3170 21, 22, 23, 24, 25, 26, 0, 0, 0, 0, 3171 0, 0, 0, 0, 27, 28, 29, 30, 31, 32, 3172 0, 36, 8, 0, 0, 38, 726, 0, 0, 0, 3173 0, 0, 0, 0, 33, 34, 35, 0, 9, 10, 3174 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 3175 21, 22, 23, 24, 25, 26, 203, 0, 0, 0, 3176 0, 0, 0, 0, 0, 28, 29, 30, 31, 32, 3177 36, 8, 0, 37, 38, 0, 0, 0, 0, 0, 3178 0, 0, 0, 0, 33, 34, 35, 9, 10, 11, 3179 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 3180 22, 23, 24, 25, 26, 0, 0, 0, 0, 0, 3181 0, 0, 0, 0, 28, 29, 30, 31, 32, 0, 3182 36, 8, 0, 0, 38, 0, 0, 0, 0, 0, 3183 0, 0, 0, 220, 34, 35, 0, 9, 10, 11, 3184 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 3185 22, 23, 24, 25, 26, 0, 0, 0, 0, 0, 3186 0, 0, 0, 0, 28, 29, 30, 31, 32, 36, 3187 682, 0, 0, 38, 0, 0, 0, 0, 0, 0, 3188 0, 0, 0, 33, 34, 35, 9, 10, 11, 12, 3189 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 3190 23, 24, 25, 26, 0, 0, 0, 0, 0, 0, 3191 0, 0, 0, 28, 29, 30, 31, 32, 0, 36, 3192 8, 0, 0, 38, 0, 0, 0, 0, 0, 0, 3193 0, 0, 33, 34, 35, 0, 9, 10, 11, 12, 3194 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 3195 23, 24, 25, 26, 0, 0, 0, 0, 0, 0, 3196 0, 0, 0, 0, 0, 0, 31, 32, 36, 0, 3197 0, 0, 38, 0, 0, 0, 0, 0, 0, 0, 3198 0, 0, 33, 34, 35, 0, 0, 0, 0, 0, 3199 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3200 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3201 0, 0, 0, 0, 0, 0, 0, 0, 36, 0, 3202 0, 0, 38 3203}; 3204 3205static const yytype_int16 yycheck[] = 3206{ 3207 0, 85, 5, 5, 40, 5, 320, 41, 8, 43, 3208 5, 212, 131, 549, 563, 5, 327, 5, 304, 465, 3209 42, 21, 37, 90, 137, 146, 6, 437, 5, 5, 3210 142, 39, 197, 5, 155, 5, 446, 446, 155, 40, 3211 5, 5, 42, 5, 3, 3, 1, 2, 161, 162, 3212 215, 38, 3, 38, 151, 5, 153, 171, 91, 5, 3213 5, 175, 43, 38, 64, 558, 110, 181, 5, 69, 3214 70, 5, 186, 566, 54, 5, 257, 5, 37, 260, 3215 3, 5, 39, 91, 6, 43, 5, 3, 3, 90, 3216 3, 38, 39, 205, 208, 5, 129, 590, 634, 54, 3217 115, 218, 102, 217, 597, 138, 140, 122, 3, 90, 3218 4, 253, 71, 147, 3, 102, 3, 0, 564, 3, 3219 142, 435, 1, 40, 37, 147, 43, 102, 43, 51, 3220 115, 131, 6, 39, 91, 179, 257, 6, 44, 260, 3221 454, 54, 101, 101, 256, 456, 105, 105, 290, 43, 3222 37, 151, 39, 153, 105, 51, 115, 269, 37, 51, 3223 45, 205, 283, 122, 51, 124, 283, 54, 168, 43, 3224 287, 352, 353, 90, 43, 71, 131, 221, 178, 3, 3225 51, 717, 105, 205, 71, 678, 101, 142, 101, 105, 3226 105, 191, 105, 215, 3, 79, 40, 3, 90, 735, 3227 4, 126, 751, 103, 91, 205, 101, 207, 208, 306, 3228 105, 124, 212, 37, 101, 3, 105, 101, 105, 90, 3229 220, 105, 244, 1, 2, 671, 126, 122, 115, 410, 3230 54, 3, 187, 188, 256, 122, 6, 124, 40, 43, 3231 54, 358, 242, 360, 244, 38, 39, 269, 203, 333, 3232 786, 90, 69, 275, 51, 43, 211, 212, 377, 3, 3233 753, 40, 6, 673, 673, 37, 467, 40, 365, 71, 3234 40, 436, 106, 3, 71, 589, 6, 101, 75, 400, 3235 401, 105, 54, 305, 3, 102, 407, 46, 47, 48, 3236 471, 115, 101, 414, 38, 101, 105, 414, 463, 105, 3237 124, 256, 3, 38, 39, 6, 306, 428, 4, 755, 3238 6, 428, 429, 101, 269, 3, 103, 105, 811, 855, 3239 320, 37, 38, 278, 6, 37, 281, 40, 3, 101, 3240 43, 365, 446, 105, 356, 37, 37, 292, 54, 126, 3241 37, 45, 364, 115, 3, 345, 368, 43, 37, 37, 3242 122, 351, 124, 131, 102, 4, 473, 6, 71, 476, 3243 37, 361, 37, 122, 857, 365, 399, 367, 861, 39, 3244 37, 101, 3, 187, 188, 105, 51, 54, 37, 54, 3245 3, 51, 101, 6, 3, 115, 105, 484, 4, 203, 3246 6, 40, 122, 37, 43, 54, 71, 211, 519, 776, 3247 101, 445, 51, 37, 105, 449, 783, 90, 525, 364, 3248 54, 39, 789, 101, 115, 43, 533, 105, 37, 102, 3249 103, 122, 377, 124, 37, 711, 101, 115, 472, 37, 3250 105, 37, 38, 433, 212, 435, 124, 68, 69, 70, 3251 115, 54, 101, 126, 37, 38, 105, 122, 54, 124, 3252 453, 453, 455, 453, 454, 455, 115, 37, 453, 493, 3253 460, 54, 417, 453, 278, 453, 37, 281, 37, 40, 3254 101, 493, 43, 495, 105, 592, 453, 453, 478, 37, 3255 37, 453, 101, 453, 484, 485, 105, 40, 453, 453, 3256 43, 453, 37, 448, 871, 495, 496, 54, 51, 612, 3257 665, 666, 37, 453, 879, 124, 43, 453, 453, 464, 3258 49, 50, 467, 4, 292, 6, 453, 892, 893, 453, 3259 564, 3, 38, 453, 558, 453, 39, 66, 67, 453, 3260 37, 38, 566, 3, 453, 37, 38, 40, 541, 541, 3261 43, 541, 4, 453, 6, 40, 541, 54, 43, 549, 3262 364, 541, 54, 541, 40, 599, 590, 43, 558, 656, 3263 762, 675, 764, 597, 541, 541, 566, 570, 570, 541, 3264 570, 541, 40, 692, 3, 570, 541, 541, 40, 541, 3265 570, 43, 570, 40, 587, 587, 43, 587, 588, 589, 3266 590, 541, 587, 570, 570, 541, 541, 597, 570, 377, 3267 570, 685, 40, 417, 541, 570, 570, 541, 570, 722, 3268 643, 541, 898, 541, 650, 649, 43, 541, 715, 3, 3269 570, 576, 541, 3, 570, 570, 43, 649, 650, 6, 3270 674, 541, 40, 570, 634, 39, 570, 102, 100, 683, 3271 570, 65, 570, 598, 678, 645, 570, 37, 91, 49, 3272 50, 570, 39, 38, 3, 4, 656, 6, 37, 91, 3273 570, 85, 86, 102, 38, 709, 66, 67, 54, 702, 3274 448, 46, 47, 48, 122, 40, 51, 102, 678, 38, 3275 724, 715, 682, 727, 38, 782, 464, 38, 37, 467, 3276 90, 40, 692, 43, 43, 38, 71, 107, 108, 109, 3277 75, 704, 704, 51, 704, 129, 39, 38, 708, 704, 3278 754, 38, 712, 668, 704, 715, 704, 717, 3, 753, 3279 46, 47, 48, 3, 40, 769, 38, 704, 704, 39, 3280 40, 828, 704, 43, 704, 735, 38, 692, 38, 704, 3281 704, 38, 704, 38, 38, 3, 91, 39, 18, 75, 3282 102, 100, 101, 753, 704, 710, 105, 37, 704, 704, 3283 38, 716, 576, 46, 47, 48, 115, 704, 790, 791, 3284 704, 41, 33, 122, 704, 124, 704, 811, 40, 37, 3285 704, 42, 782, 102, 598, 704, 786, 48, 43, 63, 3286 38, 102, 747, 793, 704, 839, 54, 797, 102, 843, 3287 38, 801, 72, 73, 74, 40, 40, 77, 38, 40, 3288 84, 811, 120, 121, 122, 89, 101, 78, 79, 863, 3289 105, 101, 43, 857, 37, 105, 44, 861, 828, 40, 3290 115, 38, 3, 788, 104, 115, 791, 122, 37, 839, 3291 840, 43, 876, 101, 124, 879, 38, 105, 39, 110, 3292 39, 37, 807, 51, 668, 855, 38, 857, 892, 893, 3293 37, 861, 126, 863, 90, 44, 124, 51, 37, 46, 3294 47, 48, 124, 43, 51, 830, 876, 3, 833, 879, 3295 44, 142, 3, 18, 71, 146, 71, 148, 71, 44, 3296 38, 38, 892, 893, 155, 73, 710, 171, 75, 44, 3297 174, 175, 716, 327, 859, 860, 41, 181, 37, 333, 3298 75, 37, 186, 38, 692, 3, 37, 40, 179, 40, 3299 38, 182, 71, 197, 40, 38, 37, 39, 189, 3, 3300 40, 3, 38, 747, 208, 209, 3, 72, 73, 74, 3301 214, 215, 77, 217, 205, 369, 118, 119, 120, 121, 3302 122, 3, 213, 37, 215, 216, 39, 218, 40, 220, 3303 221, 222, 40, 37, 91, 37, 40, 38, 38, 37, 3304 37, 40, 37, 3, 788, 101, 40, 791, 44, 105, 3305 101, 3, 54, 244, 105, 37, 3, 38, 40, 115, 3306 40, 40, 39, 807, 115, 256, 257, 38, 124, 260, 3307 44, 122, 37, 124, 37, 460, 3, 37, 269, 270, 3308 38, 38, 587, 38, 40, 37, 830, 3, 40, 833, 3309 37, 40, 283, 38, 54, 38, 287, 101, 38, 101, 3310 3, 105, 456, 105, 101, 3, 40, 40, 105, 40, 3311 37, 115, 437, 115, 305, 859, 860, 715, 122, 101, 3312 124, 37, 124, 105, 587, 467, 588, 124, 319, 587, 3313 587, 433, 863, 115, 37, 692, 496, 495, 377, 37, 3314 122, 101, 124, 708, 46, 105, 840, 797, 801, 101, 3315 861, 54, 21, 105, 101, 115, 852, -1, 105, 573, 3316 -1, 352, 353, 115, 124, 356, -1, 358, 115, 360, 3317 122, -1, 124, 364, 101, 122, -1, 124, 105, -1, 3318 144, 145, -1, -1, -1, 101, -1, -1, 115, 105, 3319 -1, -1, -1, -1, -1, 122, -1, 124, 101, 115, 3320 -1, -1, 105, 101, -1, -1, 122, 105, 124, -1, 3321 401, -1, 115, -1, -1, -1, -1, 115, 572, 410, 3322 -1, 124, -1, 414, 122, -1, 124, -1, -1, -1, 3323 434, -1, 436, 437, -1, -1, -1, 428, 429, -1, 3324 444, 445, 446, 116, 117, 118, 119, 120, 121, 122, 3325 -1, -1, -1, -1, 445, -1, -1, -1, 449, 463, 3326 -1, 465, -1, -1, -1, -1, -1, 231, 472, 233, 3327 234, 235, 236, 237, 238, -1, -1, -1, -1, -1, 3328 471, 472, 473, -1, -1, 476, 94, 95, 6, 643, 3329 -1, -1, -1, 11, 12, 13, 14, 15, 16, 17, 3330 264, -1, -1, -1, 495, 38, -1, -1, 116, 117, 3331 118, 119, 120, 121, 122, 279, -1, -1, 282, -1, 3332 -1, -1, -1, 514, -1, -1, -1, 94, 95, 96, 3333 97, 685, -1, -1, 525, -1, -1, -1, -1, -1, 3334 -1, -1, 533, -1, -1, -1, -1, -1, 702, 116, 3335 117, 118, 119, 120, 121, 122, -1, -1, -1, -1, 3336 564, 94, 95, 96, 97, 98, -1, 571, -1, 573, 3337 -1, -1, 726, 564, -1, -1, -1, -1, 111, 112, 3338 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 3339 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3340 -1, 592, -1, -1, -1, -1, -1, -1, 599, -1, 3341 -1, -1, -1, 94, 95, 96, 97, 381, 382, 383, 3342 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 3343 394, 395, 396, 397, 115, 116, 117, 118, 119, 120, 3344 121, 122, -1, -1, -1, -1, -1, 411, -1, -1, 3345 -1, -1, 643, -1, 418, -1, -1, -1, -1, -1, 3346 -1, 665, 666, -1, -1, -1, -1, 671, -1, 673, 3347 -1, 675, -1, -1, -1, -1, -1, 3, -1, -1, 3348 6, -1, -1, 674, 10, 11, 12, 13, 14, 15, 3349 16, 17, 683, 19, 20, 21, 22, 23, 24, 25, 3350 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 3351 36, 37, 38, -1, -1, -1, -1, -1, 709, -1, 3352 46, 47, 48, 49, 50, -1, 52, 491, 492, 493, 3353 -1, -1, -1, 724, -1, -1, 727, 728, -1, 65, 3354 66, 67, 733, -1, -1, -1, 94, 95, 96, 97, 3355 -1, 755, -1, -1, -1, -1, -1, -1, -1, -1, 3356 -1, -1, -1, 754, 112, 113, 114, 115, 116, 117, 3357 118, 119, 120, 121, 122, 101, -1, -1, 769, 105, 3358 -1, -1, -1, -1, -1, -1, -1, -1, 779, 115, 3359 -1, -1, 118, 119, -1, 3, 122, 123, 124, -1, 3360 791, -1, -1, 11, -1, -1, -1, -1, -1, -1, 3361 -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, 3362 28, 29, 30, 31, 32, 33, 34, 35, 36, -1, 3363 -1, -1, -1, -1, -1, -1, -1, 45, 46, 47, 3364 48, 49, 50, 94, 95, 96, 97, -1, 839, -1, 3365 -1, 842, 843, 94, 95, 96, 97, 65, 66, 67, 3366 -1, 852, 113, 114, 115, 116, 117, 118, 119, 120, 3367 121, 122, 863, 114, 115, 116, 117, 118, 119, 120, 3368 121, 122, -1, -1, 648, 649, -1, 651, -1, -1, 3369 -1, 655, 1, 101, 3, 4, 104, 105, 7, 8, 3370 9, -1, -1, -1, -1, -1, -1, -1, -1, 18, 3371 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 3372 29, 30, 31, 32, 33, 34, 35, 36, 40, -1, 3373 -1, 40, 41, -1, -1, 44, -1, 46, 47, 48, 3374 49, 50, -1, 707, -1, -1, -1, -1, 57, 58, 3375 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 3376 69, 70, -1, 72, 73, 74, -1, 76, 77, 78, 3377 -1, -1, -1, 82, 738, 84, 85, 86, 87, 88, 3378 89, -1, 94, 95, 96, 97, 98, -1, -1, -1, 3379 99, -1, 101, -1, -1, 104, 105, 106, -1, 111, 3380 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 3381 122, -1, -1, 3, -1, 124, 6, -1, -1, -1, 3382 10, 11, 12, 13, 14, 15, 16, 17, 792, 19, 3383 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 3384 30, 31, 32, 33, 34, 35, 36, 37, -1, -1, 3385 -1, -1, -1, -1, -1, 45, 46, 47, 48, 49, 3386 50, -1, 52, 94, 95, 96, 97, 98, -1, -1, 3387 -1, -1, -1, -1, -1, 65, 66, 67, -1, -1, 3388 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 3389 121, 122, 19, 20, 21, 22, 23, 24, 25, 26, 3390 -1, 28, -1, 30, -1, -1, 33, 34, 35, 36, 3391 -1, 101, -1, -1, 104, 105, -1, -1, -1, -1, 3392 -1, -1, -1, -1, -1, 115, -1, -1, 118, 119, 3393 -1, -1, 122, 123, 124, 3, -1, -1, 6, -1, 3394 -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, 3395 55, 19, 20, 21, 22, 23, 24, 25, 26, 27, 3396 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 3397 -1, -1, -1, -1, -1, -1, -1, -1, 46, 47, 3398 48, 49, 50, -1, 52, -1, -1, 55, -1, 94, 3399 95, 96, 97, 98, -1, -1, -1, 65, 66, 67, 3400 -1, 94, 95, 96, 97, -1, 111, 112, 113, 114, 3401 115, 116, 117, 118, 119, 120, 121, 122, 111, 112, 3402 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 3403 -1, 3, -1, 101, 6, -1, -1, 105, -1, 11, 3404 12, 13, 14, 15, 16, 17, -1, 115, -1, -1, 3405 118, 119, -1, -1, 122, 123, 124, 3, -1, -1, 3406 6, -1, -1, -1, 10, 11, 12, 13, 14, 15, 3407 16, 17, 55, 19, 20, 21, 22, 23, 24, 25, 3408 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 3409 36, 37, -1, -1, -1, -1, -1, -1, -1, -1, 3410 46, 47, 48, 49, 50, -1, 52, -1, -1, 55, 3411 -1, 94, 95, 96, 97, 98, -1, -1, -1, 65, 3412 66, 67, -1, -1, -1, -1, -1, -1, 111, 112, 3413 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 3414 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3415 -1, -1, -1, -1, -1, 101, -1, -1, -1, 105, 3416 -1, -1, -1, -1, -1, -1, -1, -1, -1, 115, 3417 -1, -1, 118, 119, -1, -1, 122, 123, 124, 3, 3418 -1, -1, 6, -1, -1, -1, 10, 11, 12, 13, 3419 14, 15, 16, 17, 55, 19, 20, 21, 22, 23, 3420 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 3421 34, 35, 36, 37, -1, -1, -1, -1, -1, -1, 3422 -1, -1, 46, 47, 48, 49, 50, -1, 52, -1, 3423 -1, 55, -1, 94, 95, 96, 97, 98, -1, -1, 3424 -1, 65, 66, 67, -1, -1, -1, -1, -1, -1, 3425 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 3426 121, 122, -1, -1, -1, -1, -1, -1, -1, -1, 3427 -1, -1, -1, -1, -1, -1, -1, 101, -1, -1, 3428 -1, 105, -1, -1, -1, -1, -1, -1, -1, -1, 3429 -1, 115, -1, -1, 118, 119, -1, -1, 122, 123, 3430 124, 3, -1, -1, 6, -1, -1, -1, 10, 11, 3431 12, 13, 14, 15, 16, 17, 55, 19, 20, 21, 3432 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3433 32, 33, 34, 35, 36, 37, -1, -1, -1, -1, 3434 -1, -1, -1, -1, 46, 47, 48, 49, 50, -1, 3435 52, -1, -1, 55, -1, 94, 95, 96, 97, 98, 3436 -1, -1, -1, 65, 66, 67, -1, -1, -1, -1, 3437 -1, -1, 111, 112, 113, 114, 115, 116, 117, 118, 3438 119, 120, 121, 122, -1, -1, -1, -1, -1, -1, 3439 -1, -1, -1, -1, -1, -1, -1, -1, -1, 101, 3440 -1, -1, -1, 105, -1, -1, -1, -1, -1, -1, 3441 -1, -1, -1, 115, -1, -1, 118, 119, -1, -1, 3442 122, 123, 124, 3, -1, -1, 6, -1, -1, -1, 3443 10, 11, 12, 13, 14, 15, 16, 17, 55, 19, 3444 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 3445 30, 31, 32, 33, 34, 35, 36, 37, -1, -1, 3446 -1, -1, -1, -1, -1, -1, 46, 47, 48, 49, 3447 50, -1, 52, -1, -1, -1, -1, 94, 95, 96, 3448 97, 98, -1, -1, -1, 65, 66, 67, -1, -1, 3449 -1, -1, -1, -1, 111, 112, 113, 114, 115, 116, 3450 117, 118, 119, 120, 121, 122, -1, -1, -1, -1, 3451 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3452 -1, 101, -1, -1, -1, 105, -1, -1, -1, -1, 3453 -1, -1, -1, -1, -1, 115, -1, -1, 118, 119, 3454 -1, -1, 122, 123, 124, 3, -1, -1, 6, -1, 3455 -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, 3456 -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, 3457 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 3458 -1, -1, -1, -1, -1, -1, -1, -1, 46, 47, 3459 48, 49, 50, -1, 52, 3, -1, -1, -1, -1, 3460 -1, -1, -1, -1, -1, -1, -1, 65, 66, 67, 3461 -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, 3462 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 3463 -1, -1, -1, -1, -1, -1, -1, 45, 46, 47, 3464 48, 49, 50, 101, -1, -1, 54, 105, -1, -1, 3465 -1, -1, -1, -1, -1, -1, -1, 65, 66, 67, 3466 118, 119, -1, -1, 122, 123, 124, -1, -1, -1, 3467 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3468 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3469 -1, -1, -1, 101, -1, -1, 104, 105, -1, 3, 3470 -1, -1, -1, -1, -1, -1, -1, 115, -1, -1, 3471 -1, -1, -1, -1, 122, 19, 20, 21, 22, 23, 3472 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 3473 34, 35, 36, 37, -1, -1, -1, -1, -1, -1, 3474 -1, 45, 46, 47, 48, 49, 50, -1, -1, -1, 3475 54, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3476 3, 65, 66, 67, -1, -1, -1, -1, -1, -1, 3477 -1, -1, -1, -1, -1, -1, 19, 20, 21, 22, 3478 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 3479 33, 34, 35, 36, -1, -1, -1, 101, -1, -1, 3480 104, 105, 45, 46, 47, 48, 49, 50, -1, -1, 3481 -1, 115, -1, 3, -1, -1, -1, -1, 122, -1, 3482 -1, -1, 65, 66, 67, -1, -1, -1, -1, 19, 3483 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 3484 30, 31, 32, 33, 34, 35, 36, -1, -1, -1, 3485 -1, -1, -1, -1, -1, -1, -1, 71, 101, 49, 3486 50, 104, 105, -1, -1, -1, -1, -1, -1, -1, 3487 -1, -1, 115, -1, -1, 65, 66, 67, -1, 122, 3488 94, 95, 96, 97, 98, -1, -1, -1, -1, -1, 3489 -1, -1, -1, -1, -1, -1, -1, 111, 112, 113, 3490 114, 115, 116, 117, 118, 119, 120, 121, 122, -1, 3491 -1, 101, -1, -1, -1, 105, 0, 1, -1, 3, 3492 4, -1, -1, 7, 8, 9, -1, -1, -1, -1, 3493 -1, -1, 122, -1, 18, 19, 20, 21, 22, 23, 3494 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 3495 34, 35, 36, -1, -1, -1, 40, 41, -1, -1, 3496 -1, -1, 46, 47, 48, 49, 50, -1, -1, 53, 3497 -1, -1, -1, 57, 58, 59, 60, 61, 62, 63, 3498 64, 65, 66, 67, -1, -1, -1, -1, 72, 73, 3499 74, -1, 76, 77, 78, 79, 80, 81, 82, 83, 3500 84, 85, 86, 87, 88, 89, 1, -1, 3, 4, 3501 -1, -1, 7, 8, 9, 99, -1, 101, -1, -1, 3502 104, 105, -1, 18, 19, 20, 21, 22, 23, 24, 3503 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 3504 35, 36, -1, -1, -1, 40, 41, -1, -1, 44, 3505 -1, 46, 47, 48, 49, 50, -1, -1, 53, -1, 3506 -1, -1, 57, 58, 59, 60, 61, 62, 63, 64, 3507 65, 66, 67, -1, -1, -1, -1, 72, 73, 74, 3508 -1, 76, 77, 78, 79, 80, 81, 82, 83, 84, 3509 85, 86, 87, 88, 89, 1, -1, 3, 4, -1, 3510 -1, 7, 8, 9, 99, -1, 101, -1, -1, 104, 3511 105, -1, 18, 19, 20, 21, 22, 23, 24, 25, 3512 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 3513 36, -1, -1, -1, 40, 41, -1, -1, 44, -1, 3514 46, 47, 48, 49, 50, -1, -1, 53, -1, -1, 3515 -1, 57, 58, 59, 60, 61, 62, 63, 64, 65, 3516 66, 67, -1, -1, -1, -1, 72, 73, 74, -1, 3517 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 3518 86, 87, 88, 89, 1, -1, 3, 4, -1, -1, 3519 7, 8, 9, 99, -1, 101, -1, -1, 104, 105, 3520 -1, 18, 19, 20, 21, 22, 23, 24, 25, 26, 3521 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 3522 -1, -1, -1, 40, 41, -1, -1, 44, -1, 46, 3523 47, 48, 49, 50, -1, -1, 53, -1, -1, -1, 3524 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 3525 67, -1, -1, -1, -1, 72, 73, 74, -1, 76, 3526 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 3527 87, 88, 89, 1, -1, 3, 4, -1, -1, 7, 3528 8, 9, 99, -1, 101, -1, -1, 104, 105, -1, 3529 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 3530 28, 29, 30, 31, 32, 33, 34, 35, 36, -1, 3531 -1, -1, 40, 41, -1, -1, -1, -1, 46, 47, 3532 48, 49, 50, -1, -1, 53, -1, 55, -1, 57, 3533 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 3534 -1, -1, -1, -1, 72, 73, 74, -1, 76, 77, 3535 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 3536 88, 89, 1, -1, 3, -1, -1, -1, -1, -1, 3537 -1, 99, -1, 101, -1, -1, 104, 105, -1, -1, 3538 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 3539 29, 30, 31, 32, 33, 34, 35, 36, -1, -1, 3540 -1, -1, -1, -1, -1, -1, 45, 46, 47, 48, 3541 49, 50, 1, -1, 3, -1, -1, -1, -1, -1, 3542 -1, -1, -1, -1, -1, -1, 65, 66, 67, -1, 3543 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 3544 29, 30, 31, 32, 33, 34, 35, 36, -1, -1, 3545 -1, -1, -1, -1, -1, -1, 45, 46, 47, 48, 3546 49, 50, 101, -1, -1, 104, 105, -1, -1, -1, 3547 -1, -1, 1, -1, 3, -1, 65, 66, 67, -1, 3548 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3549 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 3550 29, 30, 31, 32, 33, 34, 35, 36, -1, -1, 3551 -1, -1, 101, -1, -1, 104, 105, 46, 47, 48, 3552 49, 50, -1, 3, -1, -1, -1, -1, -1, -1, 3553 -1, -1, -1, -1, -1, -1, 65, 66, 67, 19, 3554 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 3555 30, 31, 32, 33, 34, 35, 36, -1, -1, -1, 3556 -1, -1, -1, -1, -1, -1, 46, 47, 48, 49, 3557 50, -1, 101, 3, -1, -1, 105, -1, -1, -1, 3558 -1, -1, -1, -1, -1, 65, 66, 67, -1, 19, 3559 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 3560 30, 31, 32, 33, 34, 35, 36, -1, -1, -1, 3561 -1, -1, -1, -1, -1, -1, 46, 47, 48, 49, 3562 50, 101, 3, -1, -1, 105, 106, -1, -1, -1, 3563 -1, -1, -1, -1, -1, 65, 66, 67, 19, 20, 3564 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 3565 31, 32, 33, 34, 35, 36, -1, -1, -1, -1, 3566 -1, -1, -1, -1, 45, 46, 47, 48, 49, 50, 3567 -1, 101, 3, -1, -1, 105, 106, -1, -1, -1, 3568 -1, -1, -1, -1, 65, 66, 67, -1, 19, 20, 3569 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 3570 31, 32, 33, 34, 35, 36, 37, -1, -1, -1, 3571 -1, -1, -1, -1, -1, 46, 47, 48, 49, 50, 3572 101, 3, -1, 104, 105, -1, -1, -1, -1, -1, 3573 -1, -1, -1, -1, 65, 66, 67, 19, 20, 21, 3574 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3575 32, 33, 34, 35, 36, -1, -1, -1, -1, -1, 3576 -1, -1, -1, -1, 46, 47, 48, 49, 50, -1, 3577 101, 3, -1, -1, 105, -1, -1, -1, -1, -1, 3578 -1, -1, -1, 65, 66, 67, -1, 19, 20, 21, 3579 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 3580 32, 33, 34, 35, 36, -1, -1, -1, -1, -1, 3581 -1, -1, -1, -1, 46, 47, 48, 49, 50, 101, 3582 3, -1, -1, 105, -1, -1, -1, -1, -1, -1, 3583 -1, -1, -1, 65, 66, 67, 19, 20, 21, 22, 3584 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 3585 33, 34, 35, 36, -1, -1, -1, -1, -1, -1, 3586 -1, -1, -1, 46, 47, 48, 49, 50, -1, 101, 3587 3, -1, -1, 105, -1, -1, -1, -1, -1, -1, 3588 -1, -1, 65, 66, 67, -1, 19, 20, 21, 22, 3589 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 3590 33, 34, 35, 36, -1, -1, -1, -1, -1, -1, 3591 -1, -1, -1, -1, -1, -1, 49, 50, 101, -1, 3592 -1, -1, 105, -1, -1, -1, -1, -1, -1, -1, 3593 -1, -1, 65, 66, 67, -1, -1, -1, -1, -1, 3594 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3595 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3596 -1, -1, -1, -1, -1, -1, -1, -1, 101, -1, 3597 -1, -1, 105 3598}; 3599 3600/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 3601 symbol of state STATE-NUM. */ 3602static const yytype_uint16 yystos[] = 3603{ 3604 0, 107, 108, 109, 128, 129, 274, 1, 3, 19, 3605 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 3606 30, 31, 32, 33, 34, 35, 36, 45, 46, 47, 3607 48, 49, 50, 65, 66, 67, 101, 104, 105, 215, 3608 229, 230, 232, 233, 234, 235, 236, 253, 254, 264, 3609 266, 1, 215, 1, 37, 0, 1, 4, 7, 8, 3610 9, 18, 40, 41, 53, 57, 58, 59, 60, 61, 3611 62, 63, 64, 72, 73, 74, 76, 77, 78, 79, 3612 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 3613 99, 104, 130, 131, 132, 134, 135, 136, 137, 138, 3614 141, 142, 144, 145, 146, 147, 148, 149, 150, 153, 3615 154, 155, 158, 160, 165, 166, 167, 168, 170, 173, 3616 174, 175, 176, 177, 181, 182, 189, 190, 200, 211, 3617 274, 90, 261, 274, 261, 45, 264, 126, 90, 40, 3618 233, 229, 37, 51, 54, 71, 115, 122, 124, 220, 3619 221, 223, 225, 226, 227, 228, 264, 274, 229, 235, 3620 264, 103, 126, 265, 40, 40, 212, 213, 215, 274, 3621 106, 37, 6, 269, 37, 271, 274, 1, 3, 231, 3622 232, 37, 271, 37, 152, 274, 37, 37, 37, 79, 3623 264, 3, 43, 264, 37, 4, 43, 37, 37, 40, 3624 43, 4, 269, 37, 164, 231, 162, 164, 37, 37, 3625 269, 37, 90, 254, 271, 37, 115, 223, 228, 264, 3626 65, 231, 254, 10, 11, 12, 13, 14, 15, 16, 3627 17, 37, 52, 115, 118, 119, 122, 123, 124, 215, 3628 216, 217, 219, 231, 232, 243, 244, 245, 246, 269, 3629 274, 45, 105, 266, 254, 229, 37, 115, 212, 226, 3630 228, 264, 43, 237, 238, 55, 243, 244, 243, 37, 3631 124, 224, 227, 264, 228, 229, 264, 220, 37, 54, 3632 220, 37, 54, 115, 224, 227, 264, 102, 266, 105, 3633 266, 38, 39, 214, 274, 3, 262, 269, 6, 43, 3634 262, 272, 262, 40, 51, 37, 223, 38, 262, 264, 3635 3, 3, 262, 11, 159, 212, 212, 264, 40, 51, 3636 192, 43, 3, 161, 272, 3, 212, 43, 222, 223, 3637 226, 274, 40, 39, 163, 274, 262, 263, 274, 139, 3638 140, 269, 212, 185, 186, 187, 215, 253, 274, 264, 3639 269, 3, 115, 228, 264, 272, 37, 262, 115, 264, 3640 102, 3, 239, 274, 37, 223, 43, 264, 243, 37, 3641 243, 243, 243, 243, 243, 243, 91, 39, 218, 274, 3642 37, 94, 95, 96, 97, 98, 111, 112, 113, 114, 3643 115, 116, 117, 118, 119, 120, 121, 122, 265, 91, 3644 115, 228, 264, 225, 264, 38, 38, 115, 225, 264, 3645 102, 54, 243, 55, 228, 264, 264, 37, 54, 228, 3646 212, 55, 243, 212, 55, 243, 224, 227, 102, 115, 3647 224, 265, 40, 215, 38, 169, 39, 51, 38, 237, 3648 220, 38, 43, 38, 51, 38, 39, 157, 39, 38, 3649 38, 40, 264, 129, 191, 38, 38, 38, 38, 162, 3650 164, 38, 38, 39, 43, 38, 91, 39, 188, 274, 3651 54, 102, 38, 228, 264, 40, 102, 40, 43, 212, 3652 264, 75, 172, 220, 229, 179, 40, 71, 247, 248, 3653 274, 38, 115, 122, 228, 231, 219, 243, 243, 243, 3654 243, 243, 243, 243, 243, 243, 243, 243, 243, 243, 3655 243, 243, 243, 243, 254, 264, 102, 38, 38, 102, 3656 225, 243, 224, 264, 38, 102, 212, 55, 243, 38, 3657 55, 38, 55, 115, 224, 227, 224, 214, 4, 43, 3658 269, 129, 272, 139, 245, 269, 273, 40, 40, 133, 3659 4, 151, 269, 4, 40, 43, 100, 156, 223, 269, 3660 270, 262, 269, 273, 38, 215, 223, 43, 40, 44, 3661 129, 41, 211, 162, 40, 43, 37, 44, 163, 3, 3662 101, 105, 267, 40, 272, 215, 156, 183, 187, 143, 3663 223, 269, 102, 3, 240, 241, 274, 38, 37, 39, 3664 40, 43, 171, 75, 220, 1, 40, 61, 68, 69, 3665 70, 73, 124, 134, 135, 136, 137, 141, 142, 146, 3666 148, 150, 153, 155, 158, 160, 165, 166, 167, 168, 3667 181, 182, 189, 193, 196, 197, 198, 199, 200, 201, 3668 202, 207, 210, 211, 274, 249, 43, 243, 38, 122, 3669 229, 38, 115, 221, 218, 71, 264, 38, 55, 38, 3670 224, 38, 55, 224, 44, 39, 39, 193, 37, 75, 3671 229, 256, 274, 51, 38, 39, 157, 156, 223, 256, 3672 44, 269, 3, 231, 40, 51, 270, 212, 103, 126, 3673 268, 126, 90, 38, 44, 170, 177, 181, 182, 184, 3674 197, 199, 211, 188, 129, 256, 40, 51, 39, 44, 3675 37, 51, 256, 257, 212, 223, 37, 195, 43, 71, 3676 71, 71, 124, 266, 44, 193, 106, 231, 254, 264, 3677 73, 250, 251, 255, 274, 178, 243, 243, 38, 38, 3678 243, 220, 38, 272, 272, 44, 212, 37, 75, 156, 3679 269, 273, 40, 223, 38, 256, 40, 40, 223, 164, 3680 38, 3, 3, 105, 3, 105, 216, 4, 43, 231, 3681 55, 40, 242, 243, 241, 40, 223, 212, 237, 71, 3682 258, 274, 38, 172, 212, 193, 194, 266, 37, 223, 3683 231, 37, 71, 3, 43, 264, 40, 39, 68, 69, 3684 70, 252, 264, 193, 243, 38, 212, 37, 157, 256, 3685 40, 223, 156, 40, 40, 268, 268, 91, 171, 38, 3686 40, 259, 260, 264, 40, 43, 220, 171, 38, 193, 3687 37, 212, 171, 37, 115, 228, 212, 243, 43, 204, 3688 71, 251, 255, 44, 40, 38, 212, 40, 256, 40, 3689 40, 43, 39, 37, 220, 44, 212, 38, 212, 37, 3690 37, 38, 40, 203, 206, 223, 274, 250, 264, 40, 3691 180, 223, 38, 40, 260, 193, 38, 208, 256, 38, 3692 212, 212, 257, 206, 40, 43, 171, 209, 256, 40, 3693 43, 209, 38, 38, 40, 205, 40, 43, 51, 209, 3694 209, 40, 237, 40 3695}; 3696 3697#define yyerrok (yyerrstatus = 0) 3698#define yyclearin (yychar = YYEMPTY) 3699#define YYEMPTY (-2) 3700#define YYEOF 0 3701 3702#define YYACCEPT goto yyacceptlab 3703#define YYABORT goto yyabortlab 3704#define YYERROR goto yyerrorlab 3705 3706 3707/* Like YYERROR except do call yyerror. This remains here temporarily 3708 to ease the transition to the new meaning of YYERROR, for GCC. 3709 Once GCC version 2 has supplanted version 1, this can go. */ 3710 3711#define YYFAIL goto yyerrlab 3712 3713#define YYRECOVERING() (!!yyerrstatus) 3714 3715#define YYBACKUP(Token, Value) \ 3716do \ 3717 if (yychar == YYEMPTY && yylen == 1) \ 3718 { \ 3719 yychar = (Token); \ 3720 yylval = (Value); \ 3721 yytoken = YYTRANSLATE (yychar); \ 3722 YYPOPSTACK (1); \ 3723 goto yybackup; \ 3724 } \ 3725 else \ 3726 { \ 3727 yyerror (YY_("syntax error: cannot back up")); \ 3728 YYERROR; \ 3729 } \ 3730while (YYID (0)) 3731 3732 3733#define YYTERROR 1 3734#define YYERRCODE 256 3735 3736 3737/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 3738 If N is 0, then set CURRENT to the empty location which ends 3739 the previous symbol: RHS[0] (always defined). */ 3740 3741#define YYRHSLOC(Rhs, K) ((Rhs)[K]) 3742#ifndef YYLLOC_DEFAULT 3743# define YYLLOC_DEFAULT(Current, Rhs, N) \ 3744 do \ 3745 if (YYID (N)) \ 3746 { \ 3747 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 3748 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 3749 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 3750 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 3751 } \ 3752 else \ 3753 { \ 3754 (Current).first_line = (Current).last_line = \ 3755 YYRHSLOC (Rhs, 0).last_line; \ 3756 (Current).first_column = (Current).last_column = \ 3757 YYRHSLOC (Rhs, 0).last_column; \ 3758 } \ 3759 while (YYID (0)) 3760#endif 3761 3762 3763/* YY_LOCATION_PRINT -- Print the location on the stream. 3764 This macro was not mandated originally: define only if we know 3765 we won't break user code: when these are the locations we know. */ 3766 3767#ifndef YY_LOCATION_PRINT 3768# if YYLTYPE_IS_TRIVIAL 3769# define YY_LOCATION_PRINT(File, Loc) \ 3770 fprintf (File, "%d.%d-%d.%d", \ 3771 (Loc).first_line, (Loc).first_column, \ 3772 (Loc).last_line, (Loc).last_column) 3773# else 3774# define YY_LOCATION_PRINT(File, Loc) ((void) 0) 3775# endif 3776#endif 3777 3778 3779/* YYLEX -- calling `yylex' with the right arguments. */ 3780 3781#ifdef YYLEX_PARAM 3782# define YYLEX yylex (YYLEX_PARAM) 3783#else 3784# define YYLEX yylex () 3785#endif 3786 3787/* Enable debugging if requested. */ 3788#if YYDEBUG 3789 3790# ifndef YYFPRINTF 3791# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 3792# define YYFPRINTF fprintf 3793# endif 3794 3795# define YYDPRINTF(Args) \ 3796do { \ 3797 if (yydebug) \ 3798 YYFPRINTF Args; \ 3799} while (YYID (0)) 3800 3801# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 3802do { \ 3803 if (yydebug) \ 3804 { \ 3805 YYFPRINTF (stderr, "%s ", Title); \ 3806 yy_symbol_print (stderr, \ 3807 Type, Value); \ 3808 YYFPRINTF (stderr, "\n"); \ 3809 } \ 3810} while (YYID (0)) 3811 3812 3813/*--------------------------------. 3814| Print this symbol on YYOUTPUT. | 3815`--------------------------------*/ 3816 3817/*ARGSUSED*/ 3818#if (defined __STDC__ || defined __C99__FUNC__ \ 3819 || defined __cplusplus || defined _MSC_VER) 3820static void 3821yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 3822#else 3823static void 3824yy_symbol_value_print (yyoutput, yytype, yyvaluep) 3825 FILE *yyoutput; 3826 int yytype; 3827 YYSTYPE const * const yyvaluep; 3828#endif 3829{ 3830 if (!yyvaluep) 3831 return; 3832# ifdef YYPRINT 3833 if (yytype < YYNTOKENS) 3834 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 3835# else 3836 YYUSE (yyoutput); 3837# endif 3838 switch (yytype) 3839 { 3840 default: 3841 break; 3842 } 3843} 3844 3845 3846/*--------------------------------. 3847| Print this symbol on YYOUTPUT. | 3848`--------------------------------*/ 3849 3850#if (defined __STDC__ || defined __C99__FUNC__ \ 3851 || defined __cplusplus || defined _MSC_VER) 3852static void 3853yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 3854#else 3855static void 3856yy_symbol_print (yyoutput, yytype, yyvaluep) 3857 FILE *yyoutput; 3858 int yytype; 3859 YYSTYPE const * const yyvaluep; 3860#endif 3861{ 3862 if (yytype < YYNTOKENS) 3863 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 3864 else 3865 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 3866 3867 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 3868 YYFPRINTF (yyoutput, ")"); 3869} 3870 3871/*------------------------------------------------------------------. 3872| yy_stack_print -- Print the state stack from its BOTTOM up to its | 3873| TOP (included). | 3874`------------------------------------------------------------------*/ 3875 3876#if (defined __STDC__ || defined __C99__FUNC__ \ 3877 || defined __cplusplus || defined _MSC_VER) 3878static void 3879yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 3880#else 3881static void 3882yy_stack_print (bottom, top) 3883 yytype_int16 *bottom; 3884 yytype_int16 *top; 3885#endif 3886{ 3887 YYFPRINTF (stderr, "Stack now"); 3888 for (; bottom <= top; ++bottom) 3889 YYFPRINTF (stderr, " %d", *bottom); 3890 YYFPRINTF (stderr, "\n"); 3891} 3892 3893# define YY_STACK_PRINT(Bottom, Top) \ 3894do { \ 3895 if (yydebug) \ 3896 yy_stack_print ((Bottom), (Top)); \ 3897} while (YYID (0)) 3898 3899 3900/*------------------------------------------------. 3901| Report that the YYRULE is going to be reduced. | 3902`------------------------------------------------*/ 3903 3904#if (defined __STDC__ || defined __C99__FUNC__ \ 3905 || defined __cplusplus || defined _MSC_VER) 3906static void 3907yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 3908#else 3909static void 3910yy_reduce_print (yyvsp, yyrule) 3911 YYSTYPE *yyvsp; 3912 int yyrule; 3913#endif 3914{ 3915 int yynrhs = yyr2[yyrule]; 3916 int yyi; 3917 unsigned long int yylno = yyrline[yyrule]; 3918 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 3919 yyrule - 1, yylno); 3920 /* The symbols being reduced. */ 3921 for (yyi = 0; yyi < yynrhs; yyi++) 3922 { 3923 fprintf (stderr, " $%d = ", yyi + 1); 3924 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 3925 &(yyvsp[(yyi + 1) - (yynrhs)]) 3926 ); 3927 fprintf (stderr, "\n"); 3928 } 3929} 3930 3931# define YY_REDUCE_PRINT(Rule) \ 3932do { \ 3933 if (yydebug) \ 3934 yy_reduce_print (yyvsp, Rule); \ 3935} while (YYID (0)) 3936 3937/* Nonzero means print parse trace. It is left uninitialized so that 3938 multiple parsers can coexist. */ 3939int yydebug; 3940#else /* !YYDEBUG */ 3941# define YYDPRINTF(Args) 3942# define YY_SYMBOL_PRINT(Title, Type, Value, Location) 3943# define YY_STACK_PRINT(Bottom, Top) 3944# define YY_REDUCE_PRINT(Rule) 3945#endif /* !YYDEBUG */ 3946 3947 3948/* YYINITDEPTH -- initial size of the parser's stacks. */ 3949#ifndef YYINITDEPTH 3950# define YYINITDEPTH 200 3951#endif 3952 3953/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 3954 if the built-in stack extension method is used). 3955 3956 Do not make this value too large; the results are undefined if 3957 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 3958 evaluated with infinite-precision integer arithmetic. */ 3959 3960#ifndef YYMAXDEPTH 3961# define YYMAXDEPTH 10000 3962#endif 3963 3964 3965 3966#if YYERROR_VERBOSE 3967 3968# ifndef yystrlen 3969# if defined __GLIBC__ && defined _STRING_H 3970# define yystrlen strlen 3971# else 3972/* Return the length of YYSTR. */ 3973#if (defined __STDC__ || defined __C99__FUNC__ \ 3974 || defined __cplusplus || defined _MSC_VER) 3975static YYSIZE_T 3976yystrlen (const char *yystr) 3977#else 3978static YYSIZE_T 3979yystrlen (yystr) 3980 const char *yystr; 3981#endif 3982{ 3983 YYSIZE_T yylen; 3984 for (yylen = 0; yystr[yylen]; yylen++) 3985 continue; 3986 return yylen; 3987} 3988# endif 3989# endif 3990 3991# ifndef yystpcpy 3992# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 3993# define yystpcpy stpcpy 3994# else 3995/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 3996 YYDEST. */ 3997#if (defined __STDC__ || defined __C99__FUNC__ \ 3998 || defined __cplusplus || defined _MSC_VER) 3999static char * 4000yystpcpy (char *yydest, const char *yysrc) 4001#else 4002static char * 4003yystpcpy (yydest, yysrc) 4004 char *yydest; 4005 const char *yysrc; 4006#endif 4007{ 4008 char *yyd = yydest; 4009 const char *yys = yysrc; 4010 4011 while ((*yyd++ = *yys++) != '\0') 4012 continue; 4013 4014 return yyd - 1; 4015} 4016# endif 4017# endif 4018 4019# ifndef yytnamerr 4020/* Copy to YYRES the contents of YYSTR after stripping away unnecessary 4021 quotes and backslashes, so that it's suitable for yyerror. The 4022 heuristic is that double-quoting is unnecessary unless the string 4023 contains an apostrophe, a comma, or backslash (other than 4024 backslash-backslash). YYSTR is taken from yytname. If YYRES is 4025 null, do not copy; instead, return the length of what the result 4026 would have been. */ 4027static YYSIZE_T 4028yytnamerr (char *yyres, const char *yystr) 4029{ 4030 if (*yystr == '"') 4031 { 4032 YYSIZE_T yyn = 0; 4033 char const *yyp = yystr; 4034 4035 for (;;) 4036 switch (*++yyp) 4037 { 4038 case '\'': 4039 case ',': 4040 goto do_not_strip_quotes; 4041 4042 case '\\': 4043 if (*++yyp != '\\') 4044 goto do_not_strip_quotes; 4045 /* Fall through. */ 4046 default: 4047 if (yyres) 4048 yyres[yyn] = *yyp; 4049 yyn++; 4050 break; 4051 4052 case '"': 4053 if (yyres) 4054 yyres[yyn] = '\0'; 4055 return yyn; 4056 } 4057 do_not_strip_quotes: ; 4058 } 4059 4060 if (! yyres) 4061 return yystrlen (yystr); 4062 4063 return yystpcpy (yyres, yystr) - yyres; 4064} 4065# endif 4066 4067/* Copy into YYRESULT an error message about the unexpected token 4068 YYCHAR while in state YYSTATE. Return the number of bytes copied, 4069 including the terminating null byte. If YYRESULT is null, do not 4070 copy anything; just return the number of bytes that would be 4071 copied. As a special case, return 0 if an ordinary "syntax error" 4072 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 4073 size calculation. */ 4074static YYSIZE_T 4075yysyntax_error (char *yyresult, int yystate, int yychar) 4076{ 4077 int yyn = yypact[yystate]; 4078 4079 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 4080 return 0; 4081 else 4082 { 4083 int yytype = YYTRANSLATE (yychar); 4084 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 4085 YYSIZE_T yysize = yysize0; 4086 YYSIZE_T yysize1; 4087 int yysize_overflow = 0; 4088 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 4089 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 4090 int yyx; 4091 4092# if 0 4093 /* This is so xgettext sees the translatable formats that are 4094 constructed on the fly. */ 4095 YY_("syntax error, unexpected %s"); 4096 YY_("syntax error, unexpected %s, expecting %s"); 4097 YY_("syntax error, unexpected %s, expecting %s or %s"); 4098 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 4099 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 4100# endif 4101 char *yyfmt; 4102 char const *yyf; 4103 static char const yyunexpected[] = "syntax error, unexpected %s"; 4104 static char const yyexpecting[] = ", expecting %s"; 4105 static char const yyor[] = " or %s"; 4106 char yyformat[sizeof yyunexpected 4107 + sizeof yyexpecting - 1 4108 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 4109 * (sizeof yyor - 1))]; 4110 char const *yyprefix = yyexpecting; 4111 4112 /* Start YYX at -YYN if negative to avoid negative indexes in 4113 YYCHECK. */ 4114 int yyxbegin = yyn < 0 ? -yyn : 0; 4115 4116 /* Stay within bounds of both yycheck and yytname. */ 4117 int yychecklim = YYLAST - yyn + 1; 4118 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 4119 int yycount = 1; 4120 4121 yyarg[0] = yytname[yytype]; 4122 yyfmt = yystpcpy (yyformat, yyunexpected); 4123 4124 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 4125 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 4126 { 4127 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 4128 { 4129 yycount = 1; 4130 yysize = yysize0; 4131 yyformat[sizeof yyunexpected - 1] = '\0'; 4132 break; 4133 } 4134 yyarg[yycount++] = yytname[yyx]; 4135 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 4136 yysize_overflow |= (yysize1 < yysize); 4137 yysize = yysize1; 4138 yyfmt = yystpcpy (yyfmt, yyprefix); 4139 yyprefix = yyor; 4140 } 4141 4142 yyf = YY_(yyformat); 4143 yysize1 = yysize + yystrlen (yyf); 4144 yysize_overflow |= (yysize1 < yysize); 4145 yysize = yysize1; 4146 4147 if (yysize_overflow) 4148 return YYSIZE_MAXIMUM; 4149 4150 if (yyresult) 4151 { 4152 /* Avoid sprintf, as that infringes on the user's name space. 4153 Don't have undefined behavior even if the translation 4154 produced a string with the wrong number of "%s"s. */ 4155 char *yyp = yyresult; 4156 int yyi = 0; 4157 while ((*yyp = *yyf) != '\0') 4158 { 4159 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 4160 { 4161 yyp += yytnamerr (yyp, yyarg[yyi++]); 4162 yyf += 2; 4163 } 4164 else 4165 { 4166 yyp++; 4167 yyf++; 4168 } 4169 } 4170 } 4171 return yysize; 4172 } 4173} 4174#endif /* YYERROR_VERBOSE */ 4175 4176 4177/*-----------------------------------------------. 4178| Release the memory associated to this symbol. | 4179`-----------------------------------------------*/ 4180 4181/*ARGSUSED*/ 4182#if (defined __STDC__ || defined __C99__FUNC__ \ 4183 || defined __cplusplus || defined _MSC_VER) 4184static void 4185yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 4186#else 4187static void 4188yydestruct (yymsg, yytype, yyvaluep) 4189 const char *yymsg; 4190 int yytype; 4191 YYSTYPE *yyvaluep; 4192#endif 4193{ 4194 YYUSE (yyvaluep); 4195 4196 if (!yymsg) 4197 yymsg = "Deleting"; 4198 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 4199 4200 switch (yytype) 4201 { 4202 4203 default: 4204 break; 4205 } 4206} 4207 4208 4209/* Prevent warnings from -Wmissing-prototypes. */ 4210 4211#ifdef YYPARSE_PARAM 4212#if defined __STDC__ || defined __cplusplus 4213int yyparse (void *YYPARSE_PARAM); 4214#else 4215int yyparse (); 4216#endif 4217#else /* ! YYPARSE_PARAM */ 4218#if defined __STDC__ || defined __cplusplus 4219int yyparse (void); 4220#else 4221int yyparse (); 4222#endif 4223#endif /* ! YYPARSE_PARAM */ 4224 4225 4226 4227/* The look-ahead symbol. */ 4228int yychar; 4229 4230/* The semantic value of the look-ahead symbol. */ 4231YYSTYPE yylval; 4232 4233/* Number of syntax errors so far. */ 4234int yynerrs; 4235 4236 4237 4238/*----------. 4239| yyparse. | 4240`----------*/ 4241 4242#ifdef YYPARSE_PARAM 4243#if (defined __STDC__ || defined __C99__FUNC__ \ 4244 || defined __cplusplus || defined _MSC_VER) 4245int 4246yyparse (void *YYPARSE_PARAM) 4247#else 4248int 4249yyparse (YYPARSE_PARAM) 4250 void *YYPARSE_PARAM; 4251#endif 4252#else /* ! YYPARSE_PARAM */ 4253#if (defined __STDC__ || defined __C99__FUNC__ \ 4254 || defined __cplusplus || defined _MSC_VER) 4255int 4256yyparse (void) 4257#else 4258int 4259yyparse () 4260 4261#endif 4262#endif 4263{ 4264 4265 int yystate; 4266 int yyn; 4267 int yyresult; 4268 /* Number of tokens to shift before error messages enabled. */ 4269 int yyerrstatus; 4270 /* Look-ahead token as an internal (translated) token number. */ 4271 int yytoken = 0; 4272#if YYERROR_VERBOSE 4273 /* Buffer for error messages, and its allocated size. */ 4274 char yymsgbuf[128]; 4275 char *yymsg = yymsgbuf; 4276 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 4277#endif 4278 4279 /* Three stacks and their tools: 4280 `yyss': related to states, 4281 `yyvs': related to semantic values, 4282 `yyls': related to locations. 4283 4284 Refer to the stacks thru separate pointers, to allow yyoverflow 4285 to reallocate them elsewhere. */ 4286 4287 /* The state stack. */ 4288 yytype_int16 yyssa[YYINITDEPTH]; 4289 yytype_int16 *yyss = yyssa; 4290 yytype_int16 *yyssp; 4291 4292 /* The semantic value stack. */ 4293 YYSTYPE yyvsa[YYINITDEPTH]; 4294 YYSTYPE *yyvs = yyvsa; 4295 YYSTYPE *yyvsp; 4296 4297 4298 4299#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 4300 4301 YYSIZE_T yystacksize = YYINITDEPTH; 4302 4303 /* The variables used to return semantic value and location from the 4304 action routines. */ 4305 YYSTYPE yyval; 4306 4307 4308 /* The number of symbols on the RHS of the reduced rule. 4309 Keep to zero when no symbol should be popped. */ 4310 int yylen = 0; 4311 4312 YYDPRINTF ((stderr, "Starting parse\n")); 4313 4314 yystate = 0; 4315 yyerrstatus = 0; 4316 yynerrs = 0; 4317 yychar = YYEMPTY; /* Cause a token to be read. */ 4318 4319 /* Initialize stack pointers. 4320 Waste one element of value and location stack 4321 so that they stay on the same level as the state stack. 4322 The wasted elements are never initialized. */ 4323 4324 yyssp = yyss; 4325 yyvsp = yyvs; 4326 4327 goto yysetstate; 4328 4329/*------------------------------------------------------------. 4330| yynewstate -- Push a new state, which is found in yystate. | 4331`------------------------------------------------------------*/ 4332 yynewstate: 4333 /* In all cases, when you get here, the value and location stacks 4334 have just been pushed. So pushing a state here evens the stacks. */ 4335 yyssp++; 4336 4337 yysetstate: 4338 *yyssp = yystate; 4339 4340 if (yyss + yystacksize - 1 <= yyssp) 4341 { 4342 /* Get the current used size of the three stacks, in elements. */ 4343 YYSIZE_T yysize = yyssp - yyss + 1; 4344 4345#ifdef yyoverflow 4346 { 4347 /* Give user a chance to reallocate the stack. Use copies of 4348 these so that the &'s don't force the real ones into 4349 memory. */ 4350 YYSTYPE *yyvs1 = yyvs; 4351 yytype_int16 *yyss1 = yyss; 4352 4353 4354 /* Each stack pointer address is followed by the size of the 4355 data in use in that stack, in bytes. This used to be a 4356 conditional around just the two extra args, but that might 4357 be undefined if yyoverflow is a macro. */ 4358 yyoverflow (YY_("memory exhausted"), 4359 &yyss1, yysize * sizeof (*yyssp), 4360 &yyvs1, yysize * sizeof (*yyvsp), 4361 4362 &yystacksize); 4363 4364 yyss = yyss1; 4365 yyvs = yyvs1; 4366 } 4367#else /* no yyoverflow */ 4368# ifndef YYSTACK_RELOCATE 4369 goto yyexhaustedlab; 4370# else 4371 /* Extend the stack our own way. */ 4372 if (YYMAXDEPTH <= yystacksize) 4373 goto yyexhaustedlab; 4374 yystacksize *= 2; 4375 if (YYMAXDEPTH < yystacksize) 4376 yystacksize = YYMAXDEPTH; 4377 4378 { 4379 yytype_int16 *yyss1 = yyss; 4380 union yyalloc *yyptr = 4381 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 4382 if (! yyptr) 4383 goto yyexhaustedlab; 4384 YYSTACK_RELOCATE (yyss); 4385 YYSTACK_RELOCATE (yyvs); 4386 4387# undef YYSTACK_RELOCATE 4388 if (yyss1 != yyssa) 4389 YYSTACK_FREE (yyss1); 4390 } 4391# endif 4392#endif /* no yyoverflow */ 4393 4394 yyssp = yyss + yysize - 1; 4395 yyvsp = yyvs + yysize - 1; 4396 4397 4398 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 4399 (unsigned long int) yystacksize)); 4400 4401 if (yyss + yystacksize - 1 <= yyssp) 4402 YYABORT; 4403 } 4404 4405 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 4406 4407 goto yybackup; 4408 4409/*-----------. 4410| yybackup. | 4411`-----------*/ 4412yybackup: 4413 4414 /* Do appropriate processing given the current state. Read a 4415 look-ahead token if we need one and don't already have one. */ 4416 4417 /* First try to decide what to do without reference to look-ahead token. */ 4418 yyn = yypact[yystate]; 4419 if (yyn == YYPACT_NINF) 4420 goto yydefault; 4421 4422 /* Not known => get a look-ahead token if don't already have one. */ 4423 4424 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 4425 if (yychar == YYEMPTY) 4426 { 4427 YYDPRINTF ((stderr, "Reading a token: ")); 4428 yychar = YYLEX; 4429 } 4430 4431 if (yychar <= YYEOF) 4432 { 4433 yychar = yytoken = YYEOF; 4434 YYDPRINTF ((stderr, "Now at end of input.\n")); 4435 } 4436 else 4437 { 4438 yytoken = YYTRANSLATE (yychar); 4439 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 4440 } 4441 4442 /* If the proper action on seeing token YYTOKEN is to reduce or to 4443 detect an error, take that action. */ 4444 yyn += yytoken; 4445 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 4446 goto yydefault; 4447 yyn = yytable[yyn]; 4448 if (yyn <= 0) 4449 { 4450 if (yyn == 0 || yyn == YYTABLE_NINF) 4451 goto yyerrlab; 4452 yyn = -yyn; 4453 goto yyreduce; 4454 } 4455 4456 if (yyn == YYFINAL) 4457 YYACCEPT; 4458 4459 /* Count tokens shifted since error; after three, turn off error 4460 status. */ 4461 if (yyerrstatus) 4462 yyerrstatus--; 4463 4464 /* Shift the look-ahead token. */ 4465 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 4466 4467 /* Discard the shifted token unless it is eof. */ 4468 if (yychar != YYEOF) 4469 yychar = YYEMPTY; 4470 4471 yystate = yyn; 4472 *++yyvsp = yylval; 4473 4474 goto yynewstate; 4475 4476 4477/*-----------------------------------------------------------. 4478| yydefault -- do the default action for the current state. | 4479`-----------------------------------------------------------*/ 4480yydefault: 4481 yyn = yydefact[yystate]; 4482 if (yyn == 0) 4483 goto yyerrlab; 4484 goto yyreduce; 4485 4486 4487/*-----------------------------. 4488| yyreduce -- Do a reduction. | 4489`-----------------------------*/ 4490yyreduce: 4491 /* yyn is the number of a rule to reduce with. */ 4492 yylen = yyr2[yyn]; 4493 4494 /* If YYLEN is nonzero, implement the default value of the action: 4495 `$$ = $1'. 4496 4497 Otherwise, the following line sets YYVAL to garbage. 4498 This behavior is undocumented and Bison 4499 users should not rely upon it. Assigning to YYVAL 4500 unconditionally makes the parser a bit smaller, and it avoids a 4501 GCC warning that YYVAL may be used uninitialized. */ 4502 yyval = yyvsp[1-yylen]; 4503 4504 4505 YY_REDUCE_PRINT (yyn); 4506 switch (yyn) 4507 { 4508 case 2: 4509#line 1593 "parser.y" 4510 { 4511 if (!classes) classes = NewHash(); 4512 Setattr((yyvsp[(1) - (1)].node),"classes",classes); 4513 Setattr((yyvsp[(1) - (1)].node),"name",ModuleName); 4514 4515 if ((!module_node) && ModuleName) { 4516 module_node = new_node("module"); 4517 Setattr(module_node,"name",ModuleName); 4518 } 4519 Setattr((yyvsp[(1) - (1)].node),"module",module_node); 4520 check_extensions(); 4521 top = (yyvsp[(1) - (1)].node); 4522 } 4523 break; 4524 4525 case 3: 4526#line 1606 "parser.y" 4527 { 4528 top = Copy(Getattr((yyvsp[(2) - (3)].p),"type")); 4529 Delete((yyvsp[(2) - (3)].p)); 4530 } 4531 break; 4532 4533 case 4: 4534#line 1610 "parser.y" 4535 { 4536 top = 0; 4537 } 4538 break; 4539 4540 case 5: 4541#line 1613 "parser.y" 4542 { 4543 top = (yyvsp[(2) - (3)].p); 4544 } 4545 break; 4546 4547 case 6: 4548#line 1616 "parser.y" 4549 { 4550 top = 0; 4551 } 4552 break; 4553 4554 case 7: 4555#line 1619 "parser.y" 4556 { 4557 top = (yyvsp[(3) - (5)].pl); 4558 } 4559 break; 4560 4561 case 8: 4562#line 1622 "parser.y" 4563 { 4564 top = 0; 4565 } 4566 break; 4567 4568 case 9: 4569#line 1627 "parser.y" 4570 { 4571 /* add declaration to end of linked list (the declaration isn't always a single declaration, sometimes it is a linked list itself) */ 4572 appendChild((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node)); 4573 (yyval.node) = (yyvsp[(1) - (2)].node); 4574 } 4575 break; 4576 4577 case 10: 4578#line 1632 "parser.y" 4579 { 4580 (yyval.node) = new_node("top"); 4581 } 4582 break; 4583 4584 case 11: 4585#line 1637 "parser.y" 4586 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4587 break; 4588 4589 case 12: 4590#line 1638 "parser.y" 4591 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4592 break; 4593 4594 case 13: 4595#line 1639 "parser.y" 4596 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4597 break; 4598 4599 case 14: 4600#line 1640 "parser.y" 4601 { (yyval.node) = 0; } 4602 break; 4603 4604 case 15: 4605#line 1641 "parser.y" 4606 { 4607 (yyval.node) = 0; 4608 Swig_error(cparse_file, cparse_line,"Syntax error in input(1).\n"); 4609 exit(1); 4610 } 4611 break; 4612 4613 case 16: 4614#line 1647 "parser.y" 4615 { 4616 if ((yyval.node)) { 4617 add_symbols((yyval.node)); 4618 } 4619 (yyval.node) = (yyvsp[(1) - (1)].node); 4620 } 4621 break; 4622 4623 case 17: 4624#line 1663 "parser.y" 4625 { 4626 (yyval.node) = 0; 4627 skip_decl(); 4628 } 4629 break; 4630 4631 case 18: 4632#line 1673 "parser.y" 4633 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4634 break; 4635 4636 case 19: 4637#line 1674 "parser.y" 4638 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4639 break; 4640 4641 case 20: 4642#line 1675 "parser.y" 4643 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4644 break; 4645 4646 case 21: 4647#line 1676 "parser.y" 4648 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4649 break; 4650 4651 case 22: 4652#line 1677 "parser.y" 4653 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4654 break; 4655 4656 case 23: 4657#line 1678 "parser.y" 4658 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4659 break; 4660 4661 case 24: 4662#line 1679 "parser.y" 4663 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4664 break; 4665 4666 case 25: 4667#line 1680 "parser.y" 4668 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4669 break; 4670 4671 case 26: 4672#line 1681 "parser.y" 4673 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4674 break; 4675 4676 case 27: 4677#line 1682 "parser.y" 4678 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4679 break; 4680 4681 case 28: 4682#line 1683 "parser.y" 4683 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4684 break; 4685 4686 case 29: 4687#line 1684 "parser.y" 4688 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4689 break; 4690 4691 case 30: 4692#line 1685 "parser.y" 4693 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4694 break; 4695 4696 case 31: 4697#line 1686 "parser.y" 4698 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4699 break; 4700 4701 case 32: 4702#line 1687 "parser.y" 4703 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4704 break; 4705 4706 case 33: 4707#line 1688 "parser.y" 4708 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4709 break; 4710 4711 case 34: 4712#line 1689 "parser.y" 4713 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4714 break; 4715 4716 case 35: 4717#line 1690 "parser.y" 4718 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4719 break; 4720 4721 case 36: 4722#line 1691 "parser.y" 4723 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4724 break; 4725 4726 case 37: 4727#line 1692 "parser.y" 4728 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4729 break; 4730 4731 case 38: 4732#line 1693 "parser.y" 4733 { (yyval.node) = (yyvsp[(1) - (1)].node); } 4734 break; 4735 4736 case 39: 4737#line 1700 "parser.y" 4738 { 4739 Node *cls; 4740 String *clsname; 4741 cplus_mode = CPLUS_PUBLIC; 4742 if (!classes) classes = NewHash(); 4743 if (!extendhash) extendhash = NewHash(); 4744 clsname = make_class_name((yyvsp[(3) - (4)].str)); 4745 cls = Getattr(classes,clsname); 4746 if (!cls) { 4747 /* No previous definition. Create a new scope */ 4748 Node *am = Getattr(extendhash,clsname); 4749 if (!am) { 4750 Swig_symbol_newscope(); 4751 Swig_symbol_setscopename((yyvsp[(3) - (4)].str)); 4752 prev_symtab = 0; 4753 } else { 4754 prev_symtab = Swig_symbol_setscope(Getattr(am,"symtab")); 4755 } 4756 current_class = 0; 4757 } else { 4758 /* Previous class definition. Use its symbol table */ 4759 prev_symtab = Swig_symbol_setscope(Getattr(cls,"symtab")); 4760 current_class = cls; 4761 extendmode = 1; 4762 } 4763 Classprefix = NewString((yyvsp[(3) - (4)].str)); 4764 Namespaceprefix= Swig_symbol_qualifiedscopename(0); 4765 Delete(clsname); 4766 } 4767 break; 4768 4769 case 40: 4770#line 1728 "parser.y" 4771 { 4772 String *clsname; 4773 extendmode = 0; 4774 (yyval.node) = new_node("extend"); 4775 Setattr((yyval.node),"symtab",Swig_symbol_popscope()); 4776 if (prev_symtab) { 4777 Swig_symbol_setscope(prev_symtab); 4778 } 4779 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 4780 clsname = make_class_name((yyvsp[(3) - (7)].str)); 4781 Setattr((yyval.node),"name",clsname); 4782 4783 /* Mark members as extend */ 4784 4785 tag_nodes((yyvsp[(6) - (7)].node),"feature:extend",(char*) "1"); 4786 if (current_class) { 4787 /* We add the extension to the previously defined class */ 4788 appendChild((yyval.node),(yyvsp[(6) - (7)].node)); 4789 appendChild(current_class,(yyval.node)); 4790 } else { 4791 /* We store the extensions in the extensions hash */ 4792 Node *am = Getattr(extendhash,clsname); 4793 if (am) { 4794 /* Append the members to the previous extend methods */ 4795 appendChild(am,(yyvsp[(6) - (7)].node)); 4796 } else { 4797 appendChild((yyval.node),(yyvsp[(6) - (7)].node)); 4798 Setattr(extendhash,clsname,(yyval.node)); 4799 } 4800 } 4801 current_class = 0; 4802 Delete(Classprefix); 4803 Delete(clsname); 4804 Classprefix = 0; 4805 prev_symtab = 0; 4806 (yyval.node) = 0; 4807 4808 } 4809 break; 4810 4811 case 41: 4812#line 1772 "parser.y" 4813 { 4814 (yyval.node) = new_node("apply"); 4815 Setattr((yyval.node),"pattern",Getattr((yyvsp[(2) - (5)].p),"pattern")); 4816 appendChild((yyval.node),(yyvsp[(4) - (5)].p)); 4817 } 4818 break; 4819 4820 case 42: 4821#line 1782 "parser.y" 4822 { 4823 (yyval.node) = new_node("clear"); 4824 appendChild((yyval.node),(yyvsp[(2) - (3)].p)); 4825 } 4826 break; 4827 4828 case 43: 4829#line 1793 "parser.y" 4830 { 4831 if (((yyvsp[(4) - (5)].dtype).type != T_ERROR) && ((yyvsp[(4) - (5)].dtype).type != T_SYMBOL)) { 4832 SwigType *type = NewSwigType((yyvsp[(4) - (5)].dtype).type); 4833 (yyval.node) = new_node("constant"); 4834 Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id)); 4835 Setattr((yyval.node),"type",type); 4836 Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val); 4837 if ((yyvsp[(4) - (5)].dtype).rawval) Setattr((yyval.node),"rawval", (yyvsp[(4) - (5)].dtype).rawval); 4838 Setattr((yyval.node),"storage","%constant"); 4839 SetFlag((yyval.node),"feature:immutable"); 4840 add_symbols((yyval.node)); 4841 Delete(type); 4842 } else { 4843 if ((yyvsp[(4) - (5)].dtype).type == T_ERROR) { 4844 Swig_warning(WARN_PARSE_UNSUPPORTED_VALUE,cparse_file,cparse_line,"Unsupported constant value (ignored)\n"); 4845 } 4846 (yyval.node) = 0; 4847 } 4848 4849 } 4850 break; 4851 4852 case 44: 4853#line 1814 "parser.y" 4854 { 4855 if (((yyvsp[(4) - (5)].dtype).type != T_ERROR) && ((yyvsp[(4) - (5)].dtype).type != T_SYMBOL)) { 4856 SwigType_push((yyvsp[(2) - (5)].type),(yyvsp[(3) - (5)].decl).type); 4857 /* Sneaky callback function trick */ 4858 if (SwigType_isfunction((yyvsp[(2) - (5)].type))) { 4859 SwigType_add_pointer((yyvsp[(2) - (5)].type)); 4860 } 4861 (yyval.node) = new_node("constant"); 4862 Setattr((yyval.node),"name",(yyvsp[(3) - (5)].decl).id); 4863 Setattr((yyval.node),"type",(yyvsp[(2) - (5)].type)); 4864 Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val); 4865 if ((yyvsp[(4) - (5)].dtype).rawval) Setattr((yyval.node),"rawval", (yyvsp[(4) - (5)].dtype).rawval); 4866 Setattr((yyval.node),"storage","%constant"); 4867 SetFlag((yyval.node),"feature:immutable"); 4868 add_symbols((yyval.node)); 4869 } else { 4870 if ((yyvsp[(4) - (5)].dtype).type == T_ERROR) { 4871 Swig_warning(WARN_PARSE_UNSUPPORTED_VALUE,cparse_file,cparse_line,"Unsupported constant value\n"); 4872 } 4873 (yyval.node) = 0; 4874 } 4875 } 4876 break; 4877 4878 case 45: 4879#line 1836 "parser.y" 4880 { 4881 Swig_warning(WARN_PARSE_BAD_VALUE,cparse_file,cparse_line,"Bad constant value (ignored).\n"); 4882 (yyval.node) = 0; 4883 } 4884 break; 4885 4886 case 46: 4887#line 1847 "parser.y" 4888 { 4889 char temp[64]; 4890 Replace((yyvsp[(2) - (2)].str),"$file",cparse_file, DOH_REPLACE_ANY); 4891 sprintf(temp,"%d", cparse_line); 4892 Replace((yyvsp[(2) - (2)].str),"$line",temp,DOH_REPLACE_ANY); 4893 Printf(stderr,"%s\n", (yyvsp[(2) - (2)].str)); 4894 Delete((yyvsp[(2) - (2)].str)); 4895 (yyval.node) = 0; 4896 } 4897 break; 4898 4899 case 47: 4900#line 1856 "parser.y" 4901 { 4902 char temp[64]; 4903 String *s = NewString((yyvsp[(2) - (2)].id)); 4904 Replace(s,"$file",cparse_file, DOH_REPLACE_ANY); 4905 sprintf(temp,"%d", cparse_line); 4906 Replace(s,"$line",temp,DOH_REPLACE_ANY); 4907 Printf(stderr,"%s\n", s); 4908 Delete(s); 4909 (yyval.node) = 0; 4910 } 4911 break; 4912 4913 case 48: 4914#line 1875 "parser.y" 4915 { 4916 skip_balanced('{','}'); 4917 (yyval.node) = 0; 4918 Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n"); 4919 } 4920 break; 4921 4922 case 49: 4923#line 1881 "parser.y" 4924 { 4925 skip_balanced('{','}'); 4926 (yyval.node) = 0; 4927 Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n"); 4928 } 4929 break; 4930 4931 case 50: 4932#line 1887 "parser.y" 4933 { 4934 (yyval.node) = 0; 4935 Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n"); 4936 } 4937 break; 4938 4939 case 51: 4940#line 1892 "parser.y" 4941 { 4942 (yyval.node) = 0; 4943 Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n"); 4944 } 4945 break; 4946 4947 case 52: 4948#line 1899 "parser.y" 4949 { 4950 (yyval.node) = NewHash(); 4951 Setattr((yyval.node),"value",(yyvsp[(1) - (4)].id)); 4952 Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (4)].p),"type")); 4953 } 4954 break; 4955 4956 case 53: 4957#line 1906 "parser.y" 4958 { 4959 (yyval.node) = NewHash(); 4960 Setattr((yyval.node),"value",(yyvsp[(1) - (1)].id)); 4961 } 4962 break; 4963 4964 case 54: 4965#line 1910 "parser.y" 4966 { 4967 (yyval.node) = (yyvsp[(1) - (1)].node); 4968 } 4969 break; 4970 4971 case 55: 4972#line 1923 "parser.y" 4973 { 4974 Hash *p = (yyvsp[(5) - (7)].node); 4975 (yyval.node) = new_node("fragment"); 4976 Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (7)].node),"value")); 4977 Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (7)].node),"type")); 4978 Setattr((yyval.node),"section",Getattr(p,"name")); 4979 Setattr((yyval.node),"kwargs",nextSibling(p)); 4980 Setattr((yyval.node),"code",(yyvsp[(7) - (7)].str)); 4981 } 4982 break; 4983 4984 case 56: 4985#line 1932 "parser.y" 4986 { 4987 Hash *p = (yyvsp[(5) - (7)].node); 4988 String *code; 4989 skip_balanced('{','}'); 4990 (yyval.node) = new_node("fragment"); 4991 Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (7)].node),"value")); 4992 Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (7)].node),"type")); 4993 Setattr((yyval.node),"section",Getattr(p,"name")); 4994 Setattr((yyval.node),"kwargs",nextSibling(p)); 4995 Delitem(scanner_ccode,0); 4996 Delitem(scanner_ccode,DOH_END); 4997 code = Copy(scanner_ccode); 4998 Setattr((yyval.node),"code",code); 4999 Delete(code); 5000 } 5001 break; 5002 5003 case 57: 5004#line 1947 "parser.y" 5005 { 5006 (yyval.node) = new_node("fragment"); 5007 Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (5)].node),"value")); 5008 Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (5)].node),"type")); 5009 Setattr((yyval.node),"emitonly","1"); 5010 } 5011 break; 5012 5013 case 58: 5014#line 1960 "parser.y" 5015 { 5016 (yyvsp[(1) - (4)].loc).filename = Copy(cparse_file); 5017 (yyvsp[(1) - (4)].loc).line = cparse_line; 5018 scanner_set_location(NewString((yyvsp[(3) - (4)].id)),1); 5019 if ((yyvsp[(2) - (4)].node)) { 5020 String *maininput = Getattr((yyvsp[(2) - (4)].node), "maininput"); 5021 if (maininput) 5022 scanner_set_main_input_file(NewString(maininput)); 5023 } 5024 } 5025 break; 5026 5027 case 59: 5028#line 1969 "parser.y" 5029 { 5030 String *mname = 0; 5031 (yyval.node) = (yyvsp[(6) - (7)].node); 5032 scanner_set_location((yyvsp[(1) - (7)].loc).filename,(yyvsp[(1) - (7)].loc).line); 5033 if (strcmp((yyvsp[(1) - (7)].loc).type,"include") == 0) set_nodeType((yyval.node),"include"); 5034 if (strcmp((yyvsp[(1) - (7)].loc).type,"import") == 0) { 5035 mname = (yyvsp[(2) - (7)].node) ? Getattr((yyvsp[(2) - (7)].node),"module") : 0; 5036 set_nodeType((yyval.node),"import"); 5037 if (import_mode) --import_mode; 5038 } 5039 5040 Setattr((yyval.node),"name",(yyvsp[(3) - (7)].id)); 5041 /* Search for the module (if any) */ 5042 { 5043 Node *n = firstChild((yyval.node)); 5044 while (n) { 5045 if (Strcmp(nodeType(n),"module") == 0) { 5046 if (mname) { 5047 Setattr(n,"name", mname); 5048 mname = 0; 5049 } 5050 Setattr((yyval.node),"module",Getattr(n,"name")); 5051 break; 5052 } 5053 n = nextSibling(n); 5054 } 5055 if (mname) { 5056 /* There is no module node in the import 5057 node, ie, you imported a .h file 5058 directly. We are forced then to create 5059 a new import node with a module node. 5060 */ 5061 Node *nint = new_node("import"); 5062 Node *mnode = new_node("module"); 5063 Setattr(mnode,"name", mname); 5064 appendChild(nint,mnode); 5065 Delete(mnode); 5066 appendChild(nint,firstChild((yyval.node))); 5067 (yyval.node) = nint; 5068 Setattr((yyval.node),"module",mname); 5069 } 5070 } 5071 Setattr((yyval.node),"options",(yyvsp[(2) - (7)].node)); 5072 } 5073 break; 5074 5075 case 60: 5076#line 2015 "parser.y" 5077 { (yyval.loc).type = (char *) "include"; } 5078 break; 5079 5080 case 61: 5081#line 2016 "parser.y" 5082 { (yyval.loc).type = (char *) "import"; ++import_mode;} 5083 break; 5084 5085 case 62: 5086#line 2023 "parser.y" 5087 { 5088 String *cpps; 5089 if (Namespaceprefix) { 5090 Swig_error(cparse_file, cparse_start_line, "%%inline directive inside a namespace is disallowed.\n"); 5091 5092 (yyval.node) = 0; 5093 } else { 5094 (yyval.node) = new_node("insert"); 5095 Setattr((yyval.node),"code",(yyvsp[(2) - (2)].str)); 5096 /* Need to run through the preprocessor */ 5097 Setline((yyvsp[(2) - (2)].str),cparse_start_line); 5098 Setfile((yyvsp[(2) - (2)].str),cparse_file); 5099 Seek((yyvsp[(2) - (2)].str),0,SEEK_SET); 5100 cpps = Preprocessor_parse((yyvsp[(2) - (2)].str)); 5101 start_inline(Char(cpps), cparse_start_line); 5102 Delete((yyvsp[(2) - (2)].str)); 5103 Delete(cpps); 5104 } 5105 5106 } 5107 break; 5108 5109 case 63: 5110#line 2043 "parser.y" 5111 { 5112 String *cpps; 5113 int start_line = cparse_line; 5114 skip_balanced('{','}'); 5115 if (Namespaceprefix) { 5116 Swig_error(cparse_file, cparse_start_line, "%%inline directive inside a namespace is disallowed.\n"); 5117 5118 (yyval.node) = 0; 5119 } else { 5120 String *code; 5121 (yyval.node) = new_node("insert"); 5122 Delitem(scanner_ccode,0); 5123 Delitem(scanner_ccode,DOH_END); 5124 code = Copy(scanner_ccode); 5125 Setattr((yyval.node),"code", code); 5126 Delete(code); 5127 cpps=Copy(scanner_ccode); 5128 start_inline(Char(cpps), start_line); 5129 Delete(cpps); 5130 } 5131 } 5132 break; 5133 5134 case 64: 5135#line 2074 "parser.y" 5136 { 5137 (yyval.node) = new_node("insert"); 5138 Setattr((yyval.node),"code",(yyvsp[(1) - (1)].str)); 5139 } 5140 break; 5141 5142 case 65: 5143#line 2078 "parser.y" 5144 { 5145 String *code = NewStringEmpty(); 5146 (yyval.node) = new_node("insert"); 5147 Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id)); 5148 Setattr((yyval.node),"code",code); 5149 if (Swig_insert_file((yyvsp[(5) - (5)].id),code) < 0) { 5150 Swig_error(cparse_file, cparse_line, "Couldn't find '%s'.\n", (yyvsp[(5) - (5)].id)); 5151 (yyval.node) = 0; 5152 } 5153 } 5154 break; 5155 5156 case 66: 5157#line 2088 "parser.y" 5158 { 5159 (yyval.node) = new_node("insert"); 5160 Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id)); 5161 Setattr((yyval.node),"code",(yyvsp[(5) - (5)].str)); 5162 } 5163 break; 5164 5165 case 67: 5166#line 2093 "parser.y" 5167 { 5168 String *code; 5169 skip_balanced('{','}'); 5170 (yyval.node) = new_node("insert"); 5171 Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id)); 5172 Delitem(scanner_ccode,0); 5173 Delitem(scanner_ccode,DOH_END); 5174 code = Copy(scanner_ccode); 5175 Setattr((yyval.node),"code", code); 5176 Delete(code); 5177 } 5178 break; 5179 5180 case 68: 5181#line 2111 "parser.y" 5182 { 5183 (yyval.node) = new_node("module"); 5184 if ((yyvsp[(2) - (3)].node)) { 5185 Setattr((yyval.node),"options",(yyvsp[(2) - (3)].node)); 5186 if (Getattr((yyvsp[(2) - (3)].node),"directors")) { 5187 Wrapper_director_mode_set(1); 5188 } 5189 if (Getattr((yyvsp[(2) - (3)].node),"dirprot")) { 5190 Wrapper_director_protected_mode_set(1); 5191 } 5192 if (Getattr((yyvsp[(2) - (3)].node),"allprotected")) { 5193 Wrapper_all_protected_mode_set(1); 5194 } 5195 if (Getattr((yyvsp[(2) - (3)].node),"templatereduce")) { 5196 template_reduce = 1; 5197 } 5198 if (Getattr((yyvsp[(2) - (3)].node),"notemplatereduce")) { 5199 template_reduce = 0; 5200 } 5201 } 5202 if (!ModuleName) ModuleName = NewString((yyvsp[(3) - (3)].id)); 5203 if (!import_mode) { 5204 /* first module included, we apply global 5205 ModuleName, which can be modify by -module */ 5206 String *mname = Copy(ModuleName); 5207 Setattr((yyval.node),"name",mname); 5208 Delete(mname); 5209 } else { 5210 /* import mode, we just pass the idstring */ 5211 Setattr((yyval.node),"name",(yyvsp[(3) - (3)].id)); 5212 } 5213 if (!module_node) module_node = (yyval.node); 5214 } 5215 break; 5216 5217 case 69: 5218#line 2151 "parser.y" 5219 { 5220 Swig_warning(WARN_DEPRECATED_NAME,cparse_file,cparse_line, "%%name is deprecated. Use %%rename instead.\n"); 5221 Delete(yyrename); 5222 yyrename = NewString((yyvsp[(3) - (4)].id)); 5223 (yyval.node) = 0; 5224 } 5225 break; 5226 5227 case 70: 5228#line 2157 "parser.y" 5229 { 5230 Swig_warning(WARN_DEPRECATED_NAME,cparse_file,cparse_line, "%%name is deprecated. Use %%rename instead.\n"); 5231 (yyval.node) = 0; 5232 Swig_error(cparse_file,cparse_line,"Missing argument to %%name directive.\n"); 5233 } 5234 break; 5235 5236 case 71: 5237#line 2170 "parser.y" 5238 { 5239 (yyval.node) = new_node("native"); 5240 Setattr((yyval.node),"name",(yyvsp[(3) - (7)].id)); 5241 Setattr((yyval.node),"wrap:name",(yyvsp[(6) - (7)].id)); 5242 add_symbols((yyval.node)); 5243 } 5244 break; 5245 5246 case 72: 5247#line 2176 "parser.y" 5248 { 5249 if (!SwigType_isfunction((yyvsp[(7) - (8)].decl).type)) { 5250 Swig_error(cparse_file,cparse_line,"%%native declaration '%s' is not a function.\n", (yyvsp[(7) - (8)].decl).id); 5251 (yyval.node) = 0; 5252 } else { 5253 Delete(SwigType_pop_function((yyvsp[(7) - (8)].decl).type)); 5254 /* Need check for function here */ 5255 SwigType_push((yyvsp[(6) - (8)].type),(yyvsp[(7) - (8)].decl).type); 5256 (yyval.node) = new_node("native"); 5257 Setattr((yyval.node),"name",(yyvsp[(3) - (8)].id)); 5258 Setattr((yyval.node),"wrap:name",(yyvsp[(7) - (8)].decl).id); 5259 Setattr((yyval.node),"type",(yyvsp[(6) - (8)].type)); 5260 Setattr((yyval.node),"parms",(yyvsp[(7) - (8)].decl).parms); 5261 Setattr((yyval.node),"decl",(yyvsp[(7) - (8)].decl).type); 5262 } 5263 add_symbols((yyval.node)); 5264 } 5265 break; 5266 5267 case 73: 5268#line 2202 "parser.y" 5269 { 5270 (yyval.node) = new_node("pragma"); 5271 Setattr((yyval.node),"lang",(yyvsp[(2) - (5)].id)); 5272 Setattr((yyval.node),"name",(yyvsp[(3) - (5)].id)); 5273 Setattr((yyval.node),"value",(yyvsp[(5) - (5)].str)); 5274 } 5275 break; 5276 5277 case 74: 5278#line 2208 "parser.y" 5279 { 5280 (yyval.node) = new_node("pragma"); 5281 Setattr((yyval.node),"lang",(yyvsp[(2) - (3)].id)); 5282 Setattr((yyval.node),"name",(yyvsp[(3) - (3)].id)); 5283 } 5284 break; 5285 5286 case 75: 5287#line 2215 "parser.y" 5288 { (yyval.str) = NewString((yyvsp[(1) - (1)].id)); } 5289 break; 5290 5291 case 76: 5292#line 2216 "parser.y" 5293 { (yyval.str) = (yyvsp[(1) - (1)].str); } 5294 break; 5295 5296 case 77: 5297#line 2219 "parser.y" 5298 { (yyval.id) = (yyvsp[(2) - (3)].id); } 5299 break; 5300 5301 case 78: 5302#line 2220 "parser.y" 5303 { (yyval.id) = (char *) "swig"; } 5304 break; 5305 5306 case 79: 5307#line 2228 "parser.y" 5308 { 5309 SwigType *t = (yyvsp[(2) - (4)].decl).type; 5310 Hash *kws = NewHash(); 5311 String *fixname; 5312 fixname = feature_identifier_fix((yyvsp[(2) - (4)].decl).id); 5313 Setattr(kws,"name",(yyvsp[(3) - (4)].id)); 5314 if (!Len(t)) t = 0; 5315 /* Special declarator check */ 5316 if (t) { 5317 if (SwigType_isfunction(t)) { 5318 SwigType *decl = SwigType_pop_function(t); 5319 if (SwigType_ispointer(t)) { 5320 String *nname = NewStringf("*%s",fixname); 5321 if ((yyvsp[(1) - (4)].ivalue)) { 5322 Swig_name_rename_add(Namespaceprefix, nname,decl,kws,(yyvsp[(2) - (4)].decl).parms); 5323 } else { 5324 Swig_name_namewarn_add(Namespaceprefix,nname,decl,kws); 5325 } 5326 Delete(nname); 5327 } else { 5328 if ((yyvsp[(1) - (4)].ivalue)) { 5329 Swig_name_rename_add(Namespaceprefix,(fixname),decl,kws,(yyvsp[(2) - (4)].decl).parms); 5330 } else { 5331 Swig_name_namewarn_add(Namespaceprefix,(fixname),decl,kws); 5332 } 5333 } 5334 Delete(decl); 5335 } else if (SwigType_ispointer(t)) { 5336 String *nname = NewStringf("*%s",fixname); 5337 if ((yyvsp[(1) - (4)].ivalue)) { 5338 Swig_name_rename_add(Namespaceprefix,(nname),0,kws,(yyvsp[(2) - (4)].decl).parms); 5339 } else { 5340 Swig_name_namewarn_add(Namespaceprefix,(nname),0,kws); 5341 } 5342 Delete(nname); 5343 } 5344 } else { 5345 if ((yyvsp[(1) - (4)].ivalue)) { 5346 Swig_name_rename_add(Namespaceprefix,(fixname),0,kws,(yyvsp[(2) - (4)].decl).parms); 5347 } else { 5348 Swig_name_namewarn_add(Namespaceprefix,(fixname),0,kws); 5349 } 5350 } 5351 (yyval.node) = 0; 5352 scanner_clear_rename(); 5353 } 5354 break; 5355 5356 case 80: 5357#line 2274 "parser.y" 5358 { 5359 String *fixname; 5360 Hash *kws = (yyvsp[(3) - (7)].node); 5361 SwigType *t = (yyvsp[(5) - (7)].decl).type; 5362 fixname = feature_identifier_fix((yyvsp[(5) - (7)].decl).id); 5363 if (!Len(t)) t = 0; 5364 /* Special declarator check */ 5365 if (t) { 5366 if ((yyvsp[(6) - (7)].dtype).qualifier) SwigType_push(t,(yyvsp[(6) - (7)].dtype).qualifier); 5367 if (SwigType_isfunction(t)) { 5368 SwigType *decl = SwigType_pop_function(t); 5369 if (SwigType_ispointer(t)) { 5370 String *nname = NewStringf("*%s",fixname); 5371 if ((yyvsp[(1) - (7)].ivalue)) { 5372 Swig_name_rename_add(Namespaceprefix, nname,decl,kws,(yyvsp[(5) - (7)].decl).parms); 5373 } else { 5374 Swig_name_namewarn_add(Namespaceprefix,nname,decl,kws); 5375 } 5376 Delete(nname); 5377 } else { 5378 if ((yyvsp[(1) - (7)].ivalue)) { 5379 Swig_name_rename_add(Namespaceprefix,(fixname),decl,kws,(yyvsp[(5) - (7)].decl).parms); 5380 } else { 5381 Swig_name_namewarn_add(Namespaceprefix,(fixname),decl,kws); 5382 } 5383 } 5384 Delete(decl); 5385 } else if (SwigType_ispointer(t)) { 5386 String *nname = NewStringf("*%s",fixname); 5387 if ((yyvsp[(1) - (7)].ivalue)) { 5388 Swig_name_rename_add(Namespaceprefix,(nname),0,kws,(yyvsp[(5) - (7)].decl).parms); 5389 } else { 5390 Swig_name_namewarn_add(Namespaceprefix,(nname),0,kws); 5391 } 5392 Delete(nname); 5393 } 5394 } else { 5395 if ((yyvsp[(1) - (7)].ivalue)) { 5396 Swig_name_rename_add(Namespaceprefix,(fixname),0,kws,(yyvsp[(5) - (7)].decl).parms); 5397 } else { 5398 Swig_name_namewarn_add(Namespaceprefix,(fixname),0,kws); 5399 } 5400 } 5401 (yyval.node) = 0; 5402 scanner_clear_rename(); 5403 } 5404 break; 5405 5406 case 81: 5407#line 2320 "parser.y" 5408 { 5409 if ((yyvsp[(1) - (6)].ivalue)) { 5410 Swig_name_rename_add(Namespaceprefix,(yyvsp[(5) - (6)].id),0,(yyvsp[(3) - (6)].node),0); 5411 } else { 5412 Swig_name_namewarn_add(Namespaceprefix,(yyvsp[(5) - (6)].id),0,(yyvsp[(3) - (6)].node)); 5413 } 5414 (yyval.node) = 0; 5415 scanner_clear_rename(); 5416 } 5417 break; 5418 5419 case 82: 5420#line 2331 "parser.y" 5421 { 5422 (yyval.ivalue) = 1; 5423 } 5424 break; 5425 5426 case 83: 5427#line 2334 "parser.y" 5428 { 5429 (yyval.ivalue) = 0; 5430 } 5431 break; 5432 5433 case 84: 5434#line 2361 "parser.y" 5435 { 5436 String *val = (yyvsp[(7) - (7)].str) ? NewString((yyvsp[(7) - (7)].str)) : NewString("1"); 5437 new_feature((yyvsp[(3) - (7)].id), val, 0, (yyvsp[(5) - (7)].decl).id, (yyvsp[(5) - (7)].decl).type, (yyvsp[(5) - (7)].decl).parms, (yyvsp[(6) - (7)].dtype).qualifier); 5438 (yyval.node) = 0; 5439 scanner_clear_rename(); 5440 } 5441 break; 5442 5443 case 85: 5444#line 2367 "parser.y" 5445 { 5446 String *val = Len((yyvsp[(5) - (9)].id)) ? NewString((yyvsp[(5) - (9)].id)) : 0; 5447 new_feature((yyvsp[(3) - (9)].id), val, 0, (yyvsp[(7) - (9)].decl).id, (yyvsp[(7) - (9)].decl).type, (yyvsp[(7) - (9)].decl).parms, (yyvsp[(8) - (9)].dtype).qualifier); 5448 (yyval.node) = 0; 5449 scanner_clear_rename(); 5450 } 5451 break; 5452 5453 case 86: 5454#line 2373 "parser.y" 5455 { 5456 String *val = (yyvsp[(8) - (8)].str) ? NewString((yyvsp[(8) - (8)].str)) : NewString("1"); 5457 new_feature((yyvsp[(3) - (8)].id), val, (yyvsp[(4) - (8)].node), (yyvsp[(6) - (8)].decl).id, (yyvsp[(6) - (8)].decl).type, (yyvsp[(6) - (8)].decl).parms, (yyvsp[(7) - (8)].dtype).qualifier); 5458 (yyval.node) = 0; 5459 scanner_clear_rename(); 5460 } 5461 break; 5462 5463 case 87: 5464#line 2379 "parser.y" 5465 { 5466 String *val = Len((yyvsp[(5) - (10)].id)) ? NewString((yyvsp[(5) - (10)].id)) : 0; 5467 new_feature((yyvsp[(3) - (10)].id), val, (yyvsp[(6) - (10)].node), (yyvsp[(8) - (10)].decl).id, (yyvsp[(8) - (10)].decl).type, (yyvsp[(8) - (10)].decl).parms, (yyvsp[(9) - (10)].dtype).qualifier); 5468 (yyval.node) = 0; 5469 scanner_clear_rename(); 5470 } 5471 break; 5472 5473 case 88: 5474#line 2387 "parser.y" 5475 { 5476 String *val = (yyvsp[(5) - (5)].str) ? NewString((yyvsp[(5) - (5)].str)) : NewString("1"); 5477 new_feature((yyvsp[(3) - (5)].id), val, 0, 0, 0, 0, 0); 5478 (yyval.node) = 0; 5479 scanner_clear_rename(); 5480 } 5481 break; 5482 5483 case 89: 5484#line 2393 "parser.y" 5485 { 5486 String *val = Len((yyvsp[(5) - (7)].id)) ? NewString((yyvsp[(5) - (7)].id)) : 0; 5487 new_feature((yyvsp[(3) - (7)].id), val, 0, 0, 0, 0, 0); 5488 (yyval.node) = 0; 5489 scanner_clear_rename(); 5490 } 5491 break; 5492 5493 case 90: 5494#line 2399 "parser.y" 5495 { 5496 String *val = (yyvsp[(6) - (6)].str) ? NewString((yyvsp[(6) - (6)].str)) : NewString("1"); 5497 new_feature((yyvsp[(3) - (6)].id), val, (yyvsp[(4) - (6)].node), 0, 0, 0, 0); 5498 (yyval.node) = 0; 5499 scanner_clear_rename(); 5500 } 5501 break; 5502 5503 case 91: 5504#line 2405 "parser.y" 5505 { 5506 String *val = Len((yyvsp[(5) - (8)].id)) ? NewString((yyvsp[(5) - (8)].id)) : 0; 5507 new_feature((yyvsp[(3) - (8)].id), val, (yyvsp[(6) - (8)].node), 0, 0, 0, 0); 5508 (yyval.node) = 0; 5509 scanner_clear_rename(); 5510 } 5511 break; 5512 5513 case 92: 5514#line 2413 "parser.y" 5515 { (yyval.str) = (yyvsp[(1) - (1)].str); } 5516 break; 5517 5518 case 93: 5519#line 2414 "parser.y" 5520 { (yyval.str) = 0; } 5521 break; 5522 5523 case 94: 5524#line 2415 "parser.y" 5525 { (yyval.str) = (yyvsp[(3) - (5)].pl); } 5526 break; 5527 5528 case 95: 5529#line 2418 "parser.y" 5530 { 5531 (yyval.node) = NewHash(); 5532 Setattr((yyval.node),"name",(yyvsp[(2) - (4)].id)); 5533 Setattr((yyval.node),"value",(yyvsp[(4) - (4)].id)); 5534 } 5535 break; 5536 5537 case 96: 5538#line 2423 "parser.y" 5539 { 5540 (yyval.node) = NewHash(); 5541 Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id)); 5542 Setattr((yyval.node),"value",(yyvsp[(4) - (5)].id)); 5543 set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node)); 5544 } 5545 break; 5546 5547 case 97: 5548#line 2433 "parser.y" 5549 { 5550 Parm *val; 5551 String *name; 5552 SwigType *t; 5553 if (Namespaceprefix) name = NewStringf("%s::%s", Namespaceprefix, (yyvsp[(5) - (7)].decl).id); 5554 else name = NewString((yyvsp[(5) - (7)].decl).id); 5555 val = (yyvsp[(3) - (7)].pl); 5556 if ((yyvsp[(5) - (7)].decl).parms) { 5557 Setmeta(val,"parms",(yyvsp[(5) - (7)].decl).parms); 5558 } 5559 t = (yyvsp[(5) - (7)].decl).type; 5560 if (!Len(t)) t = 0; 5561 if (t) { 5562 if ((yyvsp[(6) - (7)].dtype).qualifier) SwigType_push(t,(yyvsp[(6) - (7)].dtype).qualifier); 5563 if (SwigType_isfunction(t)) { 5564 SwigType *decl = SwigType_pop_function(t); 5565 if (SwigType_ispointer(t)) { 5566 String *nname = NewStringf("*%s",name); 5567 Swig_feature_set(Swig_cparse_features(), nname, decl, "feature:varargs", val, 0); 5568 Delete(nname); 5569 } else { 5570 Swig_feature_set(Swig_cparse_features(), name, decl, "feature:varargs", val, 0); 5571 } 5572 Delete(decl); 5573 } else if (SwigType_ispointer(t)) { 5574 String *nname = NewStringf("*%s",name); 5575 Swig_feature_set(Swig_cparse_features(),nname,0,"feature:varargs",val, 0); 5576 Delete(nname); 5577 } 5578 } else { 5579 Swig_feature_set(Swig_cparse_features(),name,0,"feature:varargs",val, 0); 5580 } 5581 Delete(name); 5582 (yyval.node) = 0; 5583 } 5584 break; 5585 5586 case 98: 5587#line 2469 "parser.y" 5588 { (yyval.pl) = (yyvsp[(1) - (1)].pl); } 5589 break; 5590 5591 case 99: 5592#line 2470 "parser.y" 5593 { 5594 int i; 5595 int n; 5596 Parm *p; 5597 n = atoi(Char((yyvsp[(1) - (3)].dtype).val)); 5598 if (n <= 0) { 5599 Swig_error(cparse_file, cparse_line,"Argument count in %%varargs must be positive.\n"); 5600 (yyval.pl) = 0; 5601 } else { 5602 (yyval.pl) = Copy((yyvsp[(3) - (3)].p)); 5603 Setattr((yyval.pl),"name","VARARGS_SENTINEL"); 5604 for (i = 0; i < n; i++) { 5605 p = Copy((yyvsp[(3) - (3)].p)); 5606 set_nextSibling(p,(yyval.pl)); 5607 Delete((yyval.pl)); 5608 (yyval.pl) = p; 5609 } 5610 } 5611 } 5612 break; 5613 5614 case 100: 5615#line 2500 "parser.y" 5616 { 5617 (yyval.node) = 0; 5618 if ((yyvsp[(3) - (6)].tmap).method) { 5619 String *code = 0; 5620 (yyval.node) = new_node("typemap"); 5621 Setattr((yyval.node),"method",(yyvsp[(3) - (6)].tmap).method); 5622 if ((yyvsp[(3) - (6)].tmap).kwargs) { 5623 ParmList *kw = (yyvsp[(3) - (6)].tmap).kwargs; 5624 code = remove_block(kw, (yyvsp[(6) - (6)].str)); 5625 Setattr((yyval.node),"kwargs", (yyvsp[(3) - (6)].tmap).kwargs); 5626 } 5627 code = code ? code : NewString((yyvsp[(6) - (6)].str)); 5628 Setattr((yyval.node),"code", code); 5629 Delete(code); 5630 appendChild((yyval.node),(yyvsp[(5) - (6)].p)); 5631 } 5632 } 5633 break; 5634 5635 case 101: 5636#line 2517 "parser.y" 5637 { 5638 (yyval.node) = 0; 5639 if ((yyvsp[(3) - (6)].tmap).method) { 5640 (yyval.node) = new_node("typemap"); 5641 Setattr((yyval.node),"method",(yyvsp[(3) - (6)].tmap).method); 5642 appendChild((yyval.node),(yyvsp[(5) - (6)].p)); 5643 } 5644 } 5645 break; 5646 5647 case 102: 5648#line 2525 "parser.y" 5649 { 5650 (yyval.node) = 0; 5651 if ((yyvsp[(3) - (8)].tmap).method) { 5652 (yyval.node) = new_node("typemapcopy"); 5653 Setattr((yyval.node),"method",(yyvsp[(3) - (8)].tmap).method); 5654 Setattr((yyval.node),"pattern", Getattr((yyvsp[(7) - (8)].p),"pattern")); 5655 appendChild((yyval.node),(yyvsp[(5) - (8)].p)); 5656 } 5657 } 5658 break; 5659 5660 case 103: 5661#line 2538 "parser.y" 5662 { 5663 Hash *p; 5664 String *name; 5665 p = nextSibling((yyvsp[(1) - (1)].node)); 5666 if (p && (!Getattr(p,"value"))) { 5667 /* this is the deprecated two argument typemap form */ 5668 Swig_warning(WARN_DEPRECATED_TYPEMAP_LANG,cparse_file, cparse_line, 5669 "Specifying the language name in %%typemap is deprecated - use #ifdef SWIG<LANG> instead.\n"); 5670 /* two argument typemap form */ 5671 name = Getattr((yyvsp[(1) - (1)].node),"name"); 5672 if (!name || (Strcmp(name,typemap_lang))) { 5673 (yyval.tmap).method = 0; 5674 (yyval.tmap).kwargs = 0; 5675 } else { 5676 (yyval.tmap).method = Getattr(p,"name"); 5677 (yyval.tmap).kwargs = nextSibling(p); 5678 } 5679 } else { 5680 /* one-argument typemap-form */ 5681 (yyval.tmap).method = Getattr((yyvsp[(1) - (1)].node),"name"); 5682 (yyval.tmap).kwargs = p; 5683 } 5684 } 5685 break; 5686 5687 case 104: 5688#line 2563 "parser.y" 5689 { 5690 (yyval.p) = (yyvsp[(1) - (2)].p); 5691 set_nextSibling((yyval.p),(yyvsp[(2) - (2)].p)); 5692 } 5693 break; 5694 5695 case 105: 5696#line 2569 "parser.y" 5697 { 5698 (yyval.p) = (yyvsp[(2) - (3)].p); 5699 set_nextSibling((yyval.p),(yyvsp[(3) - (3)].p)); 5700 } 5701 break; 5702 5703 case 106: 5704#line 2573 "parser.y" 5705 { (yyval.p) = 0;} 5706 break; 5707 5708 case 107: 5709#line 2576 "parser.y" 5710 { 5711 Parm *parm; 5712 SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type); 5713 (yyval.p) = new_node("typemapitem"); 5714 parm = NewParm((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).id); 5715 Setattr((yyval.p),"pattern",parm); 5716 Setattr((yyval.p),"parms", (yyvsp[(2) - (2)].decl).parms); 5717 Delete(parm); 5718 /* $$ = NewParm($1,$2.id); 5719 Setattr($$,"parms",$2.parms); */ 5720 } 5721 break; 5722 5723 case 108: 5724#line 2587 "parser.y" 5725 { 5726 (yyval.p) = new_node("typemapitem"); 5727 Setattr((yyval.p),"pattern",(yyvsp[(2) - (3)].pl)); 5728 /* Setattr($$,"multitype",$2); */ 5729 } 5730 break; 5731 5732 case 109: 5733#line 2592 "parser.y" 5734 { 5735 (yyval.p) = new_node("typemapitem"); 5736 Setattr((yyval.p),"pattern", (yyvsp[(2) - (6)].pl)); 5737 /* Setattr($$,"multitype",$2); */ 5738 Setattr((yyval.p),"parms",(yyvsp[(5) - (6)].pl)); 5739 } 5740 break; 5741 5742 case 110: 5743#line 2605 "parser.y" 5744 { 5745 (yyval.node) = new_node("types"); 5746 Setattr((yyval.node),"parms",(yyvsp[(3) - (5)].pl)); 5747 if ((yyvsp[(5) - (5)].str)) 5748 Setattr((yyval.node),"convcode",NewString((yyvsp[(5) - (5)].str))); 5749 } 5750 break; 5751 5752 case 111: 5753#line 2617 "parser.y" 5754 { 5755 Parm *p, *tp; 5756 Node *n; 5757 Node *tnode = 0; 5758 Symtab *tscope = 0; 5759 int specialized = 0; 5760 5761 (yyval.node) = 0; 5762 5763 tscope = Swig_symbol_current(); /* Get the current scope */ 5764 5765 /* If the class name is qualified, we need to create or lookup namespace entries */ 5766 if (!inclass) { 5767 (yyvsp[(5) - (9)].str) = resolve_node_scope((yyvsp[(5) - (9)].str)); 5768 } 5769 5770 /* 5771 We use the new namespace entry 'nscope' only to 5772 emit the template node. The template parameters are 5773 resolved in the current 'tscope'. 5774 5775 This is closer to the C++ (typedef) behavior. 5776 */ 5777 n = Swig_cparse_template_locate((yyvsp[(5) - (9)].str),(yyvsp[(7) - (9)].p),tscope); 5778 5779 /* Patch the argument types to respect namespaces */ 5780 p = (yyvsp[(7) - (9)].p); 5781 while (p) { 5782 SwigType *value = Getattr(p,"value"); 5783 if (!value) { 5784 SwigType *ty = Getattr(p,"type"); 5785 if (ty) { 5786 SwigType *rty = 0; 5787 int reduce = template_reduce; 5788 if (reduce || !SwigType_ispointer(ty)) { 5789 rty = Swig_symbol_typedef_reduce(ty,tscope); 5790 if (!reduce) reduce = SwigType_ispointer(rty); 5791 } 5792 ty = reduce ? Swig_symbol_type_qualify(rty,tscope) : Swig_symbol_type_qualify(ty,tscope); 5793 Setattr(p,"type",ty); 5794 Delete(ty); 5795 Delete(rty); 5796 } 5797 } else { 5798 value = Swig_symbol_type_qualify(value,tscope); 5799 Setattr(p,"value",value); 5800 Delete(value); 5801 } 5802 5803 p = nextSibling(p); 5804 } 5805 5806 /* Look for the template */ 5807 { 5808 Node *nn = n; 5809 Node *linklistend = 0; 5810 while (nn) { 5811 Node *templnode = 0; 5812 if (Strcmp(nodeType(nn),"template") == 0) { 5813 int nnisclass = (Strcmp(Getattr(nn,"templatetype"),"class") == 0); /* if not a templated class it is a templated function */ 5814 Parm *tparms = Getattr(nn,"templateparms"); 5815 if (!tparms) { 5816 specialized = 1; 5817 } 5818 if (nnisclass && !specialized && ((ParmList_len((yyvsp[(7) - (9)].p)) > ParmList_len(tparms)))) { 5819 Swig_error(cparse_file, cparse_line, "Too many template parameters. Maximum of %d.\n", ParmList_len(tparms)); 5820 } else if (nnisclass && !specialized && ((ParmList_len((yyvsp[(7) - (9)].p)) < ParmList_numrequired(tparms)))) { 5821 Swig_error(cparse_file, cparse_line, "Not enough template parameters specified. %d required.\n", ParmList_numrequired(tparms)); 5822 } else if (!nnisclass && ((ParmList_len((yyvsp[(7) - (9)].p)) != ParmList_len(tparms)))) { 5823 /* must be an overloaded templated method - ignore it as it is overloaded with a different number of template parameters */ 5824 nn = Getattr(nn,"sym:nextSibling"); /* repeat for overloaded templated functions */ 5825 continue; 5826 } else { 5827 String *tname = Copy((yyvsp[(5) - (9)].str)); 5828 int def_supplied = 0; 5829 /* Expand the template */ 5830 Node *templ = Swig_symbol_clookup((yyvsp[(5) - (9)].str),0); 5831 Parm *targs = templ ? Getattr(templ,"templateparms") : 0; 5832 5833 ParmList *temparms; 5834 if (specialized) temparms = CopyParmList((yyvsp[(7) - (9)].p)); 5835 else temparms = CopyParmList(tparms); 5836 5837 /* Create typedef's and arguments */ 5838 p = (yyvsp[(7) - (9)].p); 5839 tp = temparms; 5840 if (!p && ParmList_len(p) != ParmList_len(temparms)) { 5841 /* we have no template parameters supplied in %template for a template that has default args*/ 5842 p = tp; 5843 def_supplied = 1; 5844 } 5845 5846 while (p) { 5847 String *value = Getattr(p,"value"); 5848 if (def_supplied) { 5849 Setattr(p,"default","1"); 5850 } 5851 if (value) { 5852 Setattr(tp,"value",value); 5853 } else { 5854 SwigType *ty = Getattr(p,"type"); 5855 if (ty) { 5856 Setattr(tp,"type",ty); 5857 } 5858 Delattr(tp,"value"); 5859 } 5860 /* fix default arg values */ 5861 if (targs) { 5862 Parm *pi = temparms; 5863 Parm *ti = targs; 5864 String *tv = Getattr(tp,"value"); 5865 if (!tv) tv = Getattr(tp,"type"); 5866 while(pi != tp && ti && pi) { 5867 String *name = Getattr(ti,"name"); 5868 String *value = Getattr(pi,"value"); 5869 if (!value) value = Getattr(pi,"type"); 5870 Replaceid(tv, name, value); 5871 pi = nextSibling(pi); 5872 ti = nextSibling(ti); 5873 } 5874 } 5875 p = nextSibling(p); 5876 tp = nextSibling(tp); 5877 if (!p && tp) { 5878 p = tp; 5879 def_supplied = 1; 5880 } 5881 } 5882 5883 templnode = copy_node(nn); 5884 /* We need to set the node name based on name used to instantiate */ 5885 Setattr(templnode,"name",tname); 5886 Delete(tname); 5887 if (!specialized) { 5888 Delattr(templnode,"sym:typename"); 5889 } else { 5890 Setattr(templnode,"sym:typename","1"); 5891 } 5892 if ((yyvsp[(3) - (9)].id)) { 5893 /* 5894 Comment this out for 1.3.28. We need to 5895 re-enable it later but first we need to 5896 move %ignore from using %rename to use 5897 %feature(ignore). 5898 5899 String *symname = Swig_name_make(templnode,0,$3,0,0); 5900 */ 5901 String *symname = (yyvsp[(3) - (9)].id); 5902 Swig_cparse_template_expand(templnode,symname,temparms,tscope); 5903 Setattr(templnode,"sym:name",symname); 5904 } else { 5905 static int cnt = 0; 5906 String *nname = NewStringf("__dummy_%d__", cnt++); 5907 Swig_cparse_template_expand(templnode,nname,temparms,tscope); 5908 Setattr(templnode,"sym:name",nname); 5909 Delete(nname); 5910 Setattr(templnode,"feature:onlychildren", 5911 "typemap,typemapitem,typemapcopy,typedef,types,fragment"); 5912 } 5913 Delattr(templnode,"templatetype"); 5914 Setattr(templnode,"template",nn); 5915 tnode = templnode; 5916 Setfile(templnode,cparse_file); 5917 Setline(templnode,cparse_line); 5918 Delete(temparms); 5919 5920 add_symbols_copy(templnode); 5921 5922 if (Strcmp(nodeType(templnode),"class") == 0) { 5923 5924 /* Identify pure abstract methods */ 5925 Setattr(templnode,"abstract", pure_abstract(firstChild(templnode))); 5926 5927 /* Set up inheritance in symbol table */ 5928 { 5929 Symtab *csyms; 5930 List *baselist = Getattr(templnode,"baselist"); 5931 csyms = Swig_symbol_current(); 5932 Swig_symbol_setscope(Getattr(templnode,"symtab")); 5933 if (baselist) { 5934 List *bases = make_inherit_list(Getattr(templnode,"name"),baselist); 5935 if (bases) { 5936 Iterator s; 5937 for (s = First(bases); s.item; s = Next(s)) { 5938 Symtab *st = Getattr(s.item,"symtab"); 5939 if (st) { 5940 Setfile(st,Getfile(s.item)); 5941 Setline(st,Getline(s.item)); 5942 Swig_symbol_inherit(st); 5943 } 5944 } 5945 Delete(bases); 5946 } 5947 } 5948 Swig_symbol_setscope(csyms); 5949 } 5950 5951 /* Merge in addmethods for this class */ 5952 5953 /* !!! This may be broken. We may have to add the 5954 addmethods at the beginning of the class */ 5955 5956 if (extendhash) { 5957 String *stmp = 0; 5958 String *clsname; 5959 Node *am; 5960 if (Namespaceprefix) { 5961 clsname = stmp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name")); 5962 } else { 5963 clsname = Getattr(templnode,"name"); 5964 } 5965 am = Getattr(extendhash,clsname); 5966 if (am) { 5967 Symtab *st = Swig_symbol_current(); 5968 Swig_symbol_setscope(Getattr(templnode,"symtab")); 5969 /* Printf(stdout,"%s: %s %x %x\n", Getattr(templnode,"name"), clsname, Swig_symbol_current(), Getattr(templnode,"symtab")); */ 5970 merge_extensions(templnode,am); 5971 Swig_symbol_setscope(st); 5972 append_previous_extension(templnode,am); 5973 Delattr(extendhash,clsname); 5974 } 5975 if (stmp) Delete(stmp); 5976 } 5977 /* Add to classes hash */ 5978 if (!classes) classes = NewHash(); 5979 5980 { 5981 if (Namespaceprefix) { 5982 String *temp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name")); 5983 Setattr(classes,temp,templnode); 5984 Delete(temp); 5985 } else { 5986 String *qs = Swig_symbol_qualifiedscopename(templnode); 5987 Setattr(classes, qs,templnode); 5988 Delete(qs); 5989 } 5990 } 5991 } 5992 } 5993 5994 /* all the overloaded templated functions are added into a linked list */ 5995 if (nscope_inner) { 5996 /* non-global namespace */ 5997 if (templnode) { 5998 appendChild(nscope_inner,templnode); 5999 Delete(templnode); 6000 if (nscope) (yyval.node) = nscope; 6001 } 6002 } else { 6003 /* global namespace */ 6004 if (!linklistend) { 6005 (yyval.node) = templnode; 6006 } else { 6007 set_nextSibling(linklistend,templnode); 6008 Delete(templnode); 6009 } 6010 linklistend = templnode; 6011 } 6012 } 6013 nn = Getattr(nn,"sym:nextSibling"); /* repeat for overloaded templated functions. If a templated class there will never be a sibling. */ 6014 } 6015 } 6016 Swig_symbol_setscope(tscope); 6017 Delete(Namespaceprefix); 6018 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 6019 } 6020 break; 6021 6022 case 112: 6023#line 2890 "parser.y" 6024 { 6025 Swig_warning(0,cparse_file, cparse_line,"%s\n", (yyvsp[(2) - (2)].id)); 6026 (yyval.node) = 0; 6027 } 6028 break; 6029 6030 case 113: 6031#line 2900 "parser.y" 6032 { 6033 (yyval.node) = (yyvsp[(1) - (1)].node); 6034 if ((yyval.node)) { 6035 add_symbols((yyval.node)); 6036 default_arguments((yyval.node)); 6037 } 6038 } 6039 break; 6040 6041 case 114: 6042#line 2907 "parser.y" 6043 { (yyval.node) = (yyvsp[(1) - (1)].node); } 6044 break; 6045 6046 case 115: 6047#line 2908 "parser.y" 6048 { (yyval.node) = (yyvsp[(1) - (1)].node); } 6049 break; 6050 6051 case 116: 6052#line 2912 "parser.y" 6053 { 6054 if (Strcmp((yyvsp[(2) - (3)].id),"C") == 0) { 6055 cparse_externc = 1; 6056 } 6057 } 6058 break; 6059 6060 case 117: 6061#line 2916 "parser.y" 6062 { 6063 cparse_externc = 0; 6064 if (Strcmp((yyvsp[(2) - (6)].id),"C") == 0) { 6065 Node *n = firstChild((yyvsp[(5) - (6)].node)); 6066 (yyval.node) = new_node("extern"); 6067 Setattr((yyval.node),"name",(yyvsp[(2) - (6)].id)); 6068 appendChild((yyval.node),n); 6069 while (n) { 6070 SwigType *decl = Getattr(n,"decl"); 6071 if (SwigType_isfunction(decl)) { 6072 Setattr(n,"storage","externc"); 6073 } 6074 n = nextSibling(n); 6075 } 6076 } else { 6077 Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", (yyvsp[(2) - (6)].id)); 6078 (yyval.node) = new_node("extern"); 6079 Setattr((yyval.node),"name",(yyvsp[(2) - (6)].id)); 6080 appendChild((yyval.node),firstChild((yyvsp[(5) - (6)].node))); 6081 } 6082 } 6083 break; 6084 6085 case 118: 6086#line 2943 "parser.y" 6087 { 6088 (yyval.node) = new_node("cdecl"); 6089 if ((yyvsp[(4) - (5)].dtype).qualifier) SwigType_push((yyvsp[(3) - (5)].decl).type,(yyvsp[(4) - (5)].dtype).qualifier); 6090 Setattr((yyval.node),"type",(yyvsp[(2) - (5)].type)); 6091 Setattr((yyval.node),"storage",(yyvsp[(1) - (5)].id)); 6092 Setattr((yyval.node),"name",(yyvsp[(3) - (5)].decl).id); 6093 Setattr((yyval.node),"decl",(yyvsp[(3) - (5)].decl).type); 6094 Setattr((yyval.node),"parms",(yyvsp[(3) - (5)].decl).parms); 6095 Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val); 6096 Setattr((yyval.node),"throws",(yyvsp[(4) - (5)].dtype).throws); 6097 Setattr((yyval.node),"throw",(yyvsp[(4) - (5)].dtype).throwf); 6098 if (!(yyvsp[(5) - (5)].node)) { 6099 if (Len(scanner_ccode)) { 6100 String *code = Copy(scanner_ccode); 6101 Setattr((yyval.node),"code",code); 6102 Delete(code); 6103 } 6104 } else { 6105 Node *n = (yyvsp[(5) - (5)].node); 6106 /* Inherit attributes */ 6107 while (n) { 6108 String *type = Copy((yyvsp[(2) - (5)].type)); 6109 Setattr(n,"type",type); 6110 Setattr(n,"storage",(yyvsp[(1) - (5)].id)); 6111 n = nextSibling(n); 6112 Delete(type); 6113 } 6114 } 6115 if ((yyvsp[(4) - (5)].dtype).bitfield) { 6116 Setattr((yyval.node),"bitfield", (yyvsp[(4) - (5)].dtype).bitfield); 6117 } 6118 6119 /* Look for "::" declarations (ignored) */ 6120 if (Strstr((yyvsp[(3) - (5)].decl).id,"::")) { 6121 /* This is a special case. If the scope name of the declaration exactly 6122 matches that of the declaration, then we will allow it. Otherwise, delete. */ 6123 String *p = Swig_scopename_prefix((yyvsp[(3) - (5)].decl).id); 6124 if (p) { 6125 if ((Namespaceprefix && Strcmp(p,Namespaceprefix) == 0) || 6126 (inclass && Strcmp(p,Classprefix) == 0)) { 6127 String *lstr = Swig_scopename_last((yyvsp[(3) - (5)].decl).id); 6128 Setattr((yyval.node),"name",lstr); 6129 Delete(lstr); 6130 set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node)); 6131 } else { 6132 Delete((yyval.node)); 6133 (yyval.node) = (yyvsp[(5) - (5)].node); 6134 } 6135 Delete(p); 6136 } else { 6137 Delete((yyval.node)); 6138 (yyval.node) = (yyvsp[(5) - (5)].node); 6139 } 6140 } else { 6141 set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node)); 6142 } 6143 } 6144 break; 6145 6146 case 119: 6147#line 3004 "parser.y" 6148 { 6149 (yyval.node) = 0; 6150 Clear(scanner_ccode); 6151 } 6152 break; 6153 6154 case 120: 6155#line 3008 "parser.y" 6156 { 6157 (yyval.node) = new_node("cdecl"); 6158 if ((yyvsp[(3) - (4)].dtype).qualifier) SwigType_push((yyvsp[(2) - (4)].decl).type,(yyvsp[(3) - (4)].dtype).qualifier); 6159 Setattr((yyval.node),"name",(yyvsp[(2) - (4)].decl).id); 6160 Setattr((yyval.node),"decl",(yyvsp[(2) - (4)].decl).type); 6161 Setattr((yyval.node),"parms",(yyvsp[(2) - (4)].decl).parms); 6162 Setattr((yyval.node),"value",(yyvsp[(3) - (4)].dtype).val); 6163 Setattr((yyval.node),"throws",(yyvsp[(3) - (4)].dtype).throws); 6164 Setattr((yyval.node),"throw",(yyvsp[(3) - (4)].dtype).throwf); 6165 if ((yyvsp[(3) - (4)].dtype).bitfield) { 6166 Setattr((yyval.node),"bitfield", (yyvsp[(3) - (4)].dtype).bitfield); 6167 } 6168 if (!(yyvsp[(4) - (4)].node)) { 6169 if (Len(scanner_ccode)) { 6170 String *code = Copy(scanner_ccode); 6171 Setattr((yyval.node),"code",code); 6172 Delete(code); 6173 } 6174 } else { 6175 set_nextSibling((yyval.node),(yyvsp[(4) - (4)].node)); 6176 } 6177 } 6178 break; 6179 6180 case 121: 6181#line 3030 "parser.y" 6182 { 6183 skip_balanced('{','}'); 6184 (yyval.node) = 0; 6185 } 6186 break; 6187 6188 case 122: 6189#line 3036 "parser.y" 6190 { 6191 (yyval.dtype) = (yyvsp[(1) - (1)].dtype); 6192 (yyval.dtype).qualifier = 0; 6193 (yyval.dtype).throws = 0; 6194 (yyval.dtype).throwf = 0; 6195 } 6196 break; 6197 6198 case 123: 6199#line 3042 "parser.y" 6200 { 6201 (yyval.dtype) = (yyvsp[(2) - (2)].dtype); 6202 (yyval.dtype).qualifier = (yyvsp[(1) - (2)].str); 6203 (yyval.dtype).throws = 0; 6204 (yyval.dtype).throwf = 0; 6205 } 6206 break; 6207 6208 case 124: 6209#line 3048 "parser.y" 6210 { 6211 (yyval.dtype) = (yyvsp[(5) - (5)].dtype); 6212 (yyval.dtype).qualifier = 0; 6213 (yyval.dtype).throws = (yyvsp[(3) - (5)].pl); 6214 (yyval.dtype).throwf = NewString("1"); 6215 } 6216 break; 6217 6218 case 125: 6219#line 3054 "parser.y" 6220 { 6221 (yyval.dtype) = (yyvsp[(6) - (6)].dtype); 6222 (yyval.dtype).qualifier = (yyvsp[(1) - (6)].str); 6223 (yyval.dtype).throws = (yyvsp[(4) - (6)].pl); 6224 (yyval.dtype).throwf = NewString("1"); 6225 } 6226 break; 6227 6228 case 126: 6229#line 3067 "parser.y" 6230 { 6231 SwigType *ty = 0; 6232 (yyval.node) = new_node("enumforward"); 6233 ty = NewStringf("enum %s", (yyvsp[(3) - (4)].id)); 6234 Setattr((yyval.node),"name",(yyvsp[(3) - (4)].id)); 6235 Setattr((yyval.node),"type",ty); 6236 Setattr((yyval.node),"sym:weak", "1"); 6237 add_symbols((yyval.node)); 6238 } 6239 break; 6240 6241 case 127: 6242#line 3082 "parser.y" 6243 { 6244 SwigType *ty = 0; 6245 (yyval.node) = new_node("enum"); 6246 ty = NewStringf("enum %s", (yyvsp[(3) - (7)].id)); 6247 Setattr((yyval.node),"name",(yyvsp[(3) - (7)].id)); 6248 Setattr((yyval.node),"type",ty); 6249 appendChild((yyval.node),(yyvsp[(5) - (7)].node)); 6250 add_symbols((yyval.node)); /* Add to tag space */ 6251 add_symbols((yyvsp[(5) - (7)].node)); /* Add enum values to id space */ 6252 } 6253 break; 6254 6255 case 128: 6256#line 3092 "parser.y" 6257 { 6258 Node *n; 6259 SwigType *ty = 0; 6260 String *unnamed = 0; 6261 int unnamedinstance = 0; 6262 6263 (yyval.node) = new_node("enum"); 6264 if ((yyvsp[(3) - (8)].id)) { 6265 Setattr((yyval.node),"name",(yyvsp[(3) - (8)].id)); 6266 ty = NewStringf("enum %s", (yyvsp[(3) - (8)].id)); 6267 } else if ((yyvsp[(7) - (8)].decl).id) { 6268 unnamed = make_unnamed(); 6269 ty = NewStringf("enum %s", unnamed); 6270 Setattr((yyval.node),"unnamed",unnamed); 6271 /* name is not set for unnamed enum instances, e.g. enum { foo } Instance; */ 6272 if ((yyvsp[(1) - (8)].id) && Cmp((yyvsp[(1) - (8)].id),"typedef") == 0) { 6273 Setattr((yyval.node),"name",(yyvsp[(7) - (8)].decl).id); 6274 } else { 6275 unnamedinstance = 1; 6276 } 6277 Setattr((yyval.node),"storage",(yyvsp[(1) - (8)].id)); 6278 } 6279 if ((yyvsp[(7) - (8)].decl).id && Cmp((yyvsp[(1) - (8)].id),"typedef") == 0) { 6280 Setattr((yyval.node),"tdname",(yyvsp[(7) - (8)].decl).id); 6281 Setattr((yyval.node),"allows_typedef","1"); 6282 } 6283 appendChild((yyval.node),(yyvsp[(5) - (8)].node)); 6284 n = new_node("cdecl"); 6285 Setattr(n,"type",ty); 6286 Setattr(n,"name",(yyvsp[(7) - (8)].decl).id); 6287 Setattr(n,"storage",(yyvsp[(1) - (8)].id)); 6288 Setattr(n,"decl",(yyvsp[(7) - (8)].decl).type); 6289 Setattr(n,"parms",(yyvsp[(7) - (8)].decl).parms); 6290 Setattr(n,"unnamed",unnamed); 6291 6292 if (unnamedinstance) { 6293 SwigType *cty = NewString("enum "); 6294 Setattr((yyval.node),"type",cty); 6295 Setattr((yyval.node),"unnamedinstance","1"); 6296 Setattr(n,"unnamedinstance","1"); 6297 Delete(cty); 6298 } 6299 if ((yyvsp[(8) - (8)].node)) { 6300 Node *p = (yyvsp[(8) - (8)].node); 6301 set_nextSibling(n,p); 6302 while (p) { 6303 SwigType *cty = Copy(ty); 6304 Setattr(p,"type",cty); 6305 Setattr(p,"unnamed",unnamed); 6306 Setattr(p,"storage",(yyvsp[(1) - (8)].id)); 6307 Delete(cty); 6308 p = nextSibling(p); 6309 } 6310 } else { 6311 if (Len(scanner_ccode)) { 6312 String *code = Copy(scanner_ccode); 6313 Setattr(n,"code",code); 6314 Delete(code); 6315 } 6316 } 6317 6318 /* Ensure that typedef enum ABC {foo} XYZ; uses XYZ for sym:name, like structs. 6319 * Note that class_rename/yyrename are bit of a mess so used this simple approach to change the name. */ 6320 if ((yyvsp[(7) - (8)].decl).id && (yyvsp[(3) - (8)].id) && Cmp((yyvsp[(1) - (8)].id),"typedef") == 0) { 6321 String *name = NewString((yyvsp[(7) - (8)].decl).id); 6322 Setattr((yyval.node), "parser:makename", name); 6323 Delete(name); 6324 } 6325 6326 add_symbols((yyval.node)); /* Add enum to tag space */ 6327 set_nextSibling((yyval.node),n); 6328 Delete(n); 6329 add_symbols((yyvsp[(5) - (8)].node)); /* Add enum values to id space */ 6330 add_symbols(n); 6331 Delete(unnamed); 6332 } 6333 break; 6334 6335 case 129: 6336#line 3170 "parser.y" 6337 { 6338 /* This is a sick hack. If the ctor_end has parameters, 6339 and the parms parameter only has 1 parameter, this 6340 could be a declaration of the form: 6341 6342 type (id)(parms) 6343 6344 Otherwise it's an error. */ 6345 int err = 0; 6346 (yyval.node) = 0; 6347 6348 if ((ParmList_len((yyvsp[(4) - (6)].pl)) == 1) && (!Swig_scopename_check((yyvsp[(2) - (6)].type)))) { 6349 SwigType *ty = Getattr((yyvsp[(4) - (6)].pl),"type"); 6350 String *name = Getattr((yyvsp[(4) - (6)].pl),"name"); 6351 err = 1; 6352 if (!name) { 6353 (yyval.node) = new_node("cdecl"); 6354 Setattr((yyval.node),"type",(yyvsp[(2) - (6)].type)); 6355 Setattr((yyval.node),"storage",(yyvsp[(1) - (6)].id)); 6356 Setattr((yyval.node),"name",ty); 6357 6358 if ((yyvsp[(6) - (6)].decl).have_parms) { 6359 SwigType *decl = NewStringEmpty(); 6360 SwigType_add_function(decl,(yyvsp[(6) - (6)].decl).parms); 6361 Setattr((yyval.node),"decl",decl); 6362 Setattr((yyval.node),"parms",(yyvsp[(6) - (6)].decl).parms); 6363 if (Len(scanner_ccode)) { 6364 String *code = Copy(scanner_ccode); 6365 Setattr((yyval.node),"code",code); 6366 Delete(code); 6367 } 6368 } 6369 if ((yyvsp[(6) - (6)].decl).defarg) { 6370 Setattr((yyval.node),"value",(yyvsp[(6) - (6)].decl).defarg); 6371 } 6372 Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].decl).throws); 6373 Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].decl).throwf); 6374 err = 0; 6375 } 6376 } 6377 if (err) { 6378 Swig_error(cparse_file,cparse_line,"Syntax error in input(2).\n"); 6379 exit(1); 6380 } 6381 } 6382 break; 6383 6384 case 130: 6385#line 3221 "parser.y" 6386 { (yyval.node) = (yyvsp[(1) - (1)].node); } 6387 break; 6388 6389 case 131: 6390#line 3222 "parser.y" 6391 { (yyval.node) = (yyvsp[(1) - (1)].node); } 6392 break; 6393 6394 case 132: 6395#line 3223 "parser.y" 6396 { (yyval.node) = (yyvsp[(1) - (1)].node); } 6397 break; 6398 6399 case 133: 6400#line 3224 "parser.y" 6401 { (yyval.node) = (yyvsp[(1) - (1)].node); } 6402 break; 6403 6404 case 134: 6405#line 3225 "parser.y" 6406 { (yyval.node) = (yyvsp[(1) - (1)].node); } 6407 break; 6408 6409 case 135: 6410#line 3226 "parser.y" 6411 { (yyval.node) = 0; } 6412 break; 6413 6414 case 136: 6415#line 3232 "parser.y" 6416 { 6417 List *bases = 0; 6418 Node *scope = 0; 6419 (yyval.node) = new_node("class"); 6420 Setline((yyval.node),cparse_start_line); 6421 Setattr((yyval.node),"kind",(yyvsp[(2) - (5)].id)); 6422 if ((yyvsp[(4) - (5)].bases)) { 6423 Setattr((yyval.node),"baselist", Getattr((yyvsp[(4) - (5)].bases),"public")); 6424 Setattr((yyval.node),"protectedbaselist", Getattr((yyvsp[(4) - (5)].bases),"protected")); 6425 Setattr((yyval.node),"privatebaselist", Getattr((yyvsp[(4) - (5)].bases),"private")); 6426 } 6427 Setattr((yyval.node),"allows_typedef","1"); 6428 6429 /* preserve the current scope */ 6430 prev_symtab = Swig_symbol_current(); 6431 6432 /* If the class name is qualified. We need to create or lookup namespace/scope entries */ 6433 scope = resolve_node_scope((yyvsp[(3) - (5)].str)); 6434 Setfile(scope,cparse_file); 6435 Setline(scope,cparse_line); 6436 (yyvsp[(3) - (5)].str) = scope; 6437 6438 /* support for old nested classes "pseudo" support, such as: 6439 6440 %rename(Ala__Ola) Ala::Ola; 6441 class Ala::Ola { 6442 public: 6443 Ola() {} 6444 }; 6445 6446 this should disappear when a proper implementation is added. 6447 */ 6448 if (nscope_inner && Strcmp(nodeType(nscope_inner),"namespace") != 0) { 6449 if (Namespaceprefix) { 6450 String *name = NewStringf("%s::%s", Namespaceprefix, (yyvsp[(3) - (5)].str)); 6451 (yyvsp[(3) - (5)].str) = name; 6452 Namespaceprefix = 0; 6453 nscope_inner = 0; 6454 } 6455 } 6456 Setattr((yyval.node),"name",(yyvsp[(3) - (5)].str)); 6457 6458 Delete(class_rename); 6459 class_rename = make_name((yyval.node),(yyvsp[(3) - (5)].str),0); 6460 Classprefix = NewString((yyvsp[(3) - (5)].str)); 6461 /* Deal with inheritance */ 6462 if ((yyvsp[(4) - (5)].bases)) { 6463 bases = make_inherit_list((yyvsp[(3) - (5)].str),Getattr((yyvsp[(4) - (5)].bases),"public")); 6464 } 6465 if (SwigType_istemplate((yyvsp[(3) - (5)].str))) { 6466 String *fbase, *tbase, *prefix; 6467 prefix = SwigType_templateprefix((yyvsp[(3) - (5)].str)); 6468 if (Namespaceprefix) { 6469 fbase = NewStringf("%s::%s", Namespaceprefix,(yyvsp[(3) - (5)].str)); 6470 tbase = NewStringf("%s::%s", Namespaceprefix, prefix); 6471 } else { 6472 fbase = Copy((yyvsp[(3) - (5)].str)); 6473 tbase = Copy(prefix); 6474 } 6475 Swig_name_inherit(tbase,fbase); 6476 Delete(fbase); 6477 Delete(tbase); 6478 Delete(prefix); 6479 } 6480 if (strcmp((yyvsp[(2) - (5)].id),"class") == 0) { 6481 cplus_mode = CPLUS_PRIVATE; 6482 } else { 6483 cplus_mode = CPLUS_PUBLIC; 6484 } 6485 Swig_symbol_newscope(); 6486 Swig_symbol_setscopename((yyvsp[(3) - (5)].str)); 6487 if (bases) { 6488 Iterator s; 6489 for (s = First(bases); s.item; s = Next(s)) { 6490 Symtab *st = Getattr(s.item,"symtab"); 6491 if (st) { 6492 Setfile(st,Getfile(s.item)); 6493 Setline(st,Getline(s.item)); 6494 Swig_symbol_inherit(st); 6495 } 6496 } 6497 Delete(bases); 6498 } 6499 Delete(Namespaceprefix); 6500 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 6501 cparse_start_line = cparse_line; 6502 6503 /* If there are active template parameters, we need to make sure they are 6504 placed in the class symbol table so we can catch shadows */ 6505 6506 if (template_parameters) { 6507 Parm *tp = template_parameters; 6508 while(tp) { 6509 String *tpname = Copy(Getattr(tp,"name")); 6510 Node *tn = new_node("templateparm"); 6511 Setattr(tn,"name",tpname); 6512 Swig_symbol_cadd(tpname,tn); 6513 tp = nextSibling(tp); 6514 Delete(tpname); 6515 } 6516 } 6517 if (class_level >= max_class_levels) { 6518 if (!max_class_levels) { 6519 max_class_levels = 16; 6520 } else { 6521 max_class_levels *= 2; 6522 } 6523 class_decl = (Node**) realloc(class_decl, sizeof(Node*) * max_class_levels); 6524 if (!class_decl) { 6525 Swig_error(cparse_file, cparse_line, "realloc() failed\n"); 6526 } 6527 } 6528 class_decl[class_level++] = (yyval.node); 6529 inclass = 1; 6530 } 6531 break; 6532 6533 case 137: 6534#line 3346 "parser.y" 6535 { 6536 Node *p; 6537 SwigType *ty; 6538 Symtab *cscope = prev_symtab; 6539 Node *am = 0; 6540 String *scpname = 0; 6541 (yyval.node) = class_decl[--class_level]; 6542 inclass = 0; 6543 6544 /* Check for pure-abstract class */ 6545 Setattr((yyval.node),"abstract", pure_abstract((yyvsp[(7) - (9)].node))); 6546 6547 /* This bit of code merges in a previously defined %extend directive (if any) */ 6548 6549 if (extendhash) { 6550 String *clsname = Swig_symbol_qualifiedscopename(0); 6551 am = Getattr(extendhash,clsname); 6552 if (am) { 6553 merge_extensions((yyval.node),am); 6554 Delattr(extendhash,clsname); 6555 } 6556 Delete(clsname); 6557 } 6558 if (!classes) classes = NewHash(); 6559 scpname = Swig_symbol_qualifiedscopename(0); 6560 Setattr(classes,scpname,(yyval.node)); 6561 Delete(scpname); 6562 6563 appendChild((yyval.node),(yyvsp[(7) - (9)].node)); 6564 6565 if (am) append_previous_extension((yyval.node),am); 6566 6567 p = (yyvsp[(9) - (9)].node); 6568 if (p) { 6569 set_nextSibling((yyval.node),p); 6570 } 6571 6572 if (cparse_cplusplus && !cparse_externc) { 6573 ty = NewString((yyvsp[(3) - (9)].str)); 6574 } else { 6575 ty = NewStringf("%s %s", (yyvsp[(2) - (9)].id),(yyvsp[(3) - (9)].str)); 6576 } 6577 while (p) { 6578 Setattr(p,"storage",(yyvsp[(1) - (9)].id)); 6579 Setattr(p,"type",ty); 6580 p = nextSibling(p); 6581 } 6582 /* Dump nested classes */ 6583 { 6584 String *name = (yyvsp[(3) - (9)].str); 6585 if ((yyvsp[(9) - (9)].node)) { 6586 SwigType *decltype = Getattr((yyvsp[(9) - (9)].node),"decl"); 6587 if (Cmp((yyvsp[(1) - (9)].id),"typedef") == 0) { 6588 if (!decltype || !Len(decltype)) { 6589 String *cname; 6590 name = Getattr((yyvsp[(9) - (9)].node),"name"); 6591 cname = Copy(name); 6592 Setattr((yyval.node),"tdname",cname); 6593 Delete(cname); 6594 6595 /* Use typedef name as class name */ 6596 if (class_rename && (Strcmp(class_rename,(yyvsp[(3) - (9)].str)) == 0)) { 6597 Delete(class_rename); 6598 class_rename = NewString(name); 6599 } 6600 if (!Getattr(classes,name)) { 6601 Setattr(classes,name,(yyval.node)); 6602 } 6603 Setattr((yyval.node),"decl",decltype); 6604 } 6605 } 6606 } 6607 appendChild((yyval.node),dump_nested(Char(name))); 6608 } 6609 6610 if (cplus_mode != CPLUS_PUBLIC) { 6611 /* we 'open' the class at the end, to allow %template 6612 to add new members */ 6613 Node *pa = new_node("access"); 6614 Setattr(pa,"kind","public"); 6615 cplus_mode = CPLUS_PUBLIC; 6616 appendChild((yyval.node),pa); 6617 Delete(pa); 6618 } 6619 6620 Setattr((yyval.node),"symtab",Swig_symbol_popscope()); 6621 6622 Classprefix = 0; 6623 if (nscope_inner) { 6624 /* this is tricky */ 6625 /* we add the declaration in the original namespace */ 6626 appendChild(nscope_inner,(yyval.node)); 6627 Swig_symbol_setscope(Getattr(nscope_inner,"symtab")); 6628 Delete(Namespaceprefix); 6629 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 6630 add_symbols((yyval.node)); 6631 if (nscope) (yyval.node) = nscope; 6632 /* but the variable definition in the current scope */ 6633 Swig_symbol_setscope(cscope); 6634 Delete(Namespaceprefix); 6635 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 6636 add_symbols((yyvsp[(9) - (9)].node)); 6637 } else { 6638 Delete(yyrename); 6639 yyrename = Copy(class_rename); 6640 Delete(Namespaceprefix); 6641 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 6642 6643 add_symbols((yyval.node)); 6644 add_symbols((yyvsp[(9) - (9)].node)); 6645 } 6646 Swig_symbol_setscope(cscope); 6647 Delete(Namespaceprefix); 6648 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 6649 } 6650 break; 6651 6652 case 138: 6653#line 3464 "parser.y" 6654 { 6655 String *unnamed; 6656 unnamed = make_unnamed(); 6657 (yyval.node) = new_node("class"); 6658 Setline((yyval.node),cparse_start_line); 6659 Setattr((yyval.node),"kind",(yyvsp[(2) - (3)].id)); 6660 Setattr((yyval.node),"storage",(yyvsp[(1) - (3)].id)); 6661 Setattr((yyval.node),"unnamed",unnamed); 6662 Setattr((yyval.node),"allows_typedef","1"); 6663 Delete(class_rename); 6664 class_rename = make_name((yyval.node),0,0); 6665 if (strcmp((yyvsp[(2) - (3)].id),"class") == 0) { 6666 cplus_mode = CPLUS_PRIVATE; 6667 } else { 6668 cplus_mode = CPLUS_PUBLIC; 6669 } 6670 Swig_symbol_newscope(); 6671 cparse_start_line = cparse_line; 6672 if (class_level >= max_class_levels) { 6673 if (!max_class_levels) { 6674 max_class_levels = 16; 6675 } else { 6676 max_class_levels *= 2; 6677 } 6678 class_decl = (Node**) realloc(class_decl, sizeof(Node*) * max_class_levels); 6679 if (!class_decl) { 6680 Swig_error(cparse_file, cparse_line, "realloc() failed\n"); 6681 } 6682 } 6683 class_decl[class_level++] = (yyval.node); 6684 inclass = 1; 6685 Classprefix = NewStringEmpty(); 6686 Delete(Namespaceprefix); 6687 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 6688 } 6689 break; 6690 6691 case 139: 6692#line 3498 "parser.y" 6693 { 6694 String *unnamed; 6695 Node *n; 6696 Classprefix = 0; 6697 (yyval.node) = class_decl[--class_level]; 6698 inclass = 0; 6699 unnamed = Getattr((yyval.node),"unnamed"); 6700 6701 /* Check for pure-abstract class */ 6702 Setattr((yyval.node),"abstract", pure_abstract((yyvsp[(5) - (8)].node))); 6703 6704 n = new_node("cdecl"); 6705 Setattr(n,"name",(yyvsp[(7) - (8)].decl).id); 6706 Setattr(n,"unnamed",unnamed); 6707 Setattr(n,"type",unnamed); 6708 Setattr(n,"decl",(yyvsp[(7) - (8)].decl).type); 6709 Setattr(n,"parms",(yyvsp[(7) - (8)].decl).parms); 6710 Setattr(n,"storage",(yyvsp[(1) - (8)].id)); 6711 if ((yyvsp[(8) - (8)].node)) { 6712 Node *p = (yyvsp[(8) - (8)].node); 6713 set_nextSibling(n,p); 6714 while (p) { 6715 String *type = Copy(unnamed); 6716 Setattr(p,"name",(yyvsp[(7) - (8)].decl).id); 6717 Setattr(p,"unnamed",unnamed); 6718 Setattr(p,"type",type); 6719 Delete(type); 6720 Setattr(p,"storage",(yyvsp[(1) - (8)].id)); 6721 p = nextSibling(p); 6722 } 6723 } 6724 set_nextSibling((yyval.node),n); 6725 Delete(n); 6726 { 6727 /* If a proper typedef name was given, we'll use it to set the scope name */ 6728 String *name = 0; 6729 if ((yyvsp[(1) - (8)].id) && (strcmp((yyvsp[(1) - (8)].id),"typedef") == 0)) { 6730 if (!Len((yyvsp[(7) - (8)].decl).type)) { 6731 String *scpname = 0; 6732 name = (yyvsp[(7) - (8)].decl).id; 6733 Setattr((yyval.node),"tdname",name); 6734 Setattr((yyval.node),"name",name); 6735 Swig_symbol_setscopename(name); 6736 6737 /* If a proper name was given, we use that as the typedef, not unnamed */ 6738 Clear(unnamed); 6739 Append(unnamed, name); 6740 6741 n = nextSibling(n); 6742 set_nextSibling((yyval.node),n); 6743 6744 /* Check for previous extensions */ 6745 if (extendhash) { 6746 String *clsname = Swig_symbol_qualifiedscopename(0); 6747 Node *am = Getattr(extendhash,clsname); 6748 if (am) { 6749 /* Merge the extension into the symbol table */ 6750 merge_extensions((yyval.node),am); 6751 append_previous_extension((yyval.node),am); 6752 Delattr(extendhash,clsname); 6753 } 6754 Delete(clsname); 6755 } 6756 if (!classes) classes = NewHash(); 6757 scpname = Swig_symbol_qualifiedscopename(0); 6758 Setattr(classes,scpname,(yyval.node)); 6759 Delete(scpname); 6760 } else { 6761 Swig_symbol_setscopename((char*)"<unnamed>"); 6762 } 6763 } 6764 appendChild((yyval.node),(yyvsp[(5) - (8)].node)); 6765 appendChild((yyval.node),dump_nested(Char(name))); 6766 } 6767 /* Pop the scope */ 6768 Setattr((yyval.node),"symtab",Swig_symbol_popscope()); 6769 if (class_rename) { 6770 Delete(yyrename); 6771 yyrename = NewString(class_rename); 6772 } 6773 Delete(Namespaceprefix); 6774 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 6775 add_symbols((yyval.node)); 6776 add_symbols(n); 6777 Delete(unnamed); 6778 } 6779 break; 6780 6781 case 140: 6782#line 3586 "parser.y" 6783 { (yyval.node) = 0; } 6784 break; 6785 6786 case 141: 6787#line 3587 "parser.y" 6788 { 6789 (yyval.node) = new_node("cdecl"); 6790 Setattr((yyval.node),"name",(yyvsp[(1) - (2)].decl).id); 6791 Setattr((yyval.node),"decl",(yyvsp[(1) - (2)].decl).type); 6792 Setattr((yyval.node),"parms",(yyvsp[(1) - (2)].decl).parms); 6793 set_nextSibling((yyval.node),(yyvsp[(2) - (2)].node)); 6794 } 6795 break; 6796 6797 case 142: 6798#line 3599 "parser.y" 6799 { 6800 if ((yyvsp[(1) - (4)].id) && (Strcmp((yyvsp[(1) - (4)].id),"friend") == 0)) { 6801 /* Ignore */ 6802 (yyval.node) = 0; 6803 } else { 6804 (yyval.node) = new_node("classforward"); 6805 Setfile((yyval.node),cparse_file); 6806 Setline((yyval.node),cparse_line); 6807 Setattr((yyval.node),"kind",(yyvsp[(2) - (4)].id)); 6808 Setattr((yyval.node),"name",(yyvsp[(3) - (4)].str)); 6809 Setattr((yyval.node),"sym:weak", "1"); 6810 add_symbols((yyval.node)); 6811 } 6812 } 6813 break; 6814 6815 case 143: 6816#line 3619 "parser.y" 6817 { template_parameters = (yyvsp[(3) - (4)].tparms); } 6818 break; 6819 6820 case 144: 6821#line 3619 "parser.y" 6822 { 6823 String *tname = 0; 6824 int error = 0; 6825 6826 /* check if we get a namespace node with a class declaration, and retrieve the class */ 6827 Symtab *cscope = Swig_symbol_current(); 6828 Symtab *sti = 0; 6829 Node *ntop = (yyvsp[(6) - (6)].node); 6830 Node *ni = ntop; 6831 SwigType *ntype = ni ? nodeType(ni) : 0; 6832 while (ni && Strcmp(ntype,"namespace") == 0) { 6833 sti = Getattr(ni,"symtab"); 6834 ni = firstChild(ni); 6835 ntype = nodeType(ni); 6836 } 6837 if (sti) { 6838 Swig_symbol_setscope(sti); 6839 Delete(Namespaceprefix); 6840 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 6841 (yyvsp[(6) - (6)].node) = ni; 6842 } 6843 6844 template_parameters = 0; 6845 (yyval.node) = (yyvsp[(6) - (6)].node); 6846 if ((yyval.node)) tname = Getattr((yyval.node),"name"); 6847 6848 /* Check if the class is a template specialization */ 6849 if (((yyval.node)) && (Strchr(tname,'<')) && (!is_operator(tname))) { 6850 /* If a specialization. Check if defined. */ 6851 Node *tempn = 0; 6852 { 6853 String *tbase = SwigType_templateprefix(tname); 6854 tempn = Swig_symbol_clookup_local(tbase,0); 6855 if (!tempn || (Strcmp(nodeType(tempn),"template") != 0)) { 6856 SWIG_WARN_NODE_BEGIN(tempn); 6857 Swig_warning(WARN_PARSE_TEMPLATE_SP_UNDEF, Getfile((yyval.node)),Getline((yyval.node)),"Specialization of non-template '%s'.\n", tbase); 6858 SWIG_WARN_NODE_END(tempn); 6859 tempn = 0; 6860 error = 1; 6861 } 6862 Delete(tbase); 6863 } 6864 Setattr((yyval.node),"specialization","1"); 6865 Setattr((yyval.node),"templatetype",nodeType((yyval.node))); 6866 set_nodeType((yyval.node),"template"); 6867 /* Template partial specialization */ 6868 if (tempn && ((yyvsp[(3) - (6)].tparms)) && ((yyvsp[(6) - (6)].node))) { 6869 List *tlist; 6870 String *targs = SwigType_templateargs(tname); 6871 tlist = SwigType_parmlist(targs); 6872 /* Printf(stdout,"targs = '%s' %s\n", targs, tlist); */ 6873 if (!Getattr((yyval.node),"sym:weak")) { 6874 Setattr((yyval.node),"sym:typename","1"); 6875 } 6876 6877 if (Len(tlist) != ParmList_len(Getattr(tempn,"templateparms"))) { 6878 Swig_error(Getfile((yyval.node)),Getline((yyval.node)),"Inconsistent argument count in template partial specialization. %d %d\n", Len(tlist), ParmList_len(Getattr(tempn,"templateparms"))); 6879 6880 } else { 6881 6882 /* This code builds the argument list for the partial template 6883 specialization. This is a little hairy, but the idea is as 6884 follows: 6885 6886 $3 contains a list of arguments supplied for the template. 6887 For example template<class T>. 6888 6889 tlist is a list of the specialization arguments--which may be 6890 different. For example class<int,T>. 6891 6892 tp is a copy of the arguments in the original template definition. 6893 6894 The patching algorithm walks through the list of supplied 6895 arguments ($3), finds the position in the specialization arguments 6896 (tlist), and then patches the name in the argument list of the 6897 original template. 6898 */ 6899 6900 { 6901 String *pn; 6902 Parm *p, *p1; 6903 int i, nargs; 6904 Parm *tp = CopyParmList(Getattr(tempn,"templateparms")); 6905 nargs = Len(tlist); 6906 p = (yyvsp[(3) - (6)].tparms); 6907 while (p) { 6908 for (i = 0; i < nargs; i++){ 6909 pn = Getattr(p,"name"); 6910 if (Strcmp(pn,SwigType_base(Getitem(tlist,i))) == 0) { 6911 int j; 6912 Parm *p1 = tp; 6913 for (j = 0; j < i; j++) { 6914 p1 = nextSibling(p1); 6915 } 6916 Setattr(p1,"name",pn); 6917 Setattr(p1,"partialarg","1"); 6918 } 6919 } 6920 p = nextSibling(p); 6921 } 6922 p1 = tp; 6923 i = 0; 6924 while (p1) { 6925 if (!Getattr(p1,"partialarg")) { 6926 Delattr(p1,"name"); 6927 Setattr(p1,"type", Getitem(tlist,i)); 6928 } 6929 i++; 6930 p1 = nextSibling(p1); 6931 } 6932 Setattr((yyval.node),"templateparms",tp); 6933 Delete(tp); 6934 } 6935#if 0 6936 /* Patch the parameter list */ 6937 if (tempn) { 6938 Parm *p,*p1; 6939 ParmList *tp = CopyParmList(Getattr(tempn,"templateparms")); 6940 p = (yyvsp[(3) - (6)].tparms); 6941 p1 = tp; 6942 while (p && p1) { 6943 String *pn = Getattr(p,"name"); 6944 Printf(stdout,"pn = '%s'\n", pn); 6945 if (pn) Setattr(p1,"name",pn); 6946 else Delattr(p1,"name"); 6947 pn = Getattr(p,"type"); 6948 if (pn) Setattr(p1,"type",pn); 6949 p = nextSibling(p); 6950 p1 = nextSibling(p1); 6951 } 6952 Setattr((yyval.node),"templateparms",tp); 6953 Delete(tp); 6954 } else { 6955 Setattr((yyval.node),"templateparms",(yyvsp[(3) - (6)].tparms)); 6956 } 6957#endif 6958 Delattr((yyval.node),"specialization"); 6959 Setattr((yyval.node),"partialspecialization","1"); 6960 /* Create a specialized name for matching */ 6961 { 6962 Parm *p = (yyvsp[(3) - (6)].tparms); 6963 String *fname = NewString(Getattr((yyval.node),"name")); 6964 String *ffname = 0; 6965 6966 char tmp[32]; 6967 int i, ilen; 6968 while (p) { 6969 String *n = Getattr(p,"name"); 6970 if (!n) { 6971 p = nextSibling(p); 6972 continue; 6973 } 6974 ilen = Len(tlist); 6975 for (i = 0; i < ilen; i++) { 6976 if (Strstr(Getitem(tlist,i),n)) { 6977 sprintf(tmp,"$%d",i+1); 6978 Replaceid(fname,n,tmp); 6979 } 6980 } 6981 p = nextSibling(p); 6982 } 6983 /* Patch argument names with typedef */ 6984 { 6985 Iterator tt; 6986 List *tparms = SwigType_parmlist(fname); 6987 ffname = SwigType_templateprefix(fname); 6988 Append(ffname,"<("); 6989 for (tt = First(tparms); tt.item; ) { 6990 SwigType *rtt = Swig_symbol_typedef_reduce(tt.item,0); 6991 SwigType *ttr = Swig_symbol_type_qualify(rtt,0); 6992 Append(ffname,ttr); 6993 tt = Next(tt); 6994 if (tt.item) Putc(',',ffname); 6995 Delete(rtt); 6996 Delete(ttr); 6997 } 6998 Delete(tparms); 6999 Append(ffname,")>"); 7000 } 7001 { 7002 String *partials = Getattr(tempn,"partials"); 7003 if (!partials) { 7004 partials = NewList(); 7005 Setattr(tempn,"partials",partials); 7006 Delete(partials); 7007 } 7008 /* Printf(stdout,"partial: fname = '%s', '%s'\n", fname, Swig_symbol_typedef_reduce(fname,0)); */ 7009 Append(partials,ffname); 7010 } 7011 Setattr((yyval.node),"partialargs",ffname); 7012 Swig_symbol_cadd(ffname,(yyval.node)); 7013 } 7014 } 7015 Delete(tlist); 7016 Delete(targs); 7017 } else { 7018 /* Need to resolve exact specialization name */ 7019 /* add default args from generic template */ 7020 String *ty = Swig_symbol_template_deftype(tname,0); 7021 String *fname = Swig_symbol_type_qualify(ty,0); 7022 Swig_symbol_cadd(fname,(yyval.node)); 7023 Delete(ty); 7024 Delete(fname); 7025 } 7026 } else if ((yyval.node)) { 7027 Setattr((yyval.node),"templatetype",nodeType((yyvsp[(6) - (6)].node))); 7028 set_nodeType((yyval.node),"template"); 7029 Setattr((yyval.node),"templateparms", (yyvsp[(3) - (6)].tparms)); 7030 if (!Getattr((yyval.node),"sym:weak")) { 7031 Setattr((yyval.node),"sym:typename","1"); 7032 } 7033 add_symbols((yyval.node)); 7034 default_arguments((yyval.node)); 7035 /* We also place a fully parameterized version in the symbol table */ 7036 { 7037 Parm *p; 7038 String *fname = NewStringf("%s<(", Getattr((yyval.node),"name")); 7039 p = (yyvsp[(3) - (6)].tparms); 7040 while (p) { 7041 String *n = Getattr(p,"name"); 7042 if (!n) n = Getattr(p,"type"); 7043 Append(fname,n); 7044 p = nextSibling(p); 7045 if (p) Putc(',',fname); 7046 } 7047 Append(fname,")>"); 7048 Swig_symbol_cadd(fname,(yyval.node)); 7049 } 7050 } 7051 (yyval.node) = ntop; 7052 Swig_symbol_setscope(cscope); 7053 Delete(Namespaceprefix); 7054 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 7055 if (error) (yyval.node) = 0; 7056 } 7057 break; 7058 7059 case 145: 7060#line 3854 "parser.y" 7061 { 7062 Swig_warning(WARN_PARSE_EXPLICIT_TEMPLATE, cparse_file, cparse_line, "Explicit template instantiation ignored.\n"); 7063 (yyval.node) = 0; 7064 } 7065 break; 7066 7067 case 146: 7068#line 3860 "parser.y" 7069 { 7070 (yyval.node) = (yyvsp[(1) - (1)].node); 7071 } 7072 break; 7073 7074 case 147: 7075#line 3863 "parser.y" 7076 { 7077 (yyval.node) = (yyvsp[(1) - (1)].node); 7078 } 7079 break; 7080 7081 case 148: 7082#line 3866 "parser.y" 7083 { 7084 (yyval.node) = (yyvsp[(1) - (1)].node); 7085 } 7086 break; 7087 7088 case 149: 7089#line 3869 "parser.y" 7090 { 7091 (yyval.node) = 0; 7092 } 7093 break; 7094 7095 case 150: 7096#line 3872 "parser.y" 7097 { 7098 (yyval.node) = (yyvsp[(1) - (1)].node); 7099 } 7100 break; 7101 7102 case 151: 7103#line 3875 "parser.y" 7104 { 7105 (yyval.node) = (yyvsp[(1) - (1)].node); 7106 } 7107 break; 7108 7109 case 152: 7110#line 3880 "parser.y" 7111 { 7112 /* Rip out the parameter names */ 7113 Parm *p = (yyvsp[(1) - (1)].pl); 7114 (yyval.tparms) = (yyvsp[(1) - (1)].pl); 7115 7116 while (p) { 7117 String *name = Getattr(p,"name"); 7118 if (!name) { 7119 /* Hmmm. Maybe it's a 'class T' parameter */ 7120 char *type = Char(Getattr(p,"type")); 7121 /* Template template parameter */ 7122 if (strncmp(type,"template<class> ",16) == 0) { 7123 type += 16; 7124 } 7125 if ((strncmp(type,"class ",6) == 0) || (strncmp(type,"typename ", 9) == 0)) { 7126 char *t = strchr(type,' '); 7127 Setattr(p,"name", t+1); 7128 } else { 7129 /* 7130 Swig_error(cparse_file, cparse_line, "Missing template parameter name\n"); 7131 $$.rparms = 0; 7132 $$.parms = 0; 7133 break; */ 7134 } 7135 } 7136 p = nextSibling(p); 7137 } 7138 } 7139 break; 7140 7141 case 153: 7142#line 3910 "parser.y" 7143 { 7144 set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].pl)); 7145 (yyval.pl) = (yyvsp[(1) - (2)].p); 7146 } 7147 break; 7148 7149 case 154: 7150#line 3914 "parser.y" 7151 { (yyval.pl) = 0; } 7152 break; 7153 7154 case 155: 7155#line 3917 "parser.y" 7156 { 7157 (yyval.p) = NewParm(NewString((yyvsp[(1) - (1)].id)), 0); 7158 } 7159 break; 7160 7161 case 156: 7162#line 3920 "parser.y" 7163 { 7164 (yyval.p) = (yyvsp[(1) - (1)].p); 7165 } 7166 break; 7167 7168 case 157: 7169#line 3925 "parser.y" 7170 { 7171 set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].pl)); 7172 (yyval.pl) = (yyvsp[(2) - (3)].p); 7173 } 7174 break; 7175 7176 case 158: 7177#line 3929 "parser.y" 7178 { (yyval.pl) = 0; } 7179 break; 7180 7181 case 159: 7182#line 3934 "parser.y" 7183 { 7184 String *uname = Swig_symbol_type_qualify((yyvsp[(2) - (3)].str),0); 7185 String *name = Swig_scopename_last((yyvsp[(2) - (3)].str)); 7186 (yyval.node) = new_node("using"); 7187 Setattr((yyval.node),"uname",uname); 7188 Setattr((yyval.node),"name", name); 7189 Delete(uname); 7190 Delete(name); 7191 add_symbols((yyval.node)); 7192 } 7193 break; 7194 7195 case 160: 7196#line 3944 "parser.y" 7197 { 7198 Node *n = Swig_symbol_clookup((yyvsp[(3) - (4)].str),0); 7199 if (!n) { 7200 Swig_error(cparse_file, cparse_line, "Nothing known about namespace '%s'\n", (yyvsp[(3) - (4)].str)); 7201 (yyval.node) = 0; 7202 } else { 7203 7204 while (Strcmp(nodeType(n),"using") == 0) { 7205 n = Getattr(n,"node"); 7206 } 7207 if (n) { 7208 if (Strcmp(nodeType(n),"namespace") == 0) { 7209 Symtab *current = Swig_symbol_current(); 7210 Symtab *symtab = Getattr(n,"symtab"); 7211 (yyval.node) = new_node("using"); 7212 Setattr((yyval.node),"node",n); 7213 Setattr((yyval.node),"namespace", (yyvsp[(3) - (4)].str)); 7214 if (current != symtab) { 7215 Swig_symbol_inherit(symtab); 7216 } 7217 } else { 7218 Swig_error(cparse_file, cparse_line, "'%s' is not a namespace.\n", (yyvsp[(3) - (4)].str)); 7219 (yyval.node) = 0; 7220 } 7221 } else { 7222 (yyval.node) = 0; 7223 } 7224 } 7225 } 7226 break; 7227 7228 case 161: 7229#line 3975 "parser.y" 7230 { 7231 Hash *h; 7232 (yyvsp[(1) - (3)].node) = Swig_symbol_current(); 7233 h = Swig_symbol_clookup((yyvsp[(2) - (3)].str),0); 7234 if (h && ((yyvsp[(1) - (3)].node) == Getattr(h,"sym:symtab")) && (Strcmp(nodeType(h),"namespace") == 0)) { 7235 if (Getattr(h,"alias")) { 7236 h = Getattr(h,"namespace"); 7237 Swig_warning(WARN_PARSE_NAMESPACE_ALIAS, cparse_file, cparse_line, "Namespace alias '%s' not allowed here. Assuming '%s'\n", 7238 (yyvsp[(2) - (3)].str), Getattr(h,"name")); 7239 (yyvsp[(2) - (3)].str) = Getattr(h,"name"); 7240 } 7241 Swig_symbol_setscope(Getattr(h,"symtab")); 7242 } else { 7243 Swig_symbol_newscope(); 7244 Swig_symbol_setscopename((yyvsp[(2) - (3)].str)); 7245 } 7246 Delete(Namespaceprefix); 7247 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 7248 } 7249 break; 7250 7251 case 162: 7252#line 3993 "parser.y" 7253 { 7254 Node *n = (yyvsp[(5) - (6)].node); 7255 set_nodeType(n,"namespace"); 7256 Setattr(n,"name",(yyvsp[(2) - (6)].str)); 7257 Setattr(n,"symtab", Swig_symbol_popscope()); 7258 Swig_symbol_setscope((yyvsp[(1) - (6)].node)); 7259 (yyval.node) = n; 7260 Delete(Namespaceprefix); 7261 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 7262 add_symbols((yyval.node)); 7263 } 7264 break; 7265 7266 case 163: 7267#line 4004 "parser.y" 7268 { 7269 Hash *h; 7270 (yyvsp[(1) - (2)].node) = Swig_symbol_current(); 7271 h = Swig_symbol_clookup((char *)" ",0); 7272 if (h && (Strcmp(nodeType(h),"namespace") == 0)) { 7273 Swig_symbol_setscope(Getattr(h,"symtab")); 7274 } else { 7275 Swig_symbol_newscope(); 7276 /* we don't use "__unnamed__", but a long 'empty' name */ 7277 Swig_symbol_setscopename(" "); 7278 } 7279 Namespaceprefix = 0; 7280 } 7281 break; 7282 7283 case 164: 7284#line 4016 "parser.y" 7285 { 7286 (yyval.node) = (yyvsp[(4) - (5)].node); 7287 set_nodeType((yyval.node),"namespace"); 7288 Setattr((yyval.node),"unnamed","1"); 7289 Setattr((yyval.node),"symtab", Swig_symbol_popscope()); 7290 Swig_symbol_setscope((yyvsp[(1) - (5)].node)); 7291 Delete(Namespaceprefix); 7292 Namespaceprefix = Swig_symbol_qualifiedscopename(0); 7293 add_symbols((yyval.node)); 7294 } 7295 break; 7296 7297 case 165: 7298#line 4026 "parser.y" 7299 { 7300 /* Namespace alias */ 7301 Node *n; 7302 (yyval.node) = new_node("namespace"); 7303 Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id)); 7304 Setattr((yyval.node),"alias",(yyvsp[(4) - (5)].str)); 7305 n = Swig_symbol_clookup((yyvsp[(4) - (5)].str),0); 7306 if (!n) { 7307 Swig_error(cparse_file, cparse_line, "Unknown namespace '%s'\n", (yyvsp[(4) - (5)].str)); 7308 (yyval.node) = 0; 7309 } else { 7310 if (Strcmp(nodeType(n),"namespace") != 0) { 7311 Swig_error(cparse_file, cparse_line, "'%s' is not a namespace\n",(yyvsp[(4) - (5)].str)); 7312 (yyval.node) = 0; 7313 } else { 7314 while (Getattr(n,"alias")) { 7315 n = Getattr(n,"namespace"); 7316 } 7317 Setattr((yyval.node),"namespace",n); 7318 add_symbols((yyval.node)); 7319 /* Set up a scope alias */ 7320 Swig_symbol_alias((yyvsp[(2) - (5)].id),Getattr(n,"symtab")); 7321 } 7322 } 7323 } 7324 break; 7325 7326 case 166: 7327#line 4053 "parser.y" 7328 { 7329 (yyval.node) = (yyvsp[(1) - (2)].node); 7330 /* Insert cpp_member (including any siblings) to the front of the cpp_members linked list */ 7331 if ((yyval.node)) { 7332 Node *p = (yyval.node); 7333 Node *pp =0; 7334 while (p) { 7335 pp = p; 7336 p = nextSibling(p); 7337 } 7338 set_nextSibling(pp,(yyvsp[(2) - (2)].node)); 7339 } else { 7340 (yyval.node) = (yyvsp[(2) - (2)].node); 7341 } 7342 } 7343 break; 7344 7345 case 167: 7346#line 4068 "parser.y" 7347 { 7348 if (cplus_mode != CPLUS_PUBLIC) { 7349 Swig_error(cparse_file,cparse_line,"%%extend can only be used in a public section\n"); 7350 } 7351 } 7352 break; 7353 7354 case 168: 7355#line 4072 "parser.y" 7356 { 7357 (yyval.node) = new_node("extend"); 7358 tag_nodes((yyvsp[(4) - (6)].node),"feature:extend",(char*) "1"); 7359 appendChild((yyval.node),(yyvsp[(4) - (6)].node)); 7360 set_nextSibling((yyval.node),(yyvsp[(6) - (6)].node)); 7361 } 7362 break; 7363 7364 case 169: 7365#line 4078 "parser.y" 7366 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7367 break; 7368 7369 case 170: 7370#line 4079 "parser.y" 7371 { (yyval.node) = 0;} 7372 break; 7373 7374 case 171: 7375#line 4080 "parser.y" 7376 { 7377 int start_line = cparse_line; 7378 skip_decl(); 7379 Swig_error(cparse_file,start_line,"Syntax error in input(3).\n"); 7380 exit(1); 7381 } 7382 break; 7383 7384 case 172: 7385#line 4085 "parser.y" 7386 { 7387 (yyval.node) = (yyvsp[(3) - (3)].node); 7388 } 7389 break; 7390 7391 case 173: 7392#line 4096 "parser.y" 7393 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7394 break; 7395 7396 case 174: 7397#line 4097 "parser.y" 7398 { 7399 (yyval.node) = (yyvsp[(1) - (1)].node); 7400 if (extendmode) { 7401 String *symname; 7402 symname= make_name((yyval.node),Getattr((yyval.node),"name"), Getattr((yyval.node),"decl")); 7403 if (Strcmp(symname,Getattr((yyval.node),"name")) == 0) { 7404 /* No renaming operation. Set name to class name */ 7405 Delete(yyrename); 7406 yyrename = NewString(Getattr(current_class,"sym:name")); 7407 } else { 7408 Delete(yyrename); 7409 yyrename = symname; 7410 } 7411 } 7412 add_symbols((yyval.node)); 7413 default_arguments((yyval.node)); 7414 } 7415 break; 7416 7417 case 175: 7418#line 4114 "parser.y" 7419 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7420 break; 7421 7422 case 176: 7423#line 4115 "parser.y" 7424 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7425 break; 7426 7427 case 177: 7428#line 4116 "parser.y" 7429 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7430 break; 7431 7432 case 178: 7433#line 4117 "parser.y" 7434 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7435 break; 7436 7437 case 179: 7438#line 4118 "parser.y" 7439 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7440 break; 7441 7442 case 180: 7443#line 4119 "parser.y" 7444 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7445 break; 7446 7447 case 181: 7448#line 4120 "parser.y" 7449 { (yyval.node) = 0; } 7450 break; 7451 7452 case 182: 7453#line 4121 "parser.y" 7454 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7455 break; 7456 7457 case 183: 7458#line 4122 "parser.y" 7459 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7460 break; 7461 7462 case 184: 7463#line 4123 "parser.y" 7464 { (yyval.node) = 0; } 7465 break; 7466 7467 case 185: 7468#line 4124 "parser.y" 7469 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7470 break; 7471 7472 case 186: 7473#line 4125 "parser.y" 7474 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7475 break; 7476 7477 case 187: 7478#line 4126 "parser.y" 7479 { (yyval.node) = 0; } 7480 break; 7481 7482 case 188: 7483#line 4127 "parser.y" 7484 {(yyval.node) = (yyvsp[(1) - (1)].node); } 7485 break; 7486 7487 case 189: 7488#line 4128 "parser.y" 7489 {(yyval.node) = (yyvsp[(1) - (1)].node); } 7490 break; 7491 7492 case 190: 7493#line 4129 "parser.y" 7494 { (yyval.node) = 0; } 7495 break; 7496 7497 case 191: 7498#line 4138 "parser.y" 7499 { 7500 if (Classprefix) { 7501 SwigType *decl = NewStringEmpty(); 7502 (yyval.node) = new_node("constructor"); 7503 Setattr((yyval.node),"storage",(yyvsp[(1) - (6)].id)); 7504 Setattr((yyval.node),"name",(yyvsp[(2) - (6)].type)); 7505 Setattr((yyval.node),"parms",(yyvsp[(4) - (6)].pl)); 7506 SwigType_add_function(decl,(yyvsp[(4) - (6)].pl)); 7507 Setattr((yyval.node),"decl",decl); 7508 Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].decl).throws); 7509 Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].decl).throwf); 7510 if (Len(scanner_ccode)) { 7511 String *code = Copy(scanner_ccode); 7512 Setattr((yyval.node),"code",code); 7513 Delete(code); 7514 } 7515 SetFlag((yyval.node),"feature:new"); 7516 } else { 7517 (yyval.node) = 0; 7518 } 7519 } 7520 break; 7521 7522 case 192: 7523#line 4163 "parser.y" 7524 { 7525 String *name = NewStringf("%s",(yyvsp[(2) - (6)].str)); 7526 if (*(Char(name)) != '~') Insert(name,0,"~"); 7527 (yyval.node) = new_node("destructor"); 7528 Setattr((yyval.node),"name",name); 7529 Delete(name); 7530 if (Len(scanner_ccode)) { 7531 String *code = Copy(scanner_ccode); 7532 Setattr((yyval.node),"code",code); 7533 Delete(code); 7534 } 7535 { 7536 String *decl = NewStringEmpty(); 7537 SwigType_add_function(decl,(yyvsp[(4) - (6)].pl)); 7538 Setattr((yyval.node),"decl",decl); 7539 Delete(decl); 7540 } 7541 Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].dtype).throws); 7542 Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].dtype).throwf); 7543 add_symbols((yyval.node)); 7544 } 7545 break; 7546 7547 case 193: 7548#line 4187 "parser.y" 7549 { 7550 String *name; 7551 char *c = 0; 7552 (yyval.node) = new_node("destructor"); 7553 /* Check for template names. If the class is a template 7554 and the constructor is missing the template part, we 7555 add it */ 7556 if (Classprefix) { 7557 c = strchr(Char(Classprefix),'<'); 7558 if (c && !Strchr((yyvsp[(3) - (7)].str),'<')) { 7559 (yyvsp[(3) - (7)].str) = NewStringf("%s%s",(yyvsp[(3) - (7)].str),c); 7560 } 7561 } 7562 Setattr((yyval.node),"storage","virtual"); 7563 name = NewStringf("%s",(yyvsp[(3) - (7)].str)); 7564 if (*(Char(name)) != '~') Insert(name,0,"~"); 7565 Setattr((yyval.node),"name",name); 7566 Delete(name); 7567 Setattr((yyval.node),"throws",(yyvsp[(7) - (7)].dtype).throws); 7568 Setattr((yyval.node),"throw",(yyvsp[(7) - (7)].dtype).throwf); 7569 if ((yyvsp[(7) - (7)].dtype).val) { 7570 Setattr((yyval.node),"value","0"); 7571 } 7572 if (Len(scanner_ccode)) { 7573 String *code = Copy(scanner_ccode); 7574 Setattr((yyval.node),"code",code); 7575 Delete(code); 7576 } 7577 { 7578 String *decl = NewStringEmpty(); 7579 SwigType_add_function(decl,(yyvsp[(5) - (7)].pl)); 7580 Setattr((yyval.node),"decl",decl); 7581 Delete(decl); 7582 } 7583 7584 add_symbols((yyval.node)); 7585 } 7586 break; 7587 7588 case 194: 7589#line 4228 "parser.y" 7590 { 7591 (yyval.node) = new_node("cdecl"); 7592 Setattr((yyval.node),"type",(yyvsp[(3) - (8)].type)); 7593 Setattr((yyval.node),"name",(yyvsp[(2) - (8)].str)); 7594 Setattr((yyval.node),"storage",(yyvsp[(1) - (8)].id)); 7595 7596 SwigType_add_function((yyvsp[(4) - (8)].type),(yyvsp[(6) - (8)].pl)); 7597 if ((yyvsp[(8) - (8)].dtype).qualifier) { 7598 SwigType_push((yyvsp[(4) - (8)].type),(yyvsp[(8) - (8)].dtype).qualifier); 7599 } 7600 Setattr((yyval.node),"decl",(yyvsp[(4) - (8)].type)); 7601 Setattr((yyval.node),"parms",(yyvsp[(6) - (8)].pl)); 7602 Setattr((yyval.node),"conversion_operator","1"); 7603 add_symbols((yyval.node)); 7604 } 7605 break; 7606 7607 case 195: 7608#line 4243 "parser.y" 7609 { 7610 SwigType *decl; 7611 (yyval.node) = new_node("cdecl"); 7612 Setattr((yyval.node),"type",(yyvsp[(3) - (8)].type)); 7613 Setattr((yyval.node),"name",(yyvsp[(2) - (8)].str)); 7614 Setattr((yyval.node),"storage",(yyvsp[(1) - (8)].id)); 7615 decl = NewStringEmpty(); 7616 SwigType_add_reference(decl); 7617 SwigType_add_function(decl,(yyvsp[(6) - (8)].pl)); 7618 if ((yyvsp[(8) - (8)].dtype).qualifier) { 7619 SwigType_push(decl,(yyvsp[(8) - (8)].dtype).qualifier); 7620 } 7621 Setattr((yyval.node),"decl",decl); 7622 Setattr((yyval.node),"parms",(yyvsp[(6) - (8)].pl)); 7623 Setattr((yyval.node),"conversion_operator","1"); 7624 add_symbols((yyval.node)); 7625 } 7626 break; 7627 7628 case 196: 7629#line 4261 "parser.y" 7630 { 7631 String *t = NewStringEmpty(); 7632 (yyval.node) = new_node("cdecl"); 7633 Setattr((yyval.node),"type",(yyvsp[(3) - (7)].type)); 7634 Setattr((yyval.node),"name",(yyvsp[(2) - (7)].str)); 7635 Setattr((yyval.node),"storage",(yyvsp[(1) - (7)].id)); 7636 SwigType_add_function(t,(yyvsp[(5) - (7)].pl)); 7637 if ((yyvsp[(7) - (7)].dtype).qualifier) { 7638 SwigType_push(t,(yyvsp[(7) - (7)].dtype).qualifier); 7639 } 7640 Setattr((yyval.node),"decl",t); 7641 Setattr((yyval.node),"parms",(yyvsp[(5) - (7)].pl)); 7642 Setattr((yyval.node),"conversion_operator","1"); 7643 add_symbols((yyval.node)); 7644 } 7645 break; 7646 7647 case 197: 7648#line 4280 "parser.y" 7649 { 7650 skip_balanced('{','}'); 7651 (yyval.node) = 0; 7652 } 7653 break; 7654 7655 case 198: 7656#line 4287 "parser.y" 7657 { 7658 (yyval.node) = new_node("access"); 7659 Setattr((yyval.node),"kind","public"); 7660 cplus_mode = CPLUS_PUBLIC; 7661 } 7662 break; 7663 7664 case 199: 7665#line 4294 "parser.y" 7666 { 7667 (yyval.node) = new_node("access"); 7668 Setattr((yyval.node),"kind","private"); 7669 cplus_mode = CPLUS_PRIVATE; 7670 } 7671 break; 7672 7673 case 200: 7674#line 4302 "parser.y" 7675 { 7676 (yyval.node) = new_node("access"); 7677 Setattr((yyval.node),"kind","protected"); 7678 cplus_mode = CPLUS_PROTECTED; 7679 } 7680 break; 7681 7682 case 201: 7683#line 4325 "parser.y" 7684 { cparse_start_line = cparse_line; skip_balanced('{','}'); 7685 } 7686 break; 7687 7688 case 202: 7689#line 4326 "parser.y" 7690 { 7691 (yyval.node) = 0; 7692 if (cplus_mode == CPLUS_PUBLIC) { 7693 if ((yyvsp[(6) - (7)].decl).id && strcmp((yyvsp[(2) - (7)].id), "class") != 0) { 7694 Nested *n = (Nested *) malloc(sizeof(Nested)); 7695 n->code = NewStringEmpty(); 7696 Printv(n->code, "typedef ", (yyvsp[(2) - (7)].id), " ", 7697 Char(scanner_ccode), " $classname_", (yyvsp[(6) - (7)].decl).id, ";\n", NIL); 7698 7699 n->name = Swig_copy_string((yyvsp[(6) - (7)].decl).id); 7700 n->line = cparse_start_line; 7701 n->type = NewStringEmpty(); 7702 n->kind = (yyvsp[(2) - (7)].id); 7703 n->unnamed = 0; 7704 SwigType_push(n->type, (yyvsp[(6) - (7)].decl).type); 7705 n->next = 0; 7706 add_nested(n); 7707 } else { 7708 Swig_warning(WARN_PARSE_NESTED_CLASS, cparse_file, cparse_line, "Nested %s not currently supported (ignored).\n", (yyvsp[(2) - (7)].id)); 7709 if (strcmp((yyvsp[(2) - (7)].id), "class") == 0) { 7710 /* For now, just treat the nested class as a forward 7711 * declaration (SF bug #909387). */ 7712 (yyval.node) = new_node("classforward"); 7713 Setfile((yyval.node),cparse_file); 7714 Setline((yyval.node),cparse_line); 7715 Setattr((yyval.node),"kind",(yyvsp[(2) - (7)].id)); 7716 Setattr((yyval.node),"name",(yyvsp[(3) - (7)].id)); 7717 Setattr((yyval.node),"sym:weak", "1"); 7718 add_symbols((yyval.node)); 7719 } 7720 } 7721 } 7722 } 7723 break; 7724 7725 case 203: 7726#line 4360 "parser.y" 7727 { cparse_start_line = cparse_line; skip_balanced('{','}'); 7728 } 7729 break; 7730 7731 case 204: 7732#line 4361 "parser.y" 7733 { 7734 (yyval.node) = 0; 7735 if (cplus_mode == CPLUS_PUBLIC) { 7736 if (strcmp((yyvsp[(2) - (6)].id),"class") == 0) { 7737 Swig_warning(WARN_PARSE_NESTED_CLASS,cparse_file, cparse_line,"Nested class not currently supported (ignored)\n"); 7738 /* Generate some code for a new class */ 7739 } else if ((yyvsp[(5) - (6)].decl).id) { 7740 /* Generate some code for a new class */ 7741 Nested *n = (Nested *) malloc(sizeof(Nested)); 7742 n->code = NewStringEmpty(); 7743 Printv(n->code, "typedef ", (yyvsp[(2) - (6)].id), " " , 7744 Char(scanner_ccode), " $classname_", (yyvsp[(5) - (6)].decl).id, ";\n",NIL); 7745 n->name = Swig_copy_string((yyvsp[(5) - (6)].decl).id); 7746 n->line = cparse_start_line; 7747 n->type = NewStringEmpty(); 7748 n->kind = (yyvsp[(2) - (6)].id); 7749 n->unnamed = 1; 7750 SwigType_push(n->type,(yyvsp[(5) - (6)].decl).type); 7751 n->next = 0; 7752 add_nested(n); 7753 } else { 7754 Swig_warning(WARN_PARSE_NESTED_CLASS, cparse_file, cparse_line, "Nested %s not currently supported (ignored).\n", (yyvsp[(2) - (6)].id)); 7755 } 7756 } 7757 } 7758 break; 7759 7760 case 205: 7761#line 4391 "parser.y" 7762 { cparse_start_line = cparse_line; skip_balanced('{','}'); 7763 } 7764 break; 7765 7766 case 206: 7767#line 4392 "parser.y" 7768 { 7769 (yyval.node) = 0; 7770 if (cplus_mode == CPLUS_PUBLIC) { 7771 Swig_warning(WARN_PARSE_NESTED_CLASS,cparse_file, cparse_line,"Nested class not currently supported (ignored)\n"); 7772 } 7773 } 7774 break; 7775 7776 case 207: 7777#line 4409 "parser.y" 7778 { (yyval.decl) = (yyvsp[(1) - (1)].decl);} 7779 break; 7780 7781 case 208: 7782#line 4410 "parser.y" 7783 { (yyval.decl).id = 0; } 7784 break; 7785 7786 case 209: 7787#line 4416 "parser.y" 7788 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7789 break; 7790 7791 case 210: 7792#line 4419 "parser.y" 7793 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7794 break; 7795 7796 case 211: 7797#line 4423 "parser.y" 7798 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7799 break; 7800 7801 case 212: 7802#line 4426 "parser.y" 7803 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7804 break; 7805 7806 case 213: 7807#line 4427 "parser.y" 7808 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7809 break; 7810 7811 case 214: 7812#line 4428 "parser.y" 7813 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7814 break; 7815 7816 case 215: 7817#line 4429 "parser.y" 7818 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7819 break; 7820 7821 case 216: 7822#line 4430 "parser.y" 7823 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7824 break; 7825 7826 case 217: 7827#line 4431 "parser.y" 7828 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7829 break; 7830 7831 case 218: 7832#line 4432 "parser.y" 7833 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7834 break; 7835 7836 case 219: 7837#line 4433 "parser.y" 7838 { (yyval.node) = (yyvsp[(1) - (1)].node); } 7839 break; 7840 7841 case 220: 7842#line 4436 "parser.y" 7843 { 7844 Clear(scanner_ccode); 7845 (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws; 7846 (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf; 7847 } 7848 break; 7849 7850 case 221: 7851#line 4441 "parser.y" 7852 { 7853 skip_balanced('{','}'); 7854 (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws; 7855 (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf; 7856 } 7857 break; 7858 7859 case 222: 7860#line 4448 "parser.y" 7861 { 7862 Clear(scanner_ccode); 7863 (yyval.dtype).val = 0; 7864 (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier; 7865 (yyval.dtype).bitfield = 0; 7866 (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws; 7867 (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf; 7868 } 7869 break; 7870 7871 case 223: 7872#line 4456 "parser.y" 7873 { 7874 Clear(scanner_ccode); 7875 (yyval.dtype).val = (yyvsp[(3) - (4)].dtype).val; 7876 (yyval.dtype).qualifier = (yyvsp[(1) - (4)].dtype).qualifier; 7877 (yyval.dtype).bitfield = 0; 7878 (yyval.dtype).throws = (yyvsp[(1) - (4)].dtype).throws; 7879 (yyval.dtype).throwf = (yyvsp[(1) - (4)].dtype).throwf; 7880 } 7881 break; 7882 7883 case 224: 7884#line 4464 "parser.y" 7885 { 7886 skip_balanced('{','}'); 7887 (yyval.dtype).val = 0; 7888 (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier; 7889 (yyval.dtype).bitfield = 0; 7890 (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws; 7891 (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf; 7892 } 7893 break; 7894 7895 case 225: 7896#line 4475 "parser.y" 7897 { } 7898 break; 7899 7900 case 226: 7901#line 4481 "parser.y" 7902 { (yyval.id) = "extern"; } 7903 break; 7904 7905 case 227: 7906#line 4482 "parser.y" 7907 { 7908 if (strcmp((yyvsp[(2) - (2)].id),"C") == 0) { 7909 (yyval.id) = "externc"; 7910 } else { 7911 Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", (yyvsp[(2) - (2)].id)); 7912 (yyval.id) = 0; 7913 } 7914 } 7915 break; 7916 7917 case 228: 7918#line 4490 "parser.y" 7919 { (yyval.id) = "static"; } 7920 break; 7921 7922 case 229: 7923#line 4491 "parser.y" 7924 { (yyval.id) = "typedef"; } 7925 break; 7926 7927 case 230: 7928#line 4492 "parser.y" 7929 { (yyval.id) = "virtual"; } 7930 break; 7931 7932 case 231: 7933#line 4493 "parser.y" 7934 { (yyval.id) = "friend"; } 7935 break; 7936 7937 case 232: 7938#line 4494 "parser.y" 7939 { (yyval.id) = "explicit"; } 7940 break; 7941 7942 case 233: 7943#line 4495 "parser.y" 7944 { (yyval.id) = 0; } 7945 break; 7946 7947 case 234: 7948#line 4502 "parser.y" 7949 { 7950 Parm *p; 7951 (yyval.pl) = (yyvsp[(1) - (1)].pl); 7952 p = (yyvsp[(1) - (1)].pl); 7953 while (p) { 7954 Replace(Getattr(p,"type"),"typename ", "", DOH_REPLACE_ANY); 7955 p = nextSibling(p); 7956 } 7957 } 7958 break; 7959 7960 case 235: 7961#line 4513 "parser.y" 7962 { 7963 set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].pl)); 7964 (yyval.pl) = (yyvsp[(1) - (2)].p); 7965 } 7966 break; 7967 7968 case 236: 7969#line 4517 "parser.y" 7970 { (yyval.pl) = 0; } 7971 break; 7972 7973 case 237: 7974#line 4520 "parser.y" 7975 { 7976 set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].pl)); 7977 (yyval.pl) = (yyvsp[(2) - (3)].p); 7978 } 7979 break; 7980 7981 case 238: 7982#line 4524 "parser.y" 7983 { (yyval.pl) = 0; } 7984 break; 7985 7986 case 239: 7987#line 4528 "parser.y" 7988 { 7989 SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type); 7990 (yyval.p) = NewParm((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).id); 7991 Setfile((yyval.p),cparse_file); 7992 Setline((yyval.p),cparse_line); 7993 if ((yyvsp[(2) - (2)].decl).defarg) { 7994 Setattr((yyval.p),"value",(yyvsp[(2) - (2)].decl).defarg); 7995 } 7996 } 7997 break; 7998 7999 case 240: 8000#line 4538 "parser.y" 8001 { 8002 (yyval.p) = NewParm(NewStringf("template<class> %s %s", (yyvsp[(5) - (7)].id),(yyvsp[(6) - (7)].str)), 0); 8003 Setfile((yyval.p),cparse_file); 8004 Setline((yyval.p),cparse_line); 8005 if ((yyvsp[(7) - (7)].dtype).val) { 8006 Setattr((yyval.p),"value",(yyvsp[(7) - (7)].dtype).val); 8007 } 8008 } 8009 break; 8010 8011 case 241: 8012#line 4546 "parser.y" 8013 { 8014 SwigType *t = NewString("v(...)"); 8015 (yyval.p) = NewParm(t, 0); 8016 Setfile((yyval.p),cparse_file); 8017 Setline((yyval.p),cparse_line); 8018 } 8019 break; 8020 8021 case 242: 8022#line 4554 "parser.y" 8023 { 8024 Parm *p; 8025 (yyval.p) = (yyvsp[(1) - (1)].p); 8026 p = (yyvsp[(1) - (1)].p); 8027 while (p) { 8028 if (Getattr(p,"type")) { 8029 Replace(Getattr(p,"type"),"typename ", "", DOH_REPLACE_ANY); 8030 } 8031 p = nextSibling(p); 8032 } 8033 } 8034 break; 8035 8036 case 243: 8037#line 4567 "parser.y" 8038 { 8039 set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].p)); 8040 (yyval.p) = (yyvsp[(1) - (2)].p); 8041 } 8042 break; 8043 8044 case 244: 8045#line 4571 "parser.y" 8046 { (yyval.p) = 0; } 8047 break; 8048 8049 case 245: 8050#line 4574 "parser.y" 8051 { 8052 set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].p)); 8053 (yyval.p) = (yyvsp[(2) - (3)].p); 8054 } 8055 break; 8056 8057 case 246: 8058#line 4578 "parser.y" 8059 { (yyval.p) = 0; } 8060 break; 8061 8062 case 247: 8063#line 4582 "parser.y" 8064 { 8065 (yyval.p) = (yyvsp[(1) - (1)].p); 8066 { 8067 /* We need to make a possible adjustment for integer parameters. */ 8068 SwigType *type; 8069 Node *n = 0; 8070 8071 while (!n) { 8072 type = Getattr((yyvsp[(1) - (1)].p),"type"); 8073 n = Swig_symbol_clookup(type,0); /* See if we can find a node that matches the typename */ 8074 if ((n) && (Strcmp(nodeType(n),"cdecl") == 0)) { 8075 SwigType *decl = Getattr(n,"decl"); 8076 if (!SwigType_isfunction(decl)) { 8077 String *value = Getattr(n,"value"); 8078 if (value) { 8079 String *v = Copy(value); 8080 Setattr((yyvsp[(1) - (1)].p),"type",v); 8081 Delete(v); 8082 n = 0; 8083 } 8084 } 8085 } else { 8086 break; 8087 } 8088 } 8089 } 8090 8091 } 8092 break; 8093 8094 case 248: 8095#line 4610 "parser.y" 8096 { 8097 (yyval.p) = NewParm(0,0); 8098 Setfile((yyval.p),cparse_file); 8099 Setline((yyval.p),cparse_line); 8100 Setattr((yyval.p),"value",(yyvsp[(1) - (1)].dtype).val); 8101 } 8102 break; 8103 8104 case 249: 8105#line 4618 "parser.y" 8106 { 8107 (yyval.dtype) = (yyvsp[(2) - (2)].dtype); 8108 if ((yyvsp[(2) - (2)].dtype).type == T_ERROR) { 8109 Swig_warning(WARN_PARSE_BAD_DEFAULT,cparse_file, cparse_line, "Can't set default argument (ignored)\n"); 8110 (yyval.dtype).val = 0; 8111 (yyval.dtype).rawval = 0; 8112 (yyval.dtype).bitfield = 0; 8113 (yyval.dtype).throws = 0; 8114 (yyval.dtype).throwf = 0; 8115 } 8116 } 8117 break; 8118 8119 case 250: 8120#line 4629 "parser.y" 8121 { 8122 (yyval.dtype) = (yyvsp[(2) - (5)].dtype); 8123 if ((yyvsp[(2) - (5)].dtype).type == T_ERROR) { 8124 Swig_warning(WARN_PARSE_BAD_DEFAULT,cparse_file, cparse_line, "Can't set default argument (ignored)\n"); 8125 (yyval.dtype) = (yyvsp[(2) - (5)].dtype); 8126 (yyval.dtype).val = 0; 8127 (yyval.dtype).rawval = 0; 8128 (yyval.dtype).bitfield = 0; 8129 (yyval.dtype).throws = 0; 8130 (yyval.dtype).throwf = 0; 8131 } else { 8132 (yyval.dtype).val = NewStringf("%s[%s]",(yyvsp[(2) - (5)].dtype).val,(yyvsp[(4) - (5)].dtype).val); 8133 } 8134 } 8135 break; 8136 8137 case 251: 8138#line 4643 "parser.y" 8139 { 8140 skip_balanced('{','}'); 8141 (yyval.dtype).val = 0; 8142 (yyval.dtype).rawval = 0; 8143 (yyval.dtype).type = T_INT; 8144 (yyval.dtype).bitfield = 0; 8145 (yyval.dtype).throws = 0; 8146 (yyval.dtype).throwf = 0; 8147 } 8148 break; 8149 8150 case 252: 8151#line 4652 "parser.y" 8152 { 8153 (yyval.dtype).val = 0; 8154 (yyval.dtype).rawval = 0; 8155 (yyval.dtype).type = 0; 8156 (yyval.dtype).bitfield = (yyvsp[(2) - (2)].dtype).val; 8157 (yyval.dtype).throws = 0; 8158 (yyval.dtype).throwf = 0; 8159 } 8160 break; 8161 8162 case 253: 8163#line 4660 "parser.y" 8164 { 8165 (yyval.dtype).val = 0; 8166 (yyval.dtype).rawval = 0; 8167 (yyval.dtype).type = T_INT; 8168 (yyval.dtype).bitfield = 0; 8169 (yyval.dtype).throws = 0; 8170 (yyval.dtype).throwf = 0; 8171 } 8172 break; 8173 8174 case 254: 8175#line 4670 "parser.y" 8176 { 8177 (yyval.decl) = (yyvsp[(1) - (2)].decl); 8178 (yyval.decl).defarg = (yyvsp[(2) - (2)].dtype).rawval ? (yyvsp[(2) - (2)].dtype).rawval : (yyvsp[(2) - (2)].dtype).val; 8179 } 8180 break; 8181 8182 case 255: 8183#line 4674 "parser.y" 8184 { 8185 (yyval.decl) = (yyvsp[(1) - (2)].decl); 8186 (yyval.decl).defarg = (yyvsp[(2) - (2)].dtype).rawval ? (yyvsp[(2) - (2)].dtype).rawval : (yyvsp[(2) - (2)].dtype).val; 8187 } 8188 break; 8189 8190 case 256: 8191#line 4678 "parser.y" 8192 { 8193 (yyval.decl).type = 0; 8194 (yyval.decl).id = 0; 8195 (yyval.decl).defarg = (yyvsp[(1) - (1)].dtype).rawval ? (yyvsp[(1) - (1)].dtype).rawval : (yyvsp[(1) - (1)].dtype).val; 8196 } 8197 break; 8198 8199 case 257: 8200#line 4685 "parser.y" 8201 { 8202 (yyval.decl) = (yyvsp[(1) - (1)].decl); 8203 if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) { 8204 Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type)); 8205 } else if (SwigType_isarray((yyvsp[(1) - (1)].decl).type)) { 8206 SwigType *ta = SwigType_pop_arrays((yyvsp[(1) - (1)].decl).type); 8207 if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) { 8208 Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type)); 8209 } else { 8210 (yyval.decl).parms = 0; 8211 } 8212 SwigType_push((yyvsp[(1) - (1)].decl).type,ta); 8213 Delete(ta); 8214 } else { 8215 (yyval.decl).parms = 0; 8216 } 8217 } 8218 break; 8219 8220 case 258: 8221#line 4702 "parser.y" 8222 { 8223 (yyval.decl) = (yyvsp[(1) - (1)].decl); 8224 if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) { 8225 Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type)); 8226 } else if (SwigType_isarray((yyvsp[(1) - (1)].decl).type)) { 8227 SwigType *ta = SwigType_pop_arrays((yyvsp[(1) - (1)].decl).type); 8228 if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) { 8229 Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type)); 8230 } else { 8231 (yyval.decl).parms = 0; 8232 } 8233 SwigType_push((yyvsp[(1) - (1)].decl).type,ta); 8234 Delete(ta); 8235 } else { 8236 (yyval.decl).parms = 0; 8237 } 8238 } 8239 break; 8240 8241 case 259: 8242#line 4719 "parser.y" 8243 { 8244 (yyval.decl).type = 0; 8245 (yyval.decl).id = 0; 8246 (yyval.decl).parms = 0; 8247 } 8248 break; 8249 8250 case 260: 8251#line 4727 "parser.y" 8252 { 8253 (yyval.decl) = (yyvsp[(2) - (2)].decl); 8254 if ((yyval.decl).type) { 8255 SwigType_push((yyvsp[(1) - (2)].type),(yyval.decl).type); 8256 Delete((yyval.decl).type); 8257 } 8258 (yyval.decl).type = (yyvsp[(1) - (2)].type); 8259 } 8260 break; 8261 8262 case 261: 8263#line 4735 "parser.y" 8264 { 8265 (yyval.decl) = (yyvsp[(3) - (3)].decl); 8266 SwigType_add_reference((yyvsp[(1) - (3)].type)); 8267 if ((yyval.decl).type) { 8268 SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type); 8269 Delete((yyval.decl).type); 8270 } 8271 (yyval.decl).type = (yyvsp[(1) - (3)].type); 8272 } 8273 break; 8274 8275 case 262: 8276#line 4744 "parser.y" 8277 { 8278 (yyval.decl) = (yyvsp[(1) - (1)].decl); 8279 if (!(yyval.decl).type) (yyval.decl).type = NewStringEmpty(); 8280 } 8281 break; 8282 8283 case 263: 8284#line 4748 "parser.y" 8285 { 8286 (yyval.decl) = (yyvsp[(2) - (2)].decl); 8287 (yyval.decl).type = NewStringEmpty(); 8288 SwigType_add_reference((yyval.decl).type); 8289 if ((yyvsp[(2) - (2)].decl).type) { 8290 SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type); 8291 Delete((yyvsp[(2) - (2)].decl).type); 8292 } 8293 } 8294 break; 8295 8296 case 264: 8297#line 4757 "parser.y" 8298 { 8299 SwigType *t = NewStringEmpty(); 8300 8301 (yyval.decl) = (yyvsp[(3) - (3)].decl); 8302 SwigType_add_memberpointer(t,(yyvsp[(1) - (3)].str)); 8303 if ((yyval.decl).type) { 8304 SwigType_push(t,(yyval.decl).type); 8305 Delete((yyval.decl).type); 8306 } 8307 (yyval.decl).type = t; 8308 } 8309 break; 8310 8311 case 265: 8312#line 4768 "parser.y" 8313 { 8314 SwigType *t = NewStringEmpty(); 8315 (yyval.decl) = (yyvsp[(4) - (4)].decl); 8316 SwigType_add_memberpointer(t,(yyvsp[(2) - (4)].str)); 8317 SwigType_push((yyvsp[(1) - (4)].type),t); 8318 if ((yyval.decl).type) { 8319 SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type); 8320 Delete((yyval.decl).type); 8321 } 8322 (yyval.decl).type = (yyvsp[(1) - (4)].type); 8323 Delete(t); 8324 } 8325 break; 8326 8327 case 266: 8328#line 4780 "parser.y" 8329 { 8330 (yyval.decl) = (yyvsp[(5) - (5)].decl); 8331 SwigType_add_memberpointer((yyvsp[(1) - (5)].type),(yyvsp[(2) - (5)].str)); 8332 SwigType_add_reference((yyvsp[(1) - (5)].type)); 8333 if ((yyval.decl).type) { 8334 SwigType_push((yyvsp[(1) - (5)].type),(yyval.decl).type); 8335 Delete((yyval.decl).type); 8336 } 8337 (yyval.decl).type = (yyvsp[(1) - (5)].type); 8338 } 8339 break; 8340 8341 case 267: 8342#line 4790 "parser.y" 8343 { 8344 SwigType *t = NewStringEmpty(); 8345 (yyval.decl) = (yyvsp[(4) - (4)].decl); 8346 SwigType_add_memberpointer(t,(yyvsp[(1) - (4)].str)); 8347 SwigType_add_reference(t); 8348 if ((yyval.decl).type) { 8349 SwigType_push(t,(yyval.decl).type); 8350 Delete((yyval.decl).type); 8351 } 8352 (yyval.decl).type = t; 8353 } 8354 break; 8355 8356 case 268: 8357#line 4803 "parser.y" 8358 { 8359 /* Note: This is non-standard C. Template declarator is allowed to follow an identifier */ 8360 (yyval.decl).id = Char((yyvsp[(1) - (1)].str)); 8361 (yyval.decl).type = 0; 8362 (yyval.decl).parms = 0; 8363 (yyval.decl).have_parms = 0; 8364 } 8365 break; 8366 8367 case 269: 8368#line 4810 "parser.y" 8369 { 8370 (yyval.decl).id = Char(NewStringf("~%s",(yyvsp[(2) - (2)].str))); 8371 (yyval.decl).type = 0; 8372 (yyval.decl).parms = 0; 8373 (yyval.decl).have_parms = 0; 8374 } 8375 break; 8376 8377 case 270: 8378#line 4818 "parser.y" 8379 { 8380 (yyval.decl).id = Char((yyvsp[(2) - (3)].str)); 8381 (yyval.decl).type = 0; 8382 (yyval.decl).parms = 0; 8383 (yyval.decl).have_parms = 0; 8384 } 8385 break; 8386 8387 case 271: 8388#line 4834 "parser.y" 8389 { 8390 (yyval.decl) = (yyvsp[(3) - (4)].decl); 8391 if ((yyval.decl).type) { 8392 SwigType_push((yyvsp[(2) - (4)].type),(yyval.decl).type); 8393 Delete((yyval.decl).type); 8394 } 8395 (yyval.decl).type = (yyvsp[(2) - (4)].type); 8396 } 8397 break; 8398 8399 case 272: 8400#line 4842 "parser.y" 8401 { 8402 SwigType *t; 8403 (yyval.decl) = (yyvsp[(4) - (5)].decl); 8404 t = NewStringEmpty(); 8405 SwigType_add_memberpointer(t,(yyvsp[(2) - (5)].str)); 8406 if ((yyval.decl).type) { 8407 SwigType_push(t,(yyval.decl).type); 8408 Delete((yyval.decl).type); 8409 } 8410 (yyval.decl).type = t; 8411 } 8412 break; 8413 8414 case 273: 8415#line 4853 "parser.y" 8416 { 8417 SwigType *t; 8418 (yyval.decl) = (yyvsp[(1) - (3)].decl); 8419 t = NewStringEmpty(); 8420 SwigType_add_array(t,(char*)""); 8421 if ((yyval.decl).type) { 8422 SwigType_push(t,(yyval.decl).type); 8423 Delete((yyval.decl).type); 8424 } 8425 (yyval.decl).type = t; 8426 } 8427 break; 8428 8429 case 274: 8430#line 4864 "parser.y" 8431 { 8432 SwigType *t; 8433 (yyval.decl) = (yyvsp[(1) - (4)].decl); 8434 t = NewStringEmpty(); 8435 SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val); 8436 if ((yyval.decl).type) { 8437 SwigType_push(t,(yyval.decl).type); 8438 Delete((yyval.decl).type); 8439 } 8440 (yyval.decl).type = t; 8441 } 8442 break; 8443 8444 case 275: 8445#line 4875 "parser.y" 8446 { 8447 SwigType *t; 8448 (yyval.decl) = (yyvsp[(1) - (4)].decl); 8449 t = NewStringEmpty(); 8450 SwigType_add_function(t,(yyvsp[(3) - (4)].pl)); 8451 if (!(yyval.decl).have_parms) { 8452 (yyval.decl).parms = (yyvsp[(3) - (4)].pl); 8453 (yyval.decl).have_parms = 1; 8454 } 8455 if (!(yyval.decl).type) { 8456 (yyval.decl).type = t; 8457 } else { 8458 SwigType_push(t, (yyval.decl).type); 8459 Delete((yyval.decl).type); 8460 (yyval.decl).type = t; 8461 } 8462 } 8463 break; 8464 8465 case 276: 8466#line 4894 "parser.y" 8467 { 8468 /* Note: This is non-standard C. Template declarator is allowed to follow an identifier */ 8469 (yyval.decl).id = Char((yyvsp[(1) - (1)].str)); 8470 (yyval.decl).type = 0; 8471 (yyval.decl).parms = 0; 8472 (yyval.decl).have_parms = 0; 8473 } 8474 break; 8475 8476 case 277: 8477#line 4902 "parser.y" 8478 { 8479 (yyval.decl).id = Char(NewStringf("~%s",(yyvsp[(2) - (2)].str))); 8480 (yyval.decl).type = 0; 8481 (yyval.decl).parms = 0; 8482 (yyval.decl).have_parms = 0; 8483 } 8484 break; 8485 8486 case 278: 8487#line 4919 "parser.y" 8488 { 8489 (yyval.decl) = (yyvsp[(3) - (4)].decl); 8490 if ((yyval.decl).type) { 8491 SwigType_push((yyvsp[(2) - (4)].type),(yyval.decl).type); 8492 Delete((yyval.decl).type); 8493 } 8494 (yyval.decl).type = (yyvsp[(2) - (4)].type); 8495 } 8496 break; 8497 8498 case 279: 8499#line 4927 "parser.y" 8500 { 8501 (yyval.decl) = (yyvsp[(3) - (4)].decl); 8502 if (!(yyval.decl).type) { 8503 (yyval.decl).type = NewStringEmpty(); 8504 } 8505 SwigType_add_reference((yyval.decl).type); 8506 } 8507 break; 8508 8509 case 280: 8510#line 4934 "parser.y" 8511 { 8512 SwigType *t; 8513 (yyval.decl) = (yyvsp[(4) - (5)].decl); 8514 t = NewStringEmpty(); 8515 SwigType_add_memberpointer(t,(yyvsp[(2) - (5)].str)); 8516 if ((yyval.decl).type) { 8517 SwigType_push(t,(yyval.decl).type); 8518 Delete((yyval.decl).type); 8519 } 8520 (yyval.decl).type = t; 8521 } 8522 break; 8523 8524 case 281: 8525#line 4945 "parser.y" 8526 { 8527 SwigType *t; 8528 (yyval.decl) = (yyvsp[(1) - (3)].decl); 8529 t = NewStringEmpty(); 8530 SwigType_add_array(t,(char*)""); 8531 if ((yyval.decl).type) { 8532 SwigType_push(t,(yyval.decl).type); 8533 Delete((yyval.decl).type); 8534 } 8535 (yyval.decl).type = t; 8536 } 8537 break; 8538 8539 case 282: 8540#line 4956 "parser.y" 8541 { 8542 SwigType *t; 8543 (yyval.decl) = (yyvsp[(1) - (4)].decl); 8544 t = NewStringEmpty(); 8545 SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val); 8546 if ((yyval.decl).type) { 8547 SwigType_push(t,(yyval.decl).type); 8548 Delete((yyval.decl).type); 8549 } 8550 (yyval.decl).type = t; 8551 } 8552 break; 8553 8554 case 283: 8555#line 4967 "parser.y" 8556 { 8557 SwigType *t; 8558 (yyval.decl) = (yyvsp[(1) - (4)].decl); 8559 t = NewStringEmpty(); 8560 SwigType_add_function(t,(yyvsp[(3) - (4)].pl)); 8561 if (!(yyval.decl).have_parms) { 8562 (yyval.decl).parms = (yyvsp[(3) - (4)].pl); 8563 (yyval.decl).have_parms = 1; 8564 } 8565 if (!(yyval.decl).type) { 8566 (yyval.decl).type = t; 8567 } else { 8568 SwigType_push(t, (yyval.decl).type); 8569 Delete((yyval.decl).type); 8570 (yyval.decl).type = t; 8571 } 8572 } 8573 break; 8574 8575 case 284: 8576#line 4986 "parser.y" 8577 { 8578 (yyval.decl).type = (yyvsp[(1) - (1)].type); 8579 (yyval.decl).id = 0; 8580 (yyval.decl).parms = 0; 8581 (yyval.decl).have_parms = 0; 8582 } 8583 break; 8584 8585 case 285: 8586#line 4992 "parser.y" 8587 { 8588 (yyval.decl) = (yyvsp[(2) - (2)].decl); 8589 SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type); 8590 (yyval.decl).type = (yyvsp[(1) - (2)].type); 8591 Delete((yyvsp[(2) - (2)].decl).type); 8592 } 8593 break; 8594 8595 case 286: 8596#line 4998 "parser.y" 8597 { 8598 (yyval.decl).type = (yyvsp[(1) - (2)].type); 8599 SwigType_add_reference((yyval.decl).type); 8600 (yyval.decl).id = 0; 8601 (yyval.decl).parms = 0; 8602 (yyval.decl).have_parms = 0; 8603 } 8604 break; 8605 8606 case 287: 8607#line 5005 "parser.y" 8608 { 8609 (yyval.decl) = (yyvsp[(3) - (3)].decl); 8610 SwigType_add_reference((yyvsp[(1) - (3)].type)); 8611 if ((yyval.decl).type) { 8612 SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type); 8613 Delete((yyval.decl).type); 8614 } 8615 (yyval.decl).type = (yyvsp[(1) - (3)].type); 8616 } 8617 break; 8618 8619 case 288: 8620#line 5014 "parser.y" 8621 { 8622 (yyval.decl) = (yyvsp[(1) - (1)].decl); 8623 } 8624 break; 8625 8626 case 289: 8627#line 5017 "parser.y" 8628 { 8629 (yyval.decl) = (yyvsp[(2) - (2)].decl); 8630 (yyval.decl).type = NewStringEmpty(); 8631 SwigType_add_reference((yyval.decl).type); 8632 if ((yyvsp[(2) - (2)].decl).type) { 8633 SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type); 8634 Delete((yyvsp[(2) - (2)].decl).type); 8635 } 8636 } 8637 break; 8638 8639 case 290: 8640#line 5026 "parser.y" 8641 { 8642 (yyval.decl).id = 0; 8643 (yyval.decl).parms = 0; 8644 (yyval.decl).have_parms = 0; 8645 (yyval.decl).type = NewStringEmpty(); 8646 SwigType_add_reference((yyval.decl).type); 8647 } 8648 break; 8649 8650 case 291: 8651#line 5033 "parser.y" 8652 { 8653 (yyval.decl).type = NewStringEmpty(); 8654 SwigType_add_memberpointer((yyval.decl).type,(yyvsp[(1) - (2)].str)); 8655 (yyval.decl).id = 0; 8656 (yyval.decl).parms = 0; 8657 (yyval.decl).have_parms = 0; 8658 } 8659 break; 8660 8661 case 292: 8662#line 5040 "parser.y" 8663 { 8664 SwigType *t = NewStringEmpty(); 8665 (yyval.decl).type = (yyvsp[(1) - (3)].type); 8666 (yyval.decl).id = 0; 8667 (yyval.decl).parms = 0; 8668 (yyval.decl).have_parms = 0; 8669 SwigType_add_memberpointer(t,(yyvsp[(2) - (3)].str)); 8670 SwigType_push((yyval.decl).type,t); 8671 Delete(t); 8672 } 8673 break; 8674 8675 case 293: 8676#line 5050 "parser.y" 8677 { 8678 (yyval.decl) = (yyvsp[(4) - (4)].decl); 8679 SwigType_add_memberpointer((yyvsp[(1) - (4)].type),(yyvsp[(2) - (4)].str)); 8680 if ((yyval.decl).type) { 8681 SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type); 8682 Delete((yyval.decl).type); 8683 } 8684 (yyval.decl).type = (yyvsp[(1) - (4)].type); 8685 } 8686 break; 8687 8688 case 294: 8689#line 5061 "parser.y" 8690 { 8691 SwigType *t; 8692 (yyval.decl) = (yyvsp[(1) - (3)].decl); 8693 t = NewStringEmpty(); 8694 SwigType_add_array(t,(char*)""); 8695 if ((yyval.decl).type) { 8696 SwigType_push(t,(yyval.decl).type); 8697 Delete((yyval.decl).type); 8698 } 8699 (yyval.decl).type = t; 8700 } 8701 break; 8702 8703 case 295: 8704#line 5072 "parser.y" 8705 { 8706 SwigType *t; 8707 (yyval.decl) = (yyvsp[(1) - (4)].decl); 8708 t = NewStringEmpty(); 8709 SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val); 8710 if ((yyval.decl).type) { 8711 SwigType_push(t,(yyval.decl).type); 8712 Delete((yyval.decl).type); 8713 } 8714 (yyval.decl).type = t; 8715 } 8716 break; 8717 8718 case 296: 8719#line 5083 "parser.y" 8720 { 8721 (yyval.decl).type = NewStringEmpty(); 8722 (yyval.decl).id = 0; 8723 (yyval.decl).parms = 0; 8724 (yyval.decl).have_parms = 0; 8725 SwigType_add_array((yyval.decl).type,(char*)""); 8726 } 8727 break; 8728 8729 case 297: 8730#line 5090 "parser.y" 8731 { 8732 (yyval.decl).type = NewStringEmpty(); 8733 (yyval.decl).id = 0; 8734 (yyval.decl).parms = 0; 8735 (yyval.decl).have_parms = 0; 8736 SwigType_add_array((yyval.decl).type,(yyvsp[(2) - (3)].dtype).val); 8737 } 8738 break; 8739 8740 case 298: 8741#line 5097 "parser.y" 8742 { 8743 (yyval.decl) = (yyvsp[(2) - (3)].decl); 8744 } 8745 break; 8746 8747 case 299: 8748#line 5100 "parser.y" 8749 { 8750 SwigType *t; 8751 (yyval.decl) = (yyvsp[(1) - (4)].decl); 8752 t = NewStringEmpty(); 8753 SwigType_add_function(t,(yyvsp[(3) - (4)].pl)); 8754 if (!(yyval.decl).type) { 8755 (yyval.decl).type = t; 8756 } else { 8757 SwigType_push(t,(yyval.decl).type); 8758 Delete((yyval.decl).type); 8759 (yyval.decl).type = t; 8760 } 8761 if (!(yyval.decl).have_parms) { 8762 (yyval.decl).parms = (yyvsp[(3) - (4)].pl); 8763 (yyval.decl).have_parms = 1; 8764 } 8765 } 8766 break; 8767 8768 case 300: 8769#line 5117 "parser.y" 8770 { 8771 (yyval.decl).type = NewStringEmpty(); 8772 SwigType_add_function((yyval.decl).type,(yyvsp[(2) - (3)].pl)); 8773 (yyval.decl).parms = (yyvsp[(2) - (3)].pl); 8774 (yyval.decl).have_parms = 1; 8775 (yyval.decl).id = 0; 8776 } 8777 break; 8778 8779 case 301: 8780#line 5127 "parser.y" 8781 { 8782 (yyval.type) = NewStringEmpty(); 8783 SwigType_add_pointer((yyval.type)); 8784 SwigType_push((yyval.type),(yyvsp[(2) - (3)].str)); 8785 SwigType_push((yyval.type),(yyvsp[(3) - (3)].type)); 8786 Delete((yyvsp[(3) - (3)].type)); 8787 } 8788 break; 8789 8790 case 302: 8791#line 5134 "parser.y" 8792 { 8793 (yyval.type) = NewStringEmpty(); 8794 SwigType_add_pointer((yyval.type)); 8795 SwigType_push((yyval.type),(yyvsp[(2) - (2)].type)); 8796 Delete((yyvsp[(2) - (2)].type)); 8797 } 8798 break; 8799 8800 case 303: 8801#line 5140 "parser.y" 8802 { 8803 (yyval.type) = NewStringEmpty(); 8804 SwigType_add_pointer((yyval.type)); 8805 SwigType_push((yyval.type),(yyvsp[(2) - (2)].str)); 8806 } 8807 break; 8808 8809 case 304: 8810#line 5145 "parser.y" 8811 { 8812 (yyval.type) = NewStringEmpty(); 8813 SwigType_add_pointer((yyval.type)); 8814 } 8815 break; 8816 8817 case 305: 8818#line 5151 "parser.y" 8819 { 8820 (yyval.str) = NewStringEmpty(); 8821 if ((yyvsp[(1) - (1)].id)) SwigType_add_qualifier((yyval.str),(yyvsp[(1) - (1)].id)); 8822 } 8823 break; 8824 8825 case 306: 8826#line 5155 "parser.y" 8827 { 8828 (yyval.str) = (yyvsp[(2) - (2)].str); 8829 if ((yyvsp[(1) - (2)].id)) SwigType_add_qualifier((yyval.str),(yyvsp[(1) - (2)].id)); 8830 } 8831 break; 8832 8833 case 307: 8834#line 5161 "parser.y" 8835 { (yyval.id) = "const"; } 8836 break; 8837 8838 case 308: 8839#line 5162 "parser.y" 8840 { (yyval.id) = "volatile"; } 8841 break; 8842 8843 case 309: 8844#line 5163 "parser.y" 8845 { (yyval.id) = 0; } 8846 break; 8847 8848 case 310: 8849#line 5169 "parser.y" 8850 { 8851 (yyval.type) = (yyvsp[(1) - (1)].type); 8852 Replace((yyval.type),"typename ","", DOH_REPLACE_ANY); 8853 } 8854 break; 8855 8856 case 311: 8857#line 5175 "parser.y" 8858 { 8859 (yyval.type) = (yyvsp[(2) - (2)].type); 8860 SwigType_push((yyval.type),(yyvsp[(1) - (2)].str)); 8861 } 8862 break; 8863 8864 case 312: 8865#line 5179 "parser.y" 8866 { (yyval.type) = (yyvsp[(1) - (1)].type); } 8867 break; 8868 8869 case 313: 8870#line 5180 "parser.y" 8871 { 8872 (yyval.type) = (yyvsp[(1) - (2)].type); 8873 SwigType_push((yyval.type),(yyvsp[(2) - (2)].str)); 8874 } 8875 break; 8876 8877 case 314: 8878#line 5184 "parser.y" 8879 { 8880 (yyval.type) = (yyvsp[(2) - (3)].type); 8881 SwigType_push((yyval.type),(yyvsp[(3) - (3)].str)); 8882 SwigType_push((yyval.type),(yyvsp[(1) - (3)].str)); 8883 } 8884 break; 8885 8886 case 315: 8887#line 5191 "parser.y" 8888 { (yyval.type) = (yyvsp[(1) - (1)].type); 8889 /* Printf(stdout,"primitive = '%s'\n", $$);*/ 8890 } 8891 break; 8892 8893 case 316: 8894#line 5194 "parser.y" 8895 { (yyval.type) = (yyvsp[(1) - (1)].type); } 8896 break; 8897 8898 case 317: 8899#line 5195 "parser.y" 8900 { (yyval.type) = (yyvsp[(1) - (1)].type); } 8901 break; 8902 8903 case 318: 8904#line 5196 "parser.y" 8905 { (yyval.type) = NewStringf("%s%s",(yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].id)); } 8906 break; 8907 8908 case 319: 8909#line 5197 "parser.y" 8910 { (yyval.type) = NewStringf("enum %s", (yyvsp[(2) - (2)].str)); } 8911 break; 8912 8913 case 320: 8914#line 5198 "parser.y" 8915 { (yyval.type) = (yyvsp[(1) - (1)].type); } 8916 break; 8917 8918 case 321: 8919#line 5200 "parser.y" 8920 { 8921 (yyval.type) = (yyvsp[(1) - (1)].str); 8922 } 8923 break; 8924 8925 case 322: 8926#line 5203 "parser.y" 8927 { 8928 (yyval.type) = NewStringf("%s %s", (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].str)); 8929 } 8930 break; 8931 8932 case 323: 8933#line 5208 "parser.y" 8934 { 8935 if (!(yyvsp[(1) - (1)].ptype).type) (yyvsp[(1) - (1)].ptype).type = NewString("int"); 8936 if ((yyvsp[(1) - (1)].ptype).us) { 8937 (yyval.type) = NewStringf("%s %s", (yyvsp[(1) - (1)].ptype).us, (yyvsp[(1) - (1)].ptype).type); 8938 Delete((yyvsp[(1) - (1)].ptype).us); 8939 Delete((yyvsp[(1) - (1)].ptype).type); 8940 } else { 8941 (yyval.type) = (yyvsp[(1) - (1)].ptype).type; 8942 } 8943 if (Cmp((yyval.type),"signed int") == 0) { 8944 Delete((yyval.type)); 8945 (yyval.type) = NewString("int"); 8946 } else if (Cmp((yyval.type),"signed long") == 0) { 8947 Delete((yyval.type)); 8948 (yyval.type) = NewString("long"); 8949 } else if (Cmp((yyval.type),"signed short") == 0) { 8950 Delete((yyval.type)); 8951 (yyval.type) = NewString("short"); 8952 } else if (Cmp((yyval.type),"signed long long") == 0) { 8953 Delete((yyval.type)); 8954 (yyval.type) = NewString("long long"); 8955 } 8956 } 8957 break; 8958 8959 case 324: 8960#line 5233 "parser.y" 8961 { 8962 (yyval.ptype) = (yyvsp[(1) - (1)].ptype); 8963 } 8964 break; 8965 8966 case 325: 8967#line 5236 "parser.y" 8968 { 8969 if ((yyvsp[(1) - (2)].ptype).us && (yyvsp[(2) - (2)].ptype).us) { 8970 Swig_error(cparse_file, cparse_line, "Extra %s specifier.\n", (yyvsp[(2) - (2)].ptype).us); 8971 } 8972 (yyval.ptype) = (yyvsp[(2) - (2)].ptype); 8973 if ((yyvsp[(1) - (2)].ptype).us) (yyval.ptype).us = (yyvsp[(1) - (2)].ptype).us; 8974 if ((yyvsp[(1) - (2)].ptype).type) { 8975 if (!(yyvsp[(2) - (2)].ptype).type) (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type; 8976 else { 8977 int err = 0; 8978 if ((Cmp((yyvsp[(1) - (2)].ptype).type,"long") == 0)) { 8979 if ((Cmp((yyvsp[(2) - (2)].ptype).type,"long") == 0) || (Strncmp((yyvsp[(2) - (2)].ptype).type,"double",6) == 0)) { 8980 (yyval.ptype).type = NewStringf("long %s", (yyvsp[(2) - (2)].ptype).type); 8981 } else if (Cmp((yyvsp[(2) - (2)].ptype).type,"int") == 0) { 8982 (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type; 8983 } else { 8984 err = 1; 8985 } 8986 } else if ((Cmp((yyvsp[(1) - (2)].ptype).type,"short")) == 0) { 8987 if (Cmp((yyvsp[(2) - (2)].ptype).type,"int") == 0) { 8988 (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type; 8989 } else { 8990 err = 1; 8991 } 8992 } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"int") == 0) { 8993 (yyval.ptype).type = (yyvsp[(2) - (2)].ptype).type; 8994 } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"double") == 0) { 8995 if (Cmp((yyvsp[(2) - (2)].ptype).type,"long") == 0) { 8996 (yyval.ptype).type = NewString("long double"); 8997 } else if (Cmp((yyvsp[(2) - (2)].ptype).type,"complex") == 0) { 8998 (yyval.ptype).type = NewString("double complex"); 8999 } else { 9000 err = 1; 9001 } 9002 } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"float") == 0) { 9003 if (Cmp((yyvsp[(2) - (2)].ptype).type,"complex") == 0) { 9004 (yyval.ptype).type = NewString("float complex"); 9005 } else { 9006 err = 1; 9007 } 9008 } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"complex") == 0) { 9009 (yyval.ptype).type = NewStringf("%s complex", (yyvsp[(2) - (2)].ptype).type); 9010 } else { 9011 err = 1; 9012 } 9013 if (err) { 9014 Swig_error(cparse_file, cparse_line, "Extra %s specifier.\n", (yyvsp[(1) - (2)].ptype).type); 9015 } 9016 } 9017 } 9018 } 9019 break; 9020 9021 case 326: 9022#line 5290 "parser.y" 9023 { 9024 (yyval.ptype).type = NewString("int"); 9025 (yyval.ptype).us = 0; 9026 } 9027 break; 9028 9029 case 327: 9030#line 5294 "parser.y" 9031 { 9032 (yyval.ptype).type = NewString("short"); 9033 (yyval.ptype).us = 0; 9034 } 9035 break; 9036 9037 case 328: 9038#line 5298 "parser.y" 9039 { 9040 (yyval.ptype).type = NewString("long"); 9041 (yyval.ptype).us = 0; 9042 } 9043 break; 9044 9045 case 329: 9046#line 5302 "parser.y" 9047 { 9048 (yyval.ptype).type = NewString("char"); 9049 (yyval.ptype).us = 0; 9050 } 9051 break; 9052 9053 case 330: 9054#line 5306 "parser.y" 9055 { 9056 (yyval.ptype).type = NewString("wchar_t"); 9057 (yyval.ptype).us = 0; 9058 } 9059 break; 9060 9061 case 331: 9062#line 5310 "parser.y" 9063 { 9064 (yyval.ptype).type = NewString("float"); 9065 (yyval.ptype).us = 0; 9066 } 9067 break; 9068 9069 case 332: 9070#line 5314 "parser.y" 9071 { 9072 (yyval.ptype).type = NewString("double"); 9073 (yyval.ptype).us = 0; 9074 } 9075 break; 9076 9077 case 333: 9078#line 5318 "parser.y" 9079 { 9080 (yyval.ptype).us = NewString("signed"); 9081 (yyval.ptype).type = 0; 9082 } 9083 break; 9084 9085 case 334: 9086#line 5322 "parser.y" 9087 { 9088 (yyval.ptype).us = NewString("unsigned"); 9089 (yyval.ptype).type = 0; 9090 } 9091 break; 9092 9093 case 335: 9094#line 5326 "parser.y" 9095 { 9096 (yyval.ptype).type = NewString("complex"); 9097 (yyval.ptype).us = 0; 9098 } 9099 break; 9100 9101 case 336: 9102#line 5330 "parser.y" 9103 { 9104 (yyval.ptype).type = NewString("__int8"); 9105 (yyval.ptype).us = 0; 9106 } 9107 break; 9108 9109 case 337: 9110#line 5334 "parser.y" 9111 { 9112 (yyval.ptype).type = NewString("__int16"); 9113 (yyval.ptype).us = 0; 9114 } 9115 break; 9116 9117 case 338: 9118#line 5338 "parser.y" 9119 { 9120 (yyval.ptype).type = NewString("__int32"); 9121 (yyval.ptype).us = 0; 9122 } 9123 break; 9124 9125 case 339: 9126#line 5342 "parser.y" 9127 { 9128 (yyval.ptype).type = NewString("__int64"); 9129 (yyval.ptype).us = 0; 9130 } 9131 break; 9132 9133 case 340: 9134#line 5348 "parser.y" 9135 { /* scanner_check_typedef(); */ } 9136 break; 9137 9138 case 341: 9139#line 5348 "parser.y" 9140 { 9141 (yyval.dtype) = (yyvsp[(2) - (2)].dtype); 9142 if ((yyval.dtype).type == T_STRING) { 9143 (yyval.dtype).rawval = NewStringf("\"%(escape)s\"",(yyval.dtype).val); 9144 } else if ((yyval.dtype).type != T_CHAR) { 9145 (yyval.dtype).rawval = 0; 9146 } 9147 (yyval.dtype).bitfield = 0; 9148 (yyval.dtype).throws = 0; 9149 (yyval.dtype).throwf = 0; 9150 scanner_ignore_typedef(); 9151 } 9152 break; 9153 9154 case 342: 9155#line 5374 "parser.y" 9156 { (yyval.id) = (yyvsp[(1) - (1)].id); } 9157 break; 9158 9159 case 343: 9160#line 5375 "parser.y" 9161 { (yyval.id) = (char *) 0;} 9162 break; 9163 9164 case 344: 9165#line 5378 "parser.y" 9166 { 9167 9168 /* Ignore if there is a trailing comma in the enum list */ 9169 if ((yyvsp[(3) - (3)].node)) { 9170 Node *leftSibling = Getattr((yyvsp[(1) - (3)].node),"_last"); 9171 if (!leftSibling) { 9172 leftSibling=(yyvsp[(1) - (3)].node); 9173 } 9174 set_nextSibling(leftSibling,(yyvsp[(3) - (3)].node)); 9175 Setattr((yyvsp[(1) - (3)].node),"_last",(yyvsp[(3) - (3)].node)); 9176 } 9177 (yyval.node) = (yyvsp[(1) - (3)].node); 9178 } 9179 break; 9180 9181 case 345: 9182#line 5391 "parser.y" 9183 { 9184 (yyval.node) = (yyvsp[(1) - (1)].node); 9185 if ((yyvsp[(1) - (1)].node)) { 9186 Setattr((yyvsp[(1) - (1)].node),"_last",(yyvsp[(1) - (1)].node)); 9187 } 9188 } 9189 break; 9190 9191 case 346: 9192#line 5399 "parser.y" 9193 { 9194 SwigType *type = NewSwigType(T_INT); 9195 (yyval.node) = new_node("enumitem"); 9196 Setattr((yyval.node),"name",(yyvsp[(1) - (1)].id)); 9197 Setattr((yyval.node),"type",type); 9198 SetFlag((yyval.node),"feature:immutable"); 9199 Delete(type); 9200 } 9201 break; 9202 9203 case 347: 9204#line 5407 "parser.y" 9205 { 9206 (yyval.node) = new_node("enumitem"); 9207 Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id)); 9208 Setattr((yyval.node),"enumvalue", (yyvsp[(3) - (3)].dtype).val); 9209 if ((yyvsp[(3) - (3)].dtype).type == T_CHAR) { 9210 SwigType *type = NewSwigType(T_CHAR); 9211 Setattr((yyval.node),"value",NewStringf("\'%(escape)s\'", (yyvsp[(3) - (3)].dtype).val)); 9212 Setattr((yyval.node),"type",type); 9213 Delete(type); 9214 } else { 9215 SwigType *type = NewSwigType(T_INT); 9216 Setattr((yyval.node),"value",(yyvsp[(1) - (3)].id)); 9217 Setattr((yyval.node),"type",type); 9218 Delete(type); 9219 } 9220 SetFlag((yyval.node),"feature:immutable"); 9221 } 9222 break; 9223 9224 case 348: 9225#line 5424 "parser.y" 9226 { (yyval.node) = 0; } 9227 break; 9228 9229 case 349: 9230#line 5427 "parser.y" 9231 { 9232 (yyval.dtype) = (yyvsp[(1) - (1)].dtype); 9233 if (((yyval.dtype).type != T_INT) && ((yyval.dtype).type != T_UINT) && 9234 ((yyval.dtype).type != T_LONG) && ((yyval.dtype).type != T_ULONG) && 9235 ((yyval.dtype).type != T_SHORT) && ((yyval.dtype).type != T_USHORT) && 9236 ((yyval.dtype).type != T_SCHAR) && ((yyval.dtype).type != T_UCHAR) && 9237 ((yyval.dtype).type != T_CHAR)) { 9238 Swig_error(cparse_file,cparse_line,"Type error. Expecting an int\n"); 9239 } 9240 if ((yyval.dtype).type == T_CHAR) (yyval.dtype).type = T_INT; 9241 } 9242 break; 9243 9244 case 350: 9245#line 5442 "parser.y" 9246 { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); } 9247 break; 9248 9249 case 351: 9250#line 5443 "parser.y" 9251 { 9252 Node *n; 9253 (yyval.dtype).val = (yyvsp[(1) - (1)].type); 9254 (yyval.dtype).type = T_INT; 9255 /* Check if value is in scope */ 9256 n = Swig_symbol_clookup((yyvsp[(1) - (1)].type),0); 9257 if (n) { 9258 /* A band-aid for enum values used in expressions. */ 9259 if (Strcmp(nodeType(n),"enumitem") == 0) { 9260 String *q = Swig_symbol_qualified(n); 9261 if (q) { 9262 (yyval.dtype).val = NewStringf("%s::%s", q, Getattr(n,"name")); 9263 Delete(q); 9264 } 9265 } 9266 } 9267 } 9268 break; 9269 9270 case 352: 9271#line 5462 "parser.y" 9272 { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); } 9273 break; 9274 9275 case 353: 9276#line 5463 "parser.y" 9277 { 9278 (yyval.dtype).val = NewString((yyvsp[(1) - (1)].id)); 9279 (yyval.dtype).type = T_STRING; 9280 } 9281 break; 9282 9283 case 354: 9284#line 5467 "parser.y" 9285 { 9286 SwigType_push((yyvsp[(3) - (5)].type),(yyvsp[(4) - (5)].decl).type); 9287 (yyval.dtype).val = NewStringf("sizeof(%s)",SwigType_str((yyvsp[(3) - (5)].type),0)); 9288 (yyval.dtype).type = T_ULONG; 9289 } 9290 break; 9291 9292 case 355: 9293#line 5472 "parser.y" 9294 { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); } 9295 break; 9296 9297 case 356: 9298#line 5473 "parser.y" 9299 { 9300 (yyval.dtype).val = NewString((yyvsp[(1) - (1)].str)); 9301 if (Len((yyval.dtype).val)) { 9302 (yyval.dtype).rawval = NewStringf("'%(escape)s'", (yyval.dtype).val); 9303 } else { 9304 (yyval.dtype).rawval = NewString("'\\0'"); 9305 } 9306 (yyval.dtype).type = T_CHAR; 9307 (yyval.dtype).bitfield = 0; 9308 (yyval.dtype).throws = 0; 9309 (yyval.dtype).throwf = 0; 9310 } 9311 break; 9312 9313 case 357: 9314#line 5487 "parser.y" 9315 { 9316 (yyval.dtype).val = NewStringf("(%s)",(yyvsp[(2) - (3)].dtype).val); 9317 (yyval.dtype).type = (yyvsp[(2) - (3)].dtype).type; 9318 } 9319 break; 9320 9321 case 358: 9322#line 5494 "parser.y" 9323 { 9324 (yyval.dtype) = (yyvsp[(4) - (4)].dtype); 9325 if ((yyvsp[(4) - (4)].dtype).type != T_STRING) { 9326 switch ((yyvsp[(2) - (4)].dtype).type) { 9327 case T_FLOAT: 9328 case T_DOUBLE: 9329 case T_LONGDOUBLE: 9330 case T_FLTCPLX: 9331 case T_DBLCPLX: 9332 (yyval.dtype).val = NewStringf("(%s)%s", (yyvsp[(2) - (4)].dtype).val, (yyvsp[(4) - (4)].dtype).val); /* SwigType_str and decimal points don't mix! */ 9333 break; 9334 default: 9335 (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (4)].dtype).val,0), (yyvsp[(4) - (4)].dtype).val); 9336 break; 9337 } 9338 } 9339 } 9340 break; 9341 9342 case 359: 9343#line 5511 "parser.y" 9344 { 9345 (yyval.dtype) = (yyvsp[(5) - (5)].dtype); 9346 if ((yyvsp[(5) - (5)].dtype).type != T_STRING) { 9347 SwigType_push((yyvsp[(2) - (5)].dtype).val,(yyvsp[(3) - (5)].type)); 9348 (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (5)].dtype).val,0), (yyvsp[(5) - (5)].dtype).val); 9349 } 9350 } 9351 break; 9352 9353 case 360: 9354#line 5518 "parser.y" 9355 { 9356 (yyval.dtype) = (yyvsp[(5) - (5)].dtype); 9357 if ((yyvsp[(5) - (5)].dtype).type != T_STRING) { 9358 SwigType_add_reference((yyvsp[(2) - (5)].dtype).val); 9359 (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (5)].dtype).val,0), (yyvsp[(5) - (5)].dtype).val); 9360 } 9361 } 9362 break; 9363 9364 case 361: 9365#line 5525 "parser.y" 9366 { 9367 (yyval.dtype) = (yyvsp[(6) - (6)].dtype); 9368 if ((yyvsp[(6) - (6)].dtype).type != T_STRING) { 9369 SwigType_push((yyvsp[(2) - (6)].dtype).val,(yyvsp[(3) - (6)].type)); 9370 SwigType_add_reference((yyvsp[(2) - (6)].dtype).val); 9371 (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (6)].dtype).val,0), (yyvsp[(6) - (6)].dtype).val); 9372 } 9373 } 9374 break; 9375 9376 case 362: 9377#line 5533 "parser.y" 9378 { 9379 (yyval.dtype) = (yyvsp[(2) - (2)].dtype); 9380 (yyval.dtype).val = NewStringf("&%s",(yyvsp[(2) - (2)].dtype).val); 9381 } 9382 break; 9383 9384 case 363: 9385#line 5537 "parser.y" 9386 { 9387 (yyval.dtype) = (yyvsp[(2) - (2)].dtype); 9388 (yyval.dtype).val = NewStringf("*%s",(yyvsp[(2) - (2)].dtype).val); 9389 } 9390 break; 9391 9392 case 364: 9393#line 5543 "parser.y" 9394 { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); } 9395 break; 9396 9397 case 365: 9398#line 5544 "parser.y" 9399 { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); } 9400 break; 9401 9402 case 366: 9403#line 5545 "parser.y" 9404 { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); } 9405 break; 9406 9407 case 367: 9408#line 5546 "parser.y" 9409 { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); } 9410 break; 9411 9412 case 368: 9413#line 5547 "parser.y" 9414 { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); } 9415 break; 9416 9417 case 369: 9418#line 5548 "parser.y" 9419 { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); } 9420 break; 9421 9422 case 370: 9423#line 5549 "parser.y" 9424 { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); } 9425 break; 9426 9427 case 371: 9428#line 5552 "parser.y" 9429 { 9430 (yyval.dtype).val = NewStringf("%s+%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9431 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); 9432 } 9433 break; 9434 9435 case 372: 9436#line 5556 "parser.y" 9437 { 9438 (yyval.dtype).val = NewStringf("%s-%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9439 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); 9440 } 9441 break; 9442 9443 case 373: 9444#line 5560 "parser.y" 9445 { 9446 (yyval.dtype).val = NewStringf("%s*%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9447 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); 9448 } 9449 break; 9450 9451 case 374: 9452#line 5564 "parser.y" 9453 { 9454 (yyval.dtype).val = NewStringf("%s/%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9455 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); 9456 } 9457 break; 9458 9459 case 375: 9460#line 5568 "parser.y" 9461 { 9462 (yyval.dtype).val = NewStringf("%s%%%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9463 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); 9464 } 9465 break; 9466 9467 case 376: 9468#line 5572 "parser.y" 9469 { 9470 (yyval.dtype).val = NewStringf("%s&%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9471 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); 9472 } 9473 break; 9474 9475 case 377: 9476#line 5576 "parser.y" 9477 { 9478 (yyval.dtype).val = NewStringf("%s|%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9479 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); 9480 } 9481 break; 9482 9483 case 378: 9484#line 5580 "parser.y" 9485 { 9486 (yyval.dtype).val = NewStringf("%s^%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9487 (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); 9488 } 9489 break; 9490 9491 case 379: 9492#line 5584 "parser.y" 9493 { 9494 (yyval.dtype).val = NewStringf("%s << %s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9495 (yyval.dtype).type = promote_type((yyvsp[(1) - (3)].dtype).type); 9496 } 9497 break; 9498 9499 case 380: 9500#line 5588 "parser.y" 9501 { 9502 (yyval.dtype).val = NewStringf("%s >> %s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9503 (yyval.dtype).type = promote_type((yyvsp[(1) - (3)].dtype).type); 9504 } 9505 break; 9506 9507 case 381: 9508#line 5592 "parser.y" 9509 { 9510 (yyval.dtype).val = NewStringf("%s&&%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9511 (yyval.dtype).type = T_INT; 9512 } 9513 break; 9514 9515 case 382: 9516#line 5596 "parser.y" 9517 { 9518 (yyval.dtype).val = NewStringf("%s||%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9519 (yyval.dtype).type = T_INT; 9520 } 9521 break; 9522 9523 case 383: 9524#line 5600 "parser.y" 9525 { 9526 (yyval.dtype).val = NewStringf("%s==%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9527 (yyval.dtype).type = T_INT; 9528 } 9529 break; 9530 9531 case 384: 9532#line 5604 "parser.y" 9533 { 9534 (yyval.dtype).val = NewStringf("%s!=%s",(yyvsp[(1) - (3)].dtype).val,(yyvsp[(3) - (3)].dtype).val); 9535 (yyval.dtype).type = T_INT; 9536 } 9537 break; 9538 9539 case 385: 9540#line 5618 "parser.y" 9541 { 9542 /* Putting >= in the expression literally causes an infinite 9543 * loop somewhere in the type system. Just workaround for now 9544 * - SWIG_GE is defined in swiglabels.swg. */ 9545 (yyval.dtype).val = NewStringf("%s SWIG_GE %s", (yyvsp[(1) - (3)].dtype).val, (yyvsp[(3) - (3)].dtype).val); 9546 (yyval.dtype).type = T_INT; 9547 } 9548 break; 9549 9550 case 386: 9551#line 5625 "parser.y" 9552 { 9553 (yyval.dtype).val = NewStringf("%s SWIG_LE %s", (yyvsp[(1) - (3)].dtype).val, (yyvsp[(3) - (3)].dtype).val); 9554 (yyval.dtype).type = T_INT; 9555 } 9556 break; 9557 9558 case 387: 9559#line 5629 "parser.y" 9560 { 9561 (yyval.dtype).val = NewStringf("%s?%s:%s", (yyvsp[(1) - (5)].dtype).val, (yyvsp[(3) - (5)].dtype).val, (yyvsp[(5) - (5)].dtype).val); 9562 /* This may not be exactly right, but is probably good enough 9563 * for the purposes of parsing constant expressions. */ 9564 (yyval.dtype).type = promote((yyvsp[(3) - (5)].dtype).type, (yyvsp[(5) - (5)].dtype).type); 9565 } 9566 break; 9567 9568 case 388: 9569#line 5635 "parser.y" 9570 { 9571 (yyval.dtype).val = NewStringf("-%s",(yyvsp[(2) - (2)].dtype).val); 9572 (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type; 9573 } 9574 break; 9575 9576 case 389: 9577#line 5639 "parser.y" 9578 { 9579 (yyval.dtype).val = NewStringf("+%s",(yyvsp[(2) - (2)].dtype).val); 9580 (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type; 9581 } 9582 break; 9583 9584 case 390: 9585#line 5643 "parser.y" 9586 { 9587 (yyval.dtype).val = NewStringf("~%s",(yyvsp[(2) - (2)].dtype).val); 9588 (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type; 9589 } 9590 break; 9591 9592 case 391: 9593#line 5647 "parser.y" 9594 { 9595 (yyval.dtype).val = NewStringf("!%s",(yyvsp[(2) - (2)].dtype).val); 9596 (yyval.dtype).type = T_INT; 9597 } 9598 break; 9599 9600 case 392: 9601#line 5651 "parser.y" 9602 { 9603 String *qty; 9604 skip_balanced('(',')'); 9605 qty = Swig_symbol_type_qualify((yyvsp[(1) - (2)].type),0); 9606 if (SwigType_istemplate(qty)) { 9607 String *nstr = SwigType_namestr(qty); 9608 Delete(qty); 9609 qty = nstr; 9610 } 9611 (yyval.dtype).val = NewStringf("%s%s",qty,scanner_ccode); 9612 Clear(scanner_ccode); 9613 (yyval.dtype).type = T_INT; 9614 Delete(qty); 9615 } 9616 break; 9617 9618 case 393: 9619#line 5667 "parser.y" 9620 { 9621 (yyval.bases) = (yyvsp[(1) - (1)].bases); 9622 } 9623 break; 9624 9625 case 394: 9626#line 5672 "parser.y" 9627 { inherit_list = 1; } 9628 break; 9629 9630 case 395: 9631#line 5672 "parser.y" 9632 { (yyval.bases) = (yyvsp[(3) - (3)].bases); inherit_list = 0; } 9633 break; 9634 9635 case 396: 9636#line 5673 "parser.y" 9637 { (yyval.bases) = 0; } 9638 break; 9639 9640 case 397: 9641#line 5676 "parser.y" 9642 { 9643 Hash *list = NewHash(); 9644 Node *base = (yyvsp[(1) - (1)].node); 9645 Node *name = Getattr(base,"name"); 9646 List *lpublic = NewList(); 9647 List *lprotected = NewList(); 9648 List *lprivate = NewList(); 9649 Setattr(list,"public",lpublic); 9650 Setattr(list,"protected",lprotected); 9651 Setattr(list,"private",lprivate); 9652 Delete(lpublic); 9653 Delete(lprotected); 9654 Delete(lprivate); 9655 Append(Getattr(list,Getattr(base,"access")),name); 9656 (yyval.bases) = list; 9657 } 9658 break; 9659 9660 case 398: 9661#line 5693 "parser.y" 9662 { 9663 Hash *list = (yyvsp[(1) - (3)].bases); 9664 Node *base = (yyvsp[(3) - (3)].node); 9665 Node *name = Getattr(base,"name"); 9666 Append(Getattr(list,Getattr(base,"access")),name); 9667 (yyval.bases) = list; 9668 } 9669 break; 9670 9671 case 399: 9672#line 5702 "parser.y" 9673 { 9674 (yyval.node) = NewHash(); 9675 Setfile((yyval.node),cparse_file); 9676 Setline((yyval.node),cparse_line); 9677 Setattr((yyval.node),"name",(yyvsp[(2) - (2)].str)); 9678 if (last_cpptype && (Strcmp(last_cpptype,"struct") != 0)) { 9679 Setattr((yyval.node),"access","private"); 9680 Swig_warning(WARN_PARSE_NO_ACCESS,cparse_file,cparse_line, 9681 "No access specifier given for base class %s (ignored).\n",(yyvsp[(2) - (2)].str)); 9682 } else { 9683 Setattr((yyval.node),"access","public"); 9684 } 9685 } 9686 break; 9687 9688 case 400: 9689#line 5715 "parser.y" 9690 { 9691 (yyval.node) = NewHash(); 9692 Setfile((yyval.node),cparse_file); 9693 Setline((yyval.node),cparse_line); 9694 Setattr((yyval.node),"name",(yyvsp[(4) - (4)].str)); 9695 Setattr((yyval.node),"access",(yyvsp[(2) - (4)].id)); 9696 if (Strcmp((yyvsp[(2) - (4)].id),"public") != 0) { 9697 Swig_warning(WARN_PARSE_PRIVATE_INHERIT, cparse_file, 9698 cparse_line,"%s inheritance ignored.\n", (yyvsp[(2) - (4)].id)); 9699 } 9700 } 9701 break; 9702 9703 case 401: 9704#line 5728 "parser.y" 9705 { (yyval.id) = (char*)"public"; } 9706 break; 9707 9708 case 402: 9709#line 5729 "parser.y" 9710 { (yyval.id) = (char*)"private"; } 9711 break; 9712 9713 case 403: 9714#line 5730 "parser.y" 9715 { (yyval.id) = (char*)"protected"; } 9716 break; 9717 9718 case 404: 9719#line 5734 "parser.y" 9720 { 9721 (yyval.id) = (char*)"class"; 9722 if (!inherit_list) last_cpptype = (yyval.id); 9723 } 9724 break; 9725 9726 case 405: 9727#line 5738 "parser.y" 9728 { 9729 (yyval.id) = (char *)"typename"; 9730 if (!inherit_list) last_cpptype = (yyval.id); 9731 } 9732 break; 9733 9734 case 406: 9735#line 5744 "parser.y" 9736 { 9737 (yyval.id) = (yyvsp[(1) - (1)].id); 9738 } 9739 break; 9740 9741 case 407: 9742#line 5747 "parser.y" 9743 { 9744 (yyval.id) = (char*)"struct"; 9745 if (!inherit_list) last_cpptype = (yyval.id); 9746 } 9747 break; 9748 9749 case 408: 9750#line 5751 "parser.y" 9751 { 9752 (yyval.id) = (char*)"union"; 9753 if (!inherit_list) last_cpptype = (yyval.id); 9754 } 9755 break; 9756 9757 case 411: 9758#line 5761 "parser.y" 9759 { 9760 (yyval.dtype).qualifier = (yyvsp[(1) - (1)].str); 9761 (yyval.dtype).throws = 0; 9762 (yyval.dtype).throwf = 0; 9763 } 9764 break; 9765 9766 case 412: 9767#line 5766 "parser.y" 9768 { 9769 (yyval.dtype).qualifier = 0; 9770 (yyval.dtype).throws = (yyvsp[(3) - (4)].pl); 9771 (yyval.dtype).throwf = NewString("1"); 9772 } 9773 break; 9774 9775 case 413: 9776#line 5771 "parser.y" 9777 { 9778 (yyval.dtype).qualifier = (yyvsp[(1) - (5)].str); 9779 (yyval.dtype).throws = (yyvsp[(4) - (5)].pl); 9780 (yyval.dtype).throwf = NewString("1"); 9781 } 9782 break; 9783 9784 case 414: 9785#line 5776 "parser.y" 9786 { 9787 (yyval.dtype).qualifier = 0; 9788 (yyval.dtype).throws = 0; 9789 (yyval.dtype).throwf = 0; 9790 } 9791 break; 9792 9793 case 415: 9794#line 5783 "parser.y" 9795 { 9796 Clear(scanner_ccode); 9797 (yyval.decl).have_parms = 0; 9798 (yyval.decl).defarg = 0; 9799 (yyval.decl).throws = (yyvsp[(1) - (3)].dtype).throws; 9800 (yyval.decl).throwf = (yyvsp[(1) - (3)].dtype).throwf; 9801 } 9802 break; 9803 9804 case 416: 9805#line 5790 "parser.y" 9806 { 9807 skip_balanced('{','}'); 9808 (yyval.decl).have_parms = 0; 9809 (yyval.decl).defarg = 0; 9810 (yyval.decl).throws = (yyvsp[(1) - (3)].dtype).throws; 9811 (yyval.decl).throwf = (yyvsp[(1) - (3)].dtype).throwf; 9812 } 9813 break; 9814 9815 case 417: 9816#line 5797 "parser.y" 9817 { 9818 Clear(scanner_ccode); 9819 (yyval.decl).parms = (yyvsp[(2) - (4)].pl); 9820 (yyval.decl).have_parms = 1; 9821 (yyval.decl).defarg = 0; 9822 (yyval.decl).throws = 0; 9823 (yyval.decl).throwf = 0; 9824 } 9825 break; 9826 9827 case 418: 9828#line 5805 "parser.y" 9829 { 9830 skip_balanced('{','}'); 9831 (yyval.decl).parms = (yyvsp[(2) - (4)].pl); 9832 (yyval.decl).have_parms = 1; 9833 (yyval.decl).defarg = 0; 9834 (yyval.decl).throws = 0; 9835 (yyval.decl).throwf = 0; 9836 } 9837 break; 9838 9839 case 419: 9840#line 5813 "parser.y" 9841 { 9842 (yyval.decl).have_parms = 0; 9843 (yyval.decl).defarg = (yyvsp[(2) - (3)].dtype).val; 9844 (yyval.decl).throws = 0; 9845 (yyval.decl).throwf = 0; 9846 } 9847 break; 9848 9849 case 424: 9850#line 5829 "parser.y" 9851 { 9852 skip_balanced('(',')'); 9853 Clear(scanner_ccode); 9854 } 9855 break; 9856 9857 case 425: 9858#line 5835 "parser.y" 9859 { 9860 String *s = NewStringEmpty(); 9861 SwigType_add_template(s,(yyvsp[(2) - (3)].p)); 9862 (yyval.id) = Char(s); 9863 scanner_last_id(1); 9864 } 9865 break; 9866 9867 case 426: 9868#line 5841 "parser.y" 9869 { (yyval.id) = (char*)""; } 9870 break; 9871 9872 case 427: 9873#line 5844 "parser.y" 9874 { (yyval.id) = (yyvsp[(1) - (1)].id); } 9875 break; 9876 9877 case 428: 9878#line 5845 "parser.y" 9879 { (yyval.id) = (yyvsp[(1) - (1)].id); } 9880 break; 9881 9882 case 429: 9883#line 5848 "parser.y" 9884 { (yyval.id) = (yyvsp[(1) - (1)].id); } 9885 break; 9886 9887 case 430: 9888#line 5849 "parser.y" 9889 { (yyval.id) = 0; } 9890 break; 9891 9892 case 431: 9893#line 5852 "parser.y" 9894 { 9895 (yyval.str) = 0; 9896 if (!(yyval.str)) (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); 9897 Delete((yyvsp[(2) - (2)].str)); 9898 } 9899 break; 9900 9901 case 432: 9902#line 5857 "parser.y" 9903 { 9904 (yyval.str) = NewStringf("::%s%s",(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); 9905 Delete((yyvsp[(4) - (4)].str)); 9906 } 9907 break; 9908 9909 case 433: 9910#line 5861 "parser.y" 9911 { 9912 (yyval.str) = NewString((yyvsp[(1) - (1)].str)); 9913 } 9914 break; 9915 9916 case 434: 9917#line 5864 "parser.y" 9918 { 9919 (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str)); 9920 } 9921 break; 9922 9923 case 435: 9924#line 5867 "parser.y" 9925 { 9926 (yyval.str) = NewString((yyvsp[(1) - (1)].str)); 9927 } 9928 break; 9929 9930 case 436: 9931#line 5870 "parser.y" 9932 { 9933 (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str)); 9934 } 9935 break; 9936 9937 case 437: 9938#line 5875 "parser.y" 9939 { 9940 (yyval.str) = NewStringf("::%s%s",(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); 9941 Delete((yyvsp[(3) - (3)].str)); 9942 } 9943 break; 9944 9945 case 438: 9946#line 5879 "parser.y" 9947 { 9948 (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str)); 9949 } 9950 break; 9951 9952 case 439: 9953#line 5882 "parser.y" 9954 { 9955 (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str)); 9956 } 9957 break; 9958 9959 case 440: 9960#line 5889 "parser.y" 9961 { 9962 (yyval.str) = NewStringf("::~%s",(yyvsp[(2) - (2)].str)); 9963 } 9964 break; 9965 9966 case 441: 9967#line 5895 "parser.y" 9968 { 9969 (yyval.str) = NewStringf("%s%s",(yyvsp[(1) - (2)].id),(yyvsp[(2) - (2)].id)); 9970 /* if (Len($2)) { 9971 scanner_last_id(1); 9972 } */ 9973 } 9974 break; 9975 9976 case 442: 9977#line 5904 "parser.y" 9978 { 9979 (yyval.str) = 0; 9980 if (!(yyval.str)) (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].id),(yyvsp[(2) - (2)].str)); 9981 Delete((yyvsp[(2) - (2)].str)); 9982 } 9983 break; 9984 9985 case 443: 9986#line 5909 "parser.y" 9987 { 9988 (yyval.str) = NewStringf("::%s%s",(yyvsp[(3) - (4)].id),(yyvsp[(4) - (4)].str)); 9989 Delete((yyvsp[(4) - (4)].str)); 9990 } 9991 break; 9992 9993 case 444: 9994#line 5913 "parser.y" 9995 { 9996 (yyval.str) = NewString((yyvsp[(1) - (1)].id)); 9997 } 9998 break; 9999 10000 case 445: 10001#line 5916 "parser.y" 10002 { 10003 (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].id)); 10004 } 10005 break; 10006 10007 case 446: 10008#line 5919 "parser.y" 10009 { 10010 (yyval.str) = NewString((yyvsp[(1) - (1)].str)); 10011 } 10012 break; 10013 10014 case 447: 10015#line 5922 "parser.y" 10016 { 10017 (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str)); 10018 } 10019 break; 10020 10021 case 448: 10022#line 5927 "parser.y" 10023 { 10024 (yyval.str) = NewStringf("::%s%s",(yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].str)); 10025 Delete((yyvsp[(3) - (3)].str)); 10026 } 10027 break; 10028 10029 case 449: 10030#line 5931 "parser.y" 10031 { 10032 (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].id)); 10033 } 10034 break; 10035 10036 case 450: 10037#line 5934 "parser.y" 10038 { 10039 (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str)); 10040 } 10041 break; 10042 10043 case 451: 10044#line 5937 "parser.y" 10045 { 10046 (yyval.str) = NewStringf("::~%s",(yyvsp[(2) - (2)].id)); 10047 } 10048 break; 10049 10050 case 452: 10051#line 5943 "parser.y" 10052 { 10053 (yyval.id) = (char *) malloc(strlen((yyvsp[(1) - (2)].id))+strlen((yyvsp[(2) - (2)].id))+1); 10054 strcpy((yyval.id),(yyvsp[(1) - (2)].id)); 10055 strcat((yyval.id),(yyvsp[(2) - (2)].id)); 10056 } 10057 break; 10058 10059 case 453: 10060#line 5948 "parser.y" 10061 { (yyval.id) = (yyvsp[(1) - (1)].id);} 10062 break; 10063 10064 case 454: 10065#line 5951 "parser.y" 10066 { 10067 (yyval.str) = NewString((yyvsp[(1) - (1)].id)); 10068 } 10069 break; 10070 10071 case 455: 10072#line 5954 "parser.y" 10073 { 10074 skip_balanced('{','}'); 10075 (yyval.str) = NewString(scanner_ccode); 10076 } 10077 break; 10078 10079 case 456: 10080#line 5958 "parser.y" 10081 { 10082 (yyval.str) = (yyvsp[(1) - (1)].str); 10083 } 10084 break; 10085 10086 case 457: 10087#line 5963 "parser.y" 10088 { 10089 Hash *n; 10090 (yyval.node) = NewHash(); 10091 n = (yyvsp[(2) - (3)].node); 10092 while(n) { 10093 String *name, *value; 10094 name = Getattr(n,"name"); 10095 value = Getattr(n,"value"); 10096 if (!value) value = (String *) "1"; 10097 Setattr((yyval.node),name, value); 10098 n = nextSibling(n); 10099 } 10100 } 10101 break; 10102 10103 case 458: 10104#line 5976 "parser.y" 10105 { (yyval.node) = 0; } 10106 break; 10107 10108 case 459: 10109#line 5980 "parser.y" 10110 { 10111 (yyval.node) = NewHash(); 10112 Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id)); 10113 Setattr((yyval.node),"value",(yyvsp[(3) - (3)].id)); 10114 } 10115 break; 10116 10117 case 460: 10118#line 5985 "parser.y" 10119 { 10120 (yyval.node) = NewHash(); 10121 Setattr((yyval.node),"name",(yyvsp[(1) - (5)].id)); 10122 Setattr((yyval.node),"value",(yyvsp[(3) - (5)].id)); 10123 set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node)); 10124 } 10125 break; 10126 10127 case 461: 10128#line 5991 "parser.y" 10129 { 10130 (yyval.node) = NewHash(); 10131 Setattr((yyval.node),"name",(yyvsp[(1) - (1)].id)); 10132 } 10133 break; 10134 10135 case 462: 10136#line 5995 "parser.y" 10137 { 10138 (yyval.node) = NewHash(); 10139 Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id)); 10140 set_nextSibling((yyval.node),(yyvsp[(3) - (3)].node)); 10141 } 10142 break; 10143 10144 case 463: 10145#line 6000 "parser.y" 10146 { 10147 (yyval.node) = (yyvsp[(3) - (3)].node); 10148 Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id)); 10149 } 10150 break; 10151 10152 case 464: 10153#line 6004 "parser.y" 10154 { 10155 (yyval.node) = (yyvsp[(3) - (5)].node); 10156 Setattr((yyval.node),"name",(yyvsp[(1) - (5)].id)); 10157 set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node)); 10158 } 10159 break; 10160 10161 case 465: 10162#line 6011 "parser.y" 10163 { 10164 (yyval.id) = (yyvsp[(1) - (1)].id); 10165 } 10166 break; 10167 10168 case 466: 10169#line 6014 "parser.y" 10170 { 10171 (yyval.id) = Char((yyvsp[(1) - (1)].dtype).val); 10172 } 10173 break; 10174 10175 10176/* Line 1267 of yacc.c. */ 10177#line 10178 "y.tab.c" 10178 default: break; 10179 } 10180 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 10181 10182 YYPOPSTACK (yylen); 10183 yylen = 0; 10184 YY_STACK_PRINT (yyss, yyssp); 10185 10186 *++yyvsp = yyval; 10187 10188 10189 /* Now `shift' the result of the reduction. Determine what state 10190 that goes to, based on the state we popped back to and the rule 10191 number reduced by. */ 10192 10193 yyn = yyr1[yyn]; 10194 10195 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 10196 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 10197 yystate = yytable[yystate]; 10198 else 10199 yystate = yydefgoto[yyn - YYNTOKENS]; 10200 10201 goto yynewstate; 10202 10203 10204/*------------------------------------. 10205| yyerrlab -- here on detecting error | 10206`------------------------------------*/ 10207yyerrlab: 10208 /* If not already recovering from an error, report this error. */ 10209 if (!yyerrstatus) 10210 { 10211 ++yynerrs; 10212#if ! YYERROR_VERBOSE 10213 yyerror (YY_("syntax error")); 10214#else 10215 { 10216 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 10217 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 10218 { 10219 YYSIZE_T yyalloc = 2 * yysize; 10220 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 10221 yyalloc = YYSTACK_ALLOC_MAXIMUM; 10222 if (yymsg != yymsgbuf) 10223 YYSTACK_FREE (yymsg); 10224 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 10225 if (yymsg) 10226 yymsg_alloc = yyalloc; 10227 else 10228 { 10229 yymsg = yymsgbuf; 10230 yymsg_alloc = sizeof yymsgbuf; 10231 } 10232 } 10233 10234 if (0 < yysize && yysize <= yymsg_alloc) 10235 { 10236 (void) yysyntax_error (yymsg, yystate, yychar); 10237 yyerror (yymsg); 10238 } 10239 else 10240 { 10241 yyerror (YY_("syntax error")); 10242 if (yysize != 0) 10243 goto yyexhaustedlab; 10244 } 10245 } 10246#endif 10247 } 10248 10249 10250 10251 if (yyerrstatus == 3) 10252 { 10253 /* If just tried and failed to reuse look-ahead token after an 10254 error, discard it. */ 10255 10256 if (yychar <= YYEOF) 10257 { 10258 /* Return failure if at end of input. */ 10259 if (yychar == YYEOF) 10260 YYABORT; 10261 } 10262 else 10263 { 10264 yydestruct ("Error: discarding", 10265 yytoken, &yylval); 10266 yychar = YYEMPTY; 10267 } 10268 } 10269 10270 /* Else will try to reuse look-ahead token after shifting the error 10271 token. */ 10272 goto yyerrlab1; 10273 10274 10275/*---------------------------------------------------. 10276| yyerrorlab -- error raised explicitly by YYERROR. | 10277`---------------------------------------------------*/ 10278yyerrorlab: 10279 10280 /* Pacify compilers like GCC when the user code never invokes 10281 YYERROR and the label yyerrorlab therefore never appears in user 10282 code. */ 10283 if (/*CONSTCOND*/ 0) 10284 goto yyerrorlab; 10285 10286 /* Do not reclaim the symbols of the rule which action triggered 10287 this YYERROR. */ 10288 YYPOPSTACK (yylen); 10289 yylen = 0; 10290 YY_STACK_PRINT (yyss, yyssp); 10291 yystate = *yyssp; 10292 goto yyerrlab1; 10293 10294 10295/*-------------------------------------------------------------. 10296| yyerrlab1 -- common code for both syntax error and YYERROR. | 10297`-------------------------------------------------------------*/ 10298yyerrlab1: 10299 yyerrstatus = 3; /* Each real token shifted decrements this. */ 10300 10301 for (;;) 10302 { 10303 yyn = yypact[yystate]; 10304 if (yyn != YYPACT_NINF) 10305 { 10306 yyn += YYTERROR; 10307 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 10308 { 10309 yyn = yytable[yyn]; 10310 if (0 < yyn) 10311 break; 10312 } 10313 } 10314 10315 /* Pop the current state because it cannot handle the error token. */ 10316 if (yyssp == yyss) 10317 YYABORT; 10318 10319 10320 yydestruct ("Error: popping", 10321 yystos[yystate], yyvsp); 10322 YYPOPSTACK (1); 10323 yystate = *yyssp; 10324 YY_STACK_PRINT (yyss, yyssp); 10325 } 10326 10327 if (yyn == YYFINAL) 10328 YYACCEPT; 10329 10330 *++yyvsp = yylval; 10331 10332 10333 /* Shift the error token. */ 10334 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 10335 10336 yystate = yyn; 10337 goto yynewstate; 10338 10339 10340/*-------------------------------------. 10341| yyacceptlab -- YYACCEPT comes here. | 10342`-------------------------------------*/ 10343yyacceptlab: 10344 yyresult = 0; 10345 goto yyreturn; 10346 10347/*-----------------------------------. 10348| yyabortlab -- YYABORT comes here. | 10349`-----------------------------------*/ 10350yyabortlab: 10351 yyresult = 1; 10352 goto yyreturn; 10353 10354#ifndef yyoverflow 10355/*-------------------------------------------------. 10356| yyexhaustedlab -- memory exhaustion comes here. | 10357`-------------------------------------------------*/ 10358yyexhaustedlab: 10359 yyerror (YY_("memory exhausted")); 10360 yyresult = 2; 10361 /* Fall through. */ 10362#endif 10363 10364yyreturn: 10365 if (yychar != YYEOF && yychar != YYEMPTY) 10366 yydestruct ("Cleanup: discarding lookahead", 10367 yytoken, &yylval); 10368 /* Do not reclaim the symbols of the rule which action triggered 10369 this YYABORT or YYACCEPT. */ 10370 YYPOPSTACK (yylen); 10371 YY_STACK_PRINT (yyss, yyssp); 10372 while (yyssp != yyss) 10373 { 10374 yydestruct ("Cleanup: popping", 10375 yystos[*yyssp], yyvsp); 10376 YYPOPSTACK (1); 10377 } 10378#ifndef yyoverflow 10379 if (yyss != yyssa) 10380 YYSTACK_FREE (yyss); 10381#endif 10382#if YYERROR_VERBOSE 10383 if (yymsg != yymsgbuf) 10384 YYSTACK_FREE (yymsg); 10385#endif 10386 /* Make sure YYID is used. */ 10387 return YYID (yyresult); 10388} 10389 10390 10391#line 6021 "parser.y" 10392 10393 10394SwigType *Swig_cparse_type(String *s) { 10395 String *ns; 10396 ns = NewStringf("%s;",s); 10397 Seek(ns,0,SEEK_SET); 10398 scanner_file(ns); 10399 top = 0; 10400 scanner_next_token(PARSETYPE); 10401 yyparse(); 10402 /* Printf(stdout,"typeparse: '%s' ---> '%s'\n", s, top); */ 10403 return top; 10404} 10405 10406 10407Parm *Swig_cparse_parm(String *s) { 10408 String *ns; 10409 ns = NewStringf("%s;",s); 10410 Seek(ns,0,SEEK_SET); 10411 scanner_file(ns); 10412 top = 0; 10413 scanner_next_token(PARSEPARM); 10414 yyparse(); 10415 /* Printf(stdout,"typeparse: '%s' ---> '%s'\n", s, top); */ 10416 Delete(ns); 10417 return top; 10418} 10419 10420 10421ParmList *Swig_cparse_parms(String *s) { 10422 String *ns; 10423 char *cs = Char(s); 10424 if (cs && cs[0] != '(') { 10425 ns = NewStringf("(%s);",s); 10426 } else { 10427 ns = NewStringf("%s;",s); 10428 } 10429 Seek(ns,0,SEEK_SET); 10430 scanner_file(ns); 10431 top = 0; 10432 scanner_next_token(PARSEPARMS); 10433 yyparse(); 10434 /* Printf(stdout,"typeparse: '%s' ---> '%s'\n", s, top); */ 10435 return top; 10436} 10437 10438 10439