src/ParaView/vtkParse.tab.c

   1
   2 /* A Bison parser, made by GNU Bison 2.4.1.  */
   3
   4 /* Skeleton implementation for Bison's Yacc-like parsers in C
   5
   6       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   7    Free Software Foundation, Inc.
   8
   9    This program is free software: you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation, either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 /* As a special exception, you may create a larger work that contains
  23    part or all of the Bison parser skeleton and distribute that work
  24    under terms of your choice, so long as that work isn't itself a
  25    parser generator using the skeleton or a modified version thereof
  26    as a parser skeleton.  Alternatively, if you modify or redistribute
  27    the parser skeleton itself, you may (at your option) remove this
  28    special exception, which will cause the skeleton and the resulting
  29    Bison output files to be licensed under the GNU General Public
  30    License without this special exception.
  31
  32    This special exception was added by the Free Software Foundation in
  33    version 2.2 of Bison.  */
  34
  35 /* C LALR(1) parser skeleton written by Richard Stallman, by
  36    simplifying the original so-called "semantic" parser.  */
  37
  38 /* All symbols defined below should begin with yy or YY, to avoid
  39    infringing on user name space.  This should be done even for local
  40    variables, as they might otherwise be expanded by user macros.
  41    There are some unavoidable exceptions within include files to
  42    define necessary library symbols; they are noted "INFRINGES ON
  43    USER NAME SPACE" below.  */
  44
  45 /* Identify Bison output.  */
  46 #define YYBISON 1
  47
  48 /* Bison version.  */
  49 #define YYBISON_VERSION "2.4.1"
  50
  51 /* Skeleton name.  */
  52 #define YYSKELETON_NAME "yacc.c"
  53
  54 /* Pure parsers.  */
  55 #define YYPURE 0
  56
  57 /* Push parsers.  */
  58 #define YYPUSH 0
  59
  60 /* Pull parsers.  */
  61 #define YYPULL 1
  62
  63 /* Using locations.  */
  64 #define YYLSP_NEEDED 0
  65
  66
  67
  68 /* Copy the first part of user declarations.  */
  69
  70 /* Line 189 of yacc.c  */
  71 #line 15 "vtkParse.y"
  72
  73
  74 /*
  75
  76 This file must be translated to C and modified to build everywhere.
  77
  78 Run yacc like this:
  79
  80   yacc -b vtkParse vtkParse.y
  81
  82 Modify vtkParse.tab.c:
  83   - remove TABs
  84   - remove yyerrorlab stuff in range ["goto yyerrlab1;", "yyerrstatus = 3;")
  85
  86 */
  87
  88 #include <stdio.h>
  89 #include <stdlib.h>
  90 #include <string.h>
  91 #define yyerror(a) fprintf(stderr,"%s\n",a)
  92 #define yywrap() 1
  93
  94 /* Make sure yacc-generated code knows we have included stdlib.h.  */
  95 #ifndef _STDLIB_H
  96 # define _STDLIB_H
  97 #endif
  98 #define YYINCLUDED_STDLIB_H
  99
 100 /* Map from the type enumeration in vtkType.h to the VTK wrapping type
 101    system number for the type.  Note that the wrapping type system
 102    does not enumerate its type values by name.  Look in the
 103    type_primitive production rule in the grammar for the "official"
 104    enumeration. */
 105 static int vtkParseTypeMap[] =
 106   {
 107    0x2,  /* VTK_VOID                0 */
 108    0,    /* VTK_BIT                 1 */
 109    0x3,  /* VTK_CHAR                2 */
 110    0x13, /* VTK_UNSIGNED_CHAR       3 */
 111    0x5,  /* VTK_SHORT               4 */
 112    0x15, /* VTK_UNSIGNED_SHORT      5 */
 113    0x4,  /* VTK_INT                 6 */
 114    0x14, /* VTK_UNSIGNED_INT        7 */
 115    0x6,  /* VTK_LONG                8 */
 116    0x16, /* VTK_UNSIGNED_LONG       9 */
 117    0x1,  /* VTK_FLOAT              10 */
 118    0x7,  /* VTK_DOUBLE             11 */
 119    0xA,  /* VTK_ID_TYPE            12 */
 120    0,    /* VTK_STRING             13 */
 121    0,    /* VTK_OPAQUE             14 */
 122    0xD,  /* VTK_SIGNED_CHAR        15 */
 123    0xB,  /* VTK_LONG_LONG          16 */
 124    0x1B, /* VTK_UNSIGNED_LONG_LONG 17 */
 125    0xC,  /* VTK___INT64            18 */
 126    0x1C  /* VTK_UNSIGNED___INT64   19 */
 127   };
 128
 129 /* Define some constants to simplify references to the table lookup in
 130    the type_primitive production rule code.  */
 131 #include "vtkType.h"
 132 #define VTK_PARSE_INT8 vtkParseTypeMap[VTK_TYPE_INT8]
 133 #define VTK_PARSE_UINT8 vtkParseTypeMap[VTK_TYPE_UINT8]
 134 #define VTK_PARSE_INT16 vtkParseTypeMap[VTK_TYPE_INT16]
 135 #define VTK_PARSE_UINT16 vtkParseTypeMap[VTK_TYPE_UINT16]
 136 #define VTK_PARSE_INT32 vtkParseTypeMap[VTK_TYPE_INT32]
 137 #define VTK_PARSE_UINT32 vtkParseTypeMap[VTK_TYPE_UINT32]
 138 #define VTK_PARSE_INT64 vtkParseTypeMap[VTK_TYPE_INT64]
 139 #define VTK_PARSE_UINT64 vtkParseTypeMap[VTK_TYPE_UINT64]
 140 #define VTK_PARSE_FLOAT32 vtkParseTypeMap[VTK_TYPE_FLOAT32]
 141 #define VTK_PARSE_FLOAT64 vtkParseTypeMap[VTK_TYPE_FLOAT64]
 142
 143 static void vtkParseDebug(const char* s1, const char* s2);
 144
 145 /* Borland and MSVC do not define __STDC__ properly. */
 146 #if !defined(__STDC__)
 147 # if (defined(_MSC_VER) && _MSC_VER >= 1200) || defined(__BORLANDC__)
 148 #  define __STDC__ 1
 149 # endif
 150 #endif
 151
 152 /* Disable warnings in generated code. */
 153 #if defined(_MSC_VER)
 154 # pragma warning (disable: 4127) /* conditional expression is constant */
 155 # pragma warning (disable: 4244) /* conversion to smaller integer type */
 156 #endif
 157 #if defined(__BORLANDC__)
 158 # pragma warn -8004 /* assigned a value that is never used */
 159 # pragma warn -8008 /* conditional is always true */
 160 # pragma warn -8066 /* unreachable code */
 161 #endif
 162
 163 int yylex(void);
 164 void output_function(void);
 165
 166 /* vtkstrdup is not part of POSIX so we create our own */
 167 char *vtkstrdup(const char *in)
 168 {
 169   char *res = malloc(strlen(in)+1);
 170   strcpy(res,in);
 171   return res;
 172 }
 173
 174 #include "vtkParse.h"
 175
 176   FileInfo data;
 177   FunctionInfo *currentFunction;
 178
 179   FILE *fhint;
 180   char temps[2048];
 181   int  in_public;
 182   int  in_protected;
 183   int  HaveComment;
 184   char CommentText[50000];
 185   int CommentState;
 186   int openSig;
 187   int invertSig;
 188   unsigned int sigAllocatedLength;
 189
 190 #define YYMAXDEPTH 1000
 191
 192   void checkSigSize(const char *arg)
 193     {
 194     if (strlen(currentFunction->Signature) + strlen(arg) + 3 >
 195         sigAllocatedLength)
 196       {
 197       currentFunction->Signature = (char *)
 198         realloc(currentFunction->Signature, sigAllocatedLength*2);
 199       sigAllocatedLength = sigAllocatedLength*2;
 200       }
 201     }
 202   void preSig(const char *arg)
 203     {
 204     if (!currentFunction->Signature)
 205       {
 206       currentFunction->Signature = (char*)malloc(2048);
 207       sigAllocatedLength = 2048;
 208       sprintf(currentFunction->Signature,"%s",arg);
 209       }
 210     else if (openSig)
 211       {
 212       char *tmp;
 213       checkSigSize(arg);
 214       tmp = vtkstrdup(currentFunction->Signature);
 215       sprintf(currentFunction->Signature,"%s%s",arg,tmp);
 216       free(tmp);
 217       }
 218     }
 219   void postSig(const char *arg)
 220     {
 221     if (!currentFunction->Signature)
 222       {
 223       currentFunction->Signature = (char*)malloc(2048);
 224       sigAllocatedLength = 2048;
 225       sprintf(currentFunction->Signature,"%s",arg);
 226       }
 227     else if (openSig)
 228       {
 229       char *tmp;
 230       checkSigSize(arg);
 231       tmp = vtkstrdup(currentFunction->Signature);
 232       if (invertSig)
 233         {
 234         sprintf(currentFunction->Signature,"%s%s",arg,tmp);
 235         }
 236       else
 237         {
 238         sprintf(currentFunction->Signature,"%s%s",tmp,arg);
 239         }
 240       free(tmp);
 241       }
 242     }
 243   void delSig(void)
 244     {
 245     if (currentFunction->Signature)
 246       {
 247       free(currentFunction->Signature);
 248       currentFunction->Signature = NULL;
 249       }
 250     }
 251   void legacySig(void)
 252     {
 253     currentFunction->IsLegacy = 1;
 254     }
 255
 256
 257 /* Line 189 of yacc.c  */
 258 #line 259 "vtkParse.tab.c"
 259
 260 /* Enabling traces.  */
 261 #ifndef YYDEBUG
 262 # define YYDEBUG 0
 263 #endif
 264
 265 /* Enabling verbose error messages.  */
 266 #ifdef YYERROR_VERBOSE
 267 # undef YYERROR_VERBOSE
 268 # define YYERROR_VERBOSE 1
 269 #else
 270 # define YYERROR_VERBOSE 0
 271 #endif
 272
 273 /* Enabling the token table.  */
 274 #ifndef YYTOKEN_TABLE
 275 # define YYTOKEN_TABLE 0
 276 #endif
 277
 278
 279 /* Tokens.  */
 280 #ifndef YYTOKENTYPE
 281 # define YYTOKENTYPE
 282    /* Put the tokens into the symbol table, so that GDB and other debuggers
 283       know about them.  */
 284    enum yytokentype {
 285      CLASS = 258,
 286      PUBLIC = 259,
 287      PRIVATE = 260,
 288      PROTECTED = 261,
 289      VIRTUAL = 262,
 290      STRING = 263,
 291      NUM = 264,
 292      ID = 265,
 293      INT = 266,
 294      FLOAT = 267,
 295      SHORT = 268,
 296      LONG = 269,
 297      LONG_LONG = 270,
 298      INT64__ = 271,
 299      DOUBLE = 272,
 300      VOID = 273,
 301      CHAR = 274,
 302      SIGNED_CHAR = 275,
 303      BOOL = 276,
 304      CLASS_REF = 277,
 305      OTHER = 278,
 306      CONST = 279,
 307      OPERATOR = 280,
 308      UNSIGNED = 281,
 309      FRIEND = 282,
 310      VTK_ID = 283,
 311      STATIC = 284,
 312      VAR_FUNCTION = 285,
 313      ARRAY_NUM = 286,
 314      VTK_LEGACY = 287,
 315      TypeInt8 = 288,
 316      TypeUInt8 = 289,
 317      TypeInt16 = 290,
 318      TypeUInt16 = 291,
 319      TypeInt32 = 292,
 320      TypeUInt32 = 293,
 321      TypeInt64 = 294,
 322      TypeUInt64 = 295,
 323      TypeFloat32 = 296,
 324      TypeFloat64 = 297,
 325      IdType = 298,
 326      StdString = 299,
 327      SetMacro = 300,
 328      GetMacro = 301,
 329      SetStringMacro = 302,
 330      GetStringMacro = 303,
 331      SetClampMacro = 304,
 332      SetObjectMacro = 305,
 333      SetReferenceCountedObjectMacro = 306,
 334      GetObjectMacro = 307,
 335      BooleanMacro = 308,
 336      SetVector2Macro = 309,
 337      SetVector3Macro = 310,
 338      SetVector4Macro = 311,
 339      SetVector6Macro = 312,
 340      GetVector2Macro = 313,
 341      GetVector3Macro = 314,
 342      GetVector4Macro = 315,
 343      GetVector6Macro = 316,
 344      SetVectorMacro = 317,
 345      GetVectorMacro = 318,
 346      ViewportCoordinateMacro = 319,
 347      WorldCoordinateMacro = 320,
 348      TypeMacro = 321,
 349      VTK_WRAP_EXTERN = 322
 350    };
 351 #endif
 352
 353
 354
 355 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 356 typedef union YYSTYPE
 357 {
 358
 359 /* Line 214 of yacc.c  */
 360 #line 200 "vtkParse.y"
 361
 362   char *str;
 363   int   integer;
 364   struct {
 365     char* name;
 366     int external;
 367   } vtkid;
 368
 369
 370
 371 /* Line 214 of yacc.c  */
 372 #line 373 "vtkParse.tab.c"
 373 } YYSTYPE;
 374 # define YYSTYPE_IS_TRIVIAL 1
 375 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 376 # define YYSTYPE_IS_DECLARED 1
 377 #endif
 378
 379
 380 /* Copy the second part of user declarations.  */
 381
 382
 383 /* Line 264 of yacc.c  */
 384 #line 385 "vtkParse.tab.c"
 385
 386 #ifdef short
 387 # undef short
 388 #endif
 389
 390 #ifdef YYTYPE_UINT8
 391 typedef YYTYPE_UINT8 yytype_uint8;
 392 #else
 393 typedef unsigned char yytype_uint8;
 394 #endif
 395
 396 #ifdef YYTYPE_INT8
 397 typedef YYTYPE_INT8 yytype_int8;
 398 #elif (defined __STDC__ || defined __C99__FUNC__ \
 399      || defined __cplusplus || defined _MSC_VER)
 400 typedef signed char yytype_int8;
 401 #else
 402 typedef short int yytype_int8;
 403 #endif
 404
 405 #ifdef YYTYPE_UINT16
 406 typedef YYTYPE_UINT16 yytype_uint16;
 407 #else
 408 typedef unsigned short int yytype_uint16;
 409 #endif
 410
 411 #ifdef YYTYPE_INT16
 412 typedef YYTYPE_INT16 yytype_int16;
 413 #else
 414 typedef short int yytype_int16;
 415 #endif
 416
 417 #ifndef YYSIZE_T
 418 # ifdef __SIZE_TYPE__
 419 #  define YYSIZE_T __SIZE_TYPE__
 420 # elif defined size_t
 421 #  define YYSIZE_T size_t
 422 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 423      || defined __cplusplus || defined _MSC_VER)
 424 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 425 #  define YYSIZE_T size_t
 426 # else
 427 #  define YYSIZE_T unsigned int
 428 # endif
 429 #endif
 430
 431 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 432
 433 #ifndef YY_
 434 # if YYENABLE_NLS
 435 #  if ENABLE_NLS
 436 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 437 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 438 #  endif
 439 # endif
 440 # ifndef YY_
 441 #  define YY_(msgid) msgid
 442 # endif
 443 #endif
 444
 445 /* Suppress unused-variable warnings by "using" E.  */
 446 #if ! defined lint || defined __GNUC__
 447 # define YYUSE(e) ((void) (e))
 448 #else
 449 # define YYUSE(e) /* empty */
 450 #endif
 451
 452 /* Identity function, used to suppress warnings about constant conditions.  */
 453 #ifndef lint
 454 # define YYID(n) (n)
 455 #else
 456 #if (defined __STDC__ || defined __C99__FUNC__ \
 457      || defined __cplusplus || defined _MSC_VER)
 458 static int
 459 YYID (int yyi)
 460 #else
 461 static int
 462 YYID (yyi)
 463     int yyi;
 464 #endif
 465 {
 466   return yyi;
 467 }
 468 #endif
 469
 470 #if ! defined yyoverflow || YYERROR_VERBOSE
 471
 472 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 473
 474 # ifdef YYSTACK_USE_ALLOCA
 475 #  if YYSTACK_USE_ALLOCA
 476 #   ifdef __GNUC__
 477 #    define YYSTACK_ALLOC __builtin_alloca
 478 #   elif defined __BUILTIN_VA_ARG_INCR
 479 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 480 #   elif defined _AIX
 481 #    define YYSTACK_ALLOC __alloca
 482 #   elif defined _MSC_VER
 483 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 484 #    define alloca _alloca
 485 #   else
 486 #    define YYSTACK_ALLOC alloca
 487 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 488      || defined __cplusplus || defined _MSC_VER)
 489 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 490 #     ifndef _STDLIB_H
 491 #      define _STDLIB_H 1
 492 #     endif
 493 #    endif
 494 #   endif
 495 #  endif
 496 # endif
 497
 498 # ifdef YYSTACK_ALLOC
 499    /* Pacify GCC's `empty if-body' warning.  */
 500 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 501 #  ifndef YYSTACK_ALLOC_MAXIMUM
 502     /* The OS might guarantee only one guard page at the bottom of the stack,
 503        and a page size can be as small as 4096 bytes.  So we cannot safely
 504        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 505        to allow for a few compiler-allocated temporary stack slots.  */
 506 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 507 #  endif
 508 # else
 509 #  define YYSTACK_ALLOC YYMALLOC
 510 #  define YYSTACK_FREE YYFREE
 511 #  ifndef YYSTACK_ALLOC_MAXIMUM
 512 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 513 #  endif
 514 #  if (defined __cplusplus && ! defined _STDLIB_H \
 515        && ! ((defined YYMALLOC || defined malloc) \
 516        && (defined YYFREE || defined free)))
 517 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 518 #   ifndef _STDLIB_H
 519 #    define _STDLIB_H 1
 520 #   endif
 521 #  endif
 522 #  ifndef YYMALLOC
 523 #   define YYMALLOC malloc
 524 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 525      || defined __cplusplus || defined _MSC_VER)
 526 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 527 #   endif
 528 #  endif
 529 #  ifndef YYFREE
 530 #   define YYFREE free
 531 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 532      || defined __cplusplus || defined _MSC_VER)
 533 void free (void *); /* INFRINGES ON USER NAME SPACE */
 534 #   endif
 535 #  endif
 536 # endif
 537 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 538
 539
 540 #if (! defined yyoverflow \
 541      && (! defined __cplusplus \
 542    || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 543
 544 /* A type that is properly aligned for any stack member.  */
 545 union yyalloc
 546 {
 547   yytype_int16 yyss_alloc;
 548   YYSTYPE yyvs_alloc;
 549 };
 550
 551 /* The size of the maximum gap between one aligned stack and the next.  */
 552 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 553
 554 /* The size of an array large to enough to hold all stacks, each with
 555    N elements.  */
 556 # define YYSTACK_BYTES(N) \
 557      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 558       + YYSTACK_GAP_MAXIMUM)
 559
 560 /* Copy COUNT objects from FROM to TO.  The source and destination do
 561    not overlap.  */
 562 # ifndef YYCOPY
 563 #  if defined __GNUC__ && 1 < __GNUC__
 564 #   define YYCOPY(To, From, Count) \
 565       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 566 #  else
 567 #   define YYCOPY(To, From, Count)    \
 568       do          \
 569   {          \
 570     YYSIZE_T yyi;        \
 571     for (yyi = 0; yyi < (Count); yyi++)  \
 572       (To)[yyi] = (From)[yyi];    \
 573   }          \
 574       while (YYID (0))
 575 #  endif
 576 # endif
 577
 578 /* Relocate STACK from its old location to the new one.  The
 579    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 580    elements in the stack, and YYPTR gives the new location of the
 581    stack.  Advance YYPTR to a properly aligned location for the next
 582    stack.  */
 583 # define YYSTACK_RELOCATE(Stack_alloc, Stack)        \
 584     do                  \
 585       {                  \
 586   YYSIZE_T yynewbytes;            \
 587   YYCOPY (&yyptr->Stack_alloc, Stack, yysize);      \
 588   Stack = &yyptr->Stack_alloc;          \
 589   yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 590   yyptr += yynewbytes / sizeof (*yyptr);        \
 591       }                  \
 592     while (YYID (0))
 593
 594 #endif
 595
 596 /* YYFINAL -- State number of the termination state.  */
 597 #define YYFINAL  63
 598 /* YYLAST -- Last index in YYTABLE.  */
 599 #define YYLAST   891
 600
 601 /* YYNTOKENS -- Number of terminals.  */
 602 #define YYNTOKENS  83
 603 /* YYNNTS -- Number of nonterminals.  */
 604 #define YYNNTS  75
 605 /* YYNRULES -- Number of rules.  */
 606 #define YYNRULES  197
 607 /* YYNRULES -- Number of states.  */
 608 #define YYNSTATES  370
 609
 610 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 611 #define YYUNDEFTOK  2
 612 #define YYMAXUTOK   322
 613
 614 #define YYTRANSLATE(YYX)            \
 615   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 616
 617 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 618 static const yytype_uint8 yytranslate[] =
 619 {
 620        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 621        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 622        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 623        2,     2,     2,     2,     2,     2,     2,     2,    79,     2,
 624       72,    73,    80,     2,    76,    81,    82,     2,     2,     2,
 625        2,     2,     2,     2,     2,     2,     2,     2,    70,    71,
 626        2,    75,     2,     2,     2,     2,     2,     2,     2,     2,
 627        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 628        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 629        2,    77,     2,    78,     2,     2,     2,     2,     2,     2,
 630        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 631        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 632        2,     2,     2,    68,     2,    69,    74,     2,     2,     2,
 633        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 634        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 635        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 636        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 637        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 638        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 639        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 640        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 641        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 642        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 643        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 644        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 645        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 646        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 647       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 648       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
 649       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
 650       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
 651       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
 652       65,    66,    67
 653 };
 654
 655 #if YYDEBUG
 656 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 657    YYRHS.  */
 658 static const yytype_uint16 yyprhs[] =
 659 {
 660        0,     0,     3,     7,    10,    12,    13,    21,    23,    26,
 661       29,    31,    33,    36,    39,    43,    46,    49,    51,    56,
 662       59,    63,    65,    68,    72,    77,    81,    84,    86,    89,
 663       93,    98,   102,   105,   109,   110,   111,   116,   120,   121,
 664      123,   124,   130,   132,   134,   136,   138,   140,   145,   149,
 665      153,   154,   156,   158,   159,   164,   166,   167,   172,   174,
 666      175,   178,   182,   185,   188,   189,   190,   194,   199,   202,
 667      204,   207,   211,   213,   216,   218,   220,   223,   226,   228,
 668      230,   232,   235,   238,   239,   243,   245,   247,   249,   251,
 669      253,   255,   257,   259,   261,   263,   265,   267,   269,   271,
 670      273,   275,   277,   279,   281,   283,   285,   287,   289,   291,
 671      293,   294,   297,   300,   301,   307,   309,   311,   313,   316,
 672      318,   320,   324,   326,   327,   335,   336,   337,   346,   347,
 673      353,   354,   360,   361,   362,   373,   374,   382,   383,   391,
 674      392,   393,   402,   403,   411,   412,   420,   421,   429,   430,
 675      438,   439,   447,   448,   456,   457,   465,   466,   474,   475,
 676      483,   484,   494,   495,   505,   510,   515,   522,   530,   531,
 677      534,   535,   538,   540,   542,   544,   546,   548,   550,   552,
 678      554,   556,   558,   560,   562,   564,   566,   568,   570,   572,
 679      574,   576,   578,   580,   582,   584,   588,   592
 680 };
 681
 682 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 683 static const yytype_int16 yyrhs[] =
 684 {
 685       84,     0,    -1,   151,    86,   151,    -1,    28,    67,    -1,
 686       28,    -1,    -1,     3,    28,    87,   122,    68,    88,    69,
 687       -1,    89,    -1,    89,    88,    -1,   125,    70,    -1,   110,
 688       -1,    92,    -1,    27,    92,    -1,    91,   103,    -1,    27,
 689       91,   103,    -1,    90,   103,    -1,   128,    71,    -1,   128,
 690       -1,    32,    72,    91,    73,    -1,    74,    94,    -1,     7,
 691       74,    94,    -1,    94,    -1,   114,    94,    -1,   114,    24,
 692       94,    -1,     7,   114,    24,    94,    -1,     7,   114,    94,
 693       -1,     7,    94,    -1,    93,    -1,   114,    93,    -1,   114,
 694       24,    93,    -1,     7,   114,    24,    93,    -1,     7,   114,
 695       93,    -1,     7,    93,    -1,    25,   152,    71,    -1,    -1,
 696       -1,    98,    95,    97,    96,    -1,    98,    75,     9,    -1,
 697       -1,    24,    -1,    -1,   102,    72,    99,   104,    73,    -1,
 698       24,    -1,    29,    -1,    85,    -1,    10,    -1,    71,    -1,
 699       68,   151,    69,    71,    -1,    68,   151,    69,    -1,    70,
 700      152,    71,    -1,    -1,   105,    -1,   107,    -1,    -1,   107,
 701      106,    76,   105,    -1,   114,    -1,    -1,   114,   111,   108,
 702      109,    -1,    30,    -1,    -1,    75,   126,    -1,   114,   111,
 703       71,    -1,    30,    71,    -1,   102,   112,    -1,    -1,    -1,
 704       31,   113,   112,    -1,    77,   152,    78,   112,    -1,   100,
 705      115,    -1,   115,    -1,   101,   115,    -1,   101,   100,   115,
 706       -1,   119,    -1,   119,   118,    -1,   116,    -1,   117,    -1,
 707      117,    79,    -1,   117,    80,    -1,    44,    -1,    79,    -1,
 708       80,    -1,    79,   118,    -1,    80,   118,    -1,    -1,    26,
 709      120,   121,    -1,   121,    -1,    33,    -1,    34,    -1,    35,
 710       -1,    36,    -1,    37,    -1,    38,    -1,    39,    -1,    40,
 711       -1,    41,    -1,    42,    -1,    12,    -1,    18,    -1,    19,
 712       -1,    11,    -1,    13,    -1,    14,    -1,    17,    -1,    10,
 713       -1,    85,    -1,    43,    -1,    15,    -1,    16,    -1,    20,
 714       -1,    21,    -1,    -1,    70,   123,    -1,   125,    28,    -1,
 715       -1,   125,    28,   124,    76,   123,    -1,     4,    -1,     5,
 716       -1,     6,    -1,    81,   127,    -1,   127,    -1,     9,    -1,
 717        9,    82,     9,    -1,   102,    -1,    -1,    45,    72,   102,
 718       76,   129,   119,    73,    -1,    -1,    -1,    46,    72,   130,
 719      102,    76,   131,   119,    73,    -1,    -1,    47,    72,   132,
 720      102,    73,    -1,    -1,    48,    72,   133,   102,    73,    -1,
 721       -1,    -1,    49,    72,   102,    76,   134,   119,   135,    76,
 722      152,    73,    -1,    -1,    50,    72,   102,    76,   136,   119,
 723       73,    -1,    -1,    51,    72,   102,    76,   137,   119,    73,
 724       -1,    -1,    -1,    52,    72,   138,   102,    76,   139,   119,
 725       73,    -1,    -1,    53,    72,   102,   140,    76,   119,    73,
 726       -1,    -1,    54,    72,   102,    76,   141,   119,    73,    -1,
 727       -1,    58,    72,   102,    76,   142,   119,    73,    -1,    -1,
 728       55,    72,   102,    76,   143,   119,    73,    -1,    -1,    59,
 729       72,   102,    76,   144,   119,    73,    -1,    -1,    56,    72,
 730      102,    76,   145,   119,    73,    -1,    -1,    60,    72,   102,
 731       76,   146,   119,    73,    -1,    -1,    57,    72,   102,    76,
 732      147,   119,    73,    -1,    -1,    61,    72,   102,    76,   148,
 733      119,    73,    -1,    -1,    62,    72,   102,    76,   149,   119,
 734       76,   126,    73,    -1,    -1,    63,    72,   102,    76,   150,
 735      119,    76,   126,    73,    -1,    64,    72,   102,    73,    -1,
 736       65,    72,   102,    73,    -1,    66,    72,   102,    76,   102,
 737       73,    -1,    66,    72,   102,    76,   102,    76,    73,    -1,
 738       -1,   153,   151,    -1,    -1,   154,   152,    -1,    71,    -1,
 739      154,    -1,    23,    -1,   155,    -1,   156,    -1,    80,    -1,
 740       75,    -1,    70,    -1,    76,    -1,    82,    -1,     8,    -1,
 741      119,    -1,   117,    -1,     9,    -1,    22,    -1,    79,    -1,
 742      157,    -1,    24,    -1,    25,    -1,    81,    -1,    74,    -1,
 743       29,    -1,    31,    -1,    68,   151,    69,    -1,    72,   151,
 744       73,    -1,    77,   151,    78,    -1
 745 };
 746
 747 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 748 static const yytype_uint16 yyrline[] =
 749 {
 750        0,   281,   281,   283,   288,   295,   294,   300,   300,   302,
 751      302,   303,   304,   305,   306,   307,   308,   309,   311,   313,
 752      314,   315,   316,   320,   324,   329,   334,   340,   344,   349,
 753      354,   360,   366,   372,   378,   378,   378,   384,   393,   393,
 754      395,   395,   397,   399,   401,   401,   403,   404,   405,   406,
 755      408,   408,   410,   411,   411,   413,   419,   418,   425,   432,
 756      432,   434,   434,   436,   444,   445,   445,   448,   451,   452,
 757      453,   454,   456,   457,   459,   461,   462,   463,   465,   475,
 758      476,   477,   478,   480,   480,   482,   485,   486,   487,   488,
 759      489,   490,   491,   492,   493,   494,   495,   496,   497,   498,
 760      499,   500,   501,   502,   507,   527,   528,   529,   530,   531,
 761      533,   533,   535,   541,   540,   546,   547,   548,   550,   550,
 762      552,   553,   553,   557,   556,   568,   568,   568,   577,   577,
 763      588,   588,   598,   599,   597,   630,   629,   642,   641,   653,
 764      654,   653,   663,   662,   680,   679,   710,   709,   727,   726,
 765      759,   758,   776,   775,   810,   809,   827,   826,   865,   864,
 766      882,   881,   900,   899,   916,   963,  1012,  1063,  1119,  1119,
 767     1120,  1120,  1122,  1122,  1124,  1124,  1124,  1124,  1124,  1124,
 768     1124,  1124,  1125,  1125,  1125,  1125,  1125,  1125,  1125,  1126,
 769     1126,  1126,  1126,  1126,  1126,  1128,  1129,  1130
 770 };
 771 #endif
 772
 773 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 774 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 775    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 776 static const char *const yytname[] =
 777 {
 778   "$end", "error", "$undefined", "CLASS", "PUBLIC", "PRIVATE",
 779   "PROTECTED", "VIRTUAL", "STRING", "NUM", "ID", "INT", "FLOAT", "SHORT",
 780   "LONG", "LONG_LONG", "INT64__", "DOUBLE", "VOID", "CHAR", "SIGNED_CHAR",
 781   "BOOL", "CLASS_REF", "OTHER", "CONST", "OPERATOR", "UNSIGNED", "FRIEND",
 782   "VTK_ID", "STATIC", "VAR_FUNCTION", "ARRAY_NUM", "VTK_LEGACY",
 783   "TypeInt8", "TypeUInt8", "TypeInt16", "TypeUInt16", "TypeInt32",
 784   "TypeUInt32", "TypeInt64", "TypeUInt64", "TypeFloat32", "TypeFloat64",
 785   "IdType", "StdString", "SetMacro", "GetMacro", "SetStringMacro",
 786   "GetStringMacro", "SetClampMacro", "SetObjectMacro",
 787   "SetReferenceCountedObjectMacro", "GetObjectMacro", "BooleanMacro",
 788   "SetVector2Macro", "SetVector3Macro", "SetVector4Macro",
 789   "SetVector6Macro", "GetVector2Macro", "GetVector3Macro",
 790   "GetVector4Macro", "GetVector6Macro", "SetVectorMacro", "GetVectorMacro",
 791   "ViewportCoordinateMacro", "WorldCoordinateMacro", "TypeMacro",
 792   "VTK_WRAP_EXTERN", "'{'", "'}'", "':'", "';'", "'('", "')'", "'~'",
 793   "'='", "','", "'['", "']'", "'&'", "'*'", "'-'", "'.'", "$accept",
 794   "strt", "vtk_id", "class_def", "$@1", "class_def_body", "class_def_item",
 795   "legacy_function", "function", "operator", "operator_sig", "func", "$@2",
 796   "$@3", "maybe_const", "func_sig", "$@4", "const_mod", "static_mod",
 797   "any_id", "func_body", "args_list", "more_args", "$@5", "arg", "$@6",
 798   "opt_var_assign", "var", "var_id", "var_array", "$@7", "type",
 799   "type_red1", "type_string1", "type_string2", "type_indirection",
 800   "type_red2", "$@8", "type_primitive", "optional_scope", "scope_list",
 801   "$@9", "scope_type", "float_num", "float_prim", "macro", "$@10", "$@11",
 802   "$@12", "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19", "$@20",
 803   "$@21", "$@22", "$@23", "$@24", "$@25", "$@26", "$@27", "$@28", "$@29",
 804   "$@30", "$@31", "maybe_other", "maybe_other_no_semi", "other_stuff",
 805   "other_stuff_no_semi", "braces", "parens", "brackets", 0
 806 };
 807 #endif
 808
 809 # ifdef YYPRINT
 810 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 811    token YYLEX-NUM.  */
 812 static const yytype_uint16 yytoknum[] =
 813 {
 814        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 815      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
 816      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
 817      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
 818      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
 819      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
 820      315,   316,   317,   318,   319,   320,   321,   322,   123,   125,
 821       58,    59,    40,    41,   126,    61,    44,    91,    93,    38,
 822       42,    45,    46
 823 };
 824 # endif
 825
 826 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 827 static const yytype_uint8 yyr1[] =
 828 {
 829        0,    83,    84,    85,    85,    87,    86,    88,    88,    89,
 830       89,    89,    89,    89,    89,    89,    89,    89,    90,    91,
 831       91,    91,    91,    91,    91,    91,    91,    92,    92,    92,
 832       92,    92,    92,    93,    95,    96,    94,    94,    97,    97,
 833       99,    98,   100,   101,   102,   102,   103,   103,   103,   103,
 834      104,   104,   105,   106,   105,   107,   108,   107,   107,   109,
 835      109,   110,   110,   111,   112,   113,   112,   112,   114,   114,
 836      114,   114,   115,   115,   115,   116,   116,   116,   117,   118,
 837      118,   118,   118,   120,   119,   119,   121,   121,   121,   121,
 838      121,   121,   121,   121,   121,   121,   121,   121,   121,   121,
 839      121,   121,   121,   121,   121,   121,   121,   121,   121,   121,
 840      122,   122,   123,   124,   123,   125,   125,   125,   126,   126,
 841      127,   127,   127,   129,   128,   130,   131,   128,   132,   128,
 842      133,   128,   134,   135,   128,   136,   128,   137,   128,   138,
 843      139,   128,   140,   128,   141,   128,   142,   128,   143,   128,
 844      144,   128,   145,   128,   146,   128,   147,   128,   148,   128,
 845      149,   128,   150,   128,   128,   128,   128,   128,   151,   151,
 846      152,   152,   153,   153,   154,   154,   154,   154,   154,   154,
 847      154,   154,   154,   154,   154,   154,   154,   154,   154,   154,
 848      154,   154,   154,   154,   154,   155,   156,   157
 849 };
 850
 851 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 852 static const yytype_uint8 yyr2[] =
 853 {
 854        0,     2,     3,     2,     1,     0,     7,     1,     2,     2,
 855        1,     1,     2,     2,     3,     2,     2,     1,     4,     2,
 856        3,     1,     2,     3,     4,     3,     2,     1,     2,     3,
 857        4,     3,     2,     3,     0,     0,     4,     3,     0,     1,
 858        0,     5,     1,     1,     1,     1,     1,     4,     3,     3,
 859        0,     1,     1,     0,     4,     1,     0,     4,     1,     0,
 860        2,     3,     2,     2,     0,     0,     3,     4,     2,     1,
 861        2,     3,     1,     2,     1,     1,     2,     2,     1,     1,
 862        1,     2,     2,     0,     3,     1,     1,     1,     1,     1,
 863        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
 864        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
 865        0,     2,     2,     0,     5,     1,     1,     1,     2,     1,
 866        1,     3,     1,     0,     7,     0,     0,     8,     0,     5,
 867        0,     5,     0,     0,    10,     0,     7,     0,     7,     0,
 868        0,     8,     0,     7,     0,     7,     0,     7,     0,     7,
 869        0,     7,     0,     7,     0,     7,     0,     7,     0,     7,
 870        0,     9,     0,     9,     4,     4,     6,     7,     0,     2,
 871        0,     2,     1,     1,     1,     1,     1,     1,     1,     1,
 872        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
 873        1,     1,     1,     1,     1,     3,     3,     3
 874 };
 875
 876 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 877    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 878    means the default is an error.  */
 879 static const yytype_uint8 yydefact[] =
 880 {
 881      168,   182,   185,   103,    99,    96,   100,   101,   106,   107,
 882      102,    97,    98,   108,   109,   186,   174,   189,   190,    83,
 883        4,   193,   194,    86,    87,    88,    89,    90,    91,    92,
 884       93,    94,    95,   105,    78,   168,   179,   172,   168,   192,
 885      178,   180,   168,   187,   177,   191,   181,     0,   104,   184,
 886      183,    85,     0,   168,   173,   175,   176,   188,     0,     3,
 887        0,     0,     0,     1,     0,   168,   169,    84,   195,   196,
 888      197,     5,     2,   110,     0,     0,   115,   116,   117,   111,
 889        0,     0,   112,     0,   103,    42,   170,     0,    43,     0,
 890        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 891        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 892        0,     0,     0,     0,   104,     0,     7,     0,     0,    11,
 893       27,    21,    34,     0,     0,     0,    10,     0,    69,    74,
 894       75,    72,     0,    17,     0,     0,    32,    26,     0,     0,
 895      170,     0,    12,     0,    62,     0,     0,   125,   128,   130,
 896        0,     0,     0,   139,     0,     0,     0,     0,     0,     0,
 897        0,     0,     0,     0,     0,     0,     0,     0,    45,    44,
 898       19,     6,     8,   168,   170,    46,    15,    13,     0,    38,
 899       68,     0,    70,    40,     0,    28,    22,    64,     0,    76,
 900       77,    79,    80,    73,     9,    16,     0,    20,     0,    31,
 901       25,    33,   171,    14,     0,     0,     0,     0,     0,     0,
 902        0,     0,     0,     0,     0,   142,     0,     0,     0,     0,
 903        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 904        0,    37,    39,    35,    71,    50,    29,    23,    65,   170,
 905       63,    61,    81,    82,   114,    30,    24,     0,    18,     0,
 906      123,     0,     0,     0,   132,   135,   137,     0,     0,   144,
 907      148,   152,   156,   146,   150,   154,   158,   160,   162,   164,
 908      165,     0,    48,    49,    36,    58,     0,    51,    52,    55,
 909       64,     0,     0,     0,   126,   129,   131,     0,     0,     0,
 910      140,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 911        0,     0,     0,    47,    41,     0,    64,    56,    66,    64,
 912        0,     0,   133,     0,     0,     0,     0,     0,     0,     0,
 913        0,     0,     0,     0,     0,     0,     0,   166,     0,     0,
 914       59,    67,   124,     0,     0,   136,   138,     0,   143,   145,
 915      149,   153,   157,   147,   151,   155,   159,     0,     0,   167,
 916       54,     0,    57,   127,   170,   141,   120,     0,   122,     0,
 917      119,     0,    60,     0,     0,   118,   161,   163,   134,   121
 918 };
 919
 920 /* YYDEFGOTO[NTERM-NUM].  */
 921 static const yytype_int16 yydefgoto[] =
 922 {
 923       -1,    47,   169,    65,    73,   115,   116,   117,   118,   119,
 924      120,   121,   179,   274,   233,   122,   235,   123,   124,   125,
 925      176,   276,   277,   305,   278,   330,   352,   126,   188,   240,
 926      280,   127,   128,   129,    49,   193,    50,    58,    51,    75,
 927       79,   134,    80,   359,   360,   133,   283,   208,   311,   209,
 928      210,   287,   334,   288,   289,   214,   315,   258,   292,   296,
 929      293,   297,   294,   298,   295,   299,   300,   301,    52,   139,
 930       53,    54,    55,    56,    57
 931 };
 932
 933 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 934    STATE-NUM.  */
 935 #define YYPACT_NINF -274
 936 static const yytype_int16 yypact[] =
 937 {
 938      322,  -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,
 939     -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,
 940      -44,  -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,
 941     -274,  -274,  -274,  -274,  -274,   322,  -274,  -274,   322,  -274,
 942     -274,  -274,   322,  -274,  -274,  -274,  -274,    37,  -274,  -274,
 943     -274,  -274,    46,   322,  -274,  -274,  -274,  -274,   848,  -274,
 944       -3,   -17,     4,  -274,    56,   322,  -274,  -274,  -274,  -274,
 945     -274,  -274,  -274,    29,   131,    39,  -274,  -274,  -274,  -274,
 946       77,   476,    32,   625,    38,  -274,   397,   541,  -274,    41,
 947       45,    47,    49,    50,    58,    59,    61,    67,    69,    71,
 948       72,    74,    75,    76,    80,    81,    83,    85,    93,    94,
 949       95,    96,    97,    22,    98,   102,   476,   -46,   -46,  -274,
 950     -274,  -274,    53,   779,   744,   100,  -274,    66,  -274,  -274,
 951      -51,    -2,    68,    79,    73,    22,  -274,  -274,    78,    88,
 952      397,   -46,  -274,    66,  -274,   583,    22,  -274,  -274,  -274,
 953       22,    22,    22,  -274,    22,    22,    22,    22,    22,    22,
 954       22,    22,    22,    22,    22,    22,    22,    22,  -274,  -274,
 955     -274,  -274,  -274,   322,   397,  -274,  -274,  -274,   166,   152,
 956     -274,   779,  -274,  -274,    44,  -274,  -274,   -13,   106,  -274,
 957     -274,    -2,    -2,  -274,  -274,  -274,   131,  -274,    44,  -274,
 958     -274,  -274,  -274,  -274,   667,   105,    87,   103,    22,    22,
 959       22,   107,   111,   126,    22,  -274,   127,   132,   133,   137,
 960      149,   150,   151,   153,   154,   155,   109,   159,   157,   167,
 961      170,  -274,  -274,  -274,  -274,   709,  -274,  -274,  -274,   397,
 962     -274,  -274,  -274,  -274,  -274,  -274,  -274,    90,  -274,    22,
 963     -274,   161,   172,   173,  -274,  -274,  -274,   171,   174,  -274,
 964     -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,
 965     -274,    22,   178,  -274,  -274,  -274,   180,  -274,   175,    22,
 966      -10,   177,    22,   814,  -274,  -274,  -274,   814,   814,   814,
 967     -274,   814,   814,   814,   814,   814,   814,   814,   814,   814,
 968      814,   814,   -43,  -274,  -274,   182,   -10,  -274,  -274,   -10,
 969      183,   814,  -274,   186,   187,   814,   188,   189,   190,   191,
 970      192,   193,   194,   195,   197,   196,   198,  -274,   200,   709,
 971      201,  -274,  -274,   202,   203,  -274,  -274,   204,  -274,  -274,
 972     -274,  -274,  -274,  -274,  -274,  -274,  -274,    17,    17,  -274,
 973     -274,    17,  -274,  -274,   397,  -274,   199,    52,  -274,   205,
 974     -274,   207,  -274,   209,   262,  -274,  -274,  -274,  -274,  -274
 975 };
 976
 977 /* YYPGOTO[NTERM-NUM].  */
 978 static const yytype_int16 yypgoto[] =
 979 {
 980     -274,  -274,     0,  -274,  -274,   168,  -274,  -274,   -70,   215,
 981      -64,   -42,  -274,  -274,  -274,  -274,  -274,   162,  -274,    34,
 982      -84,  -274,   -39,  -274,  -274,  -274,  -274,  -274,     6,  -273,
 983     -274,   -75,  -121,  -274,   -72,   -66,   -77,  -274,   245,  -274,
 984      108,  -274,   -76,  -256,   -50,  -274,  -274,  -274,  -274,  -274,
 985     -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,
 986     -274,  -274,  -274,  -274,  -274,  -274,  -274,  -274,   -22,  -126,
 987     -274,   -85,  -274,  -274,  -274
 988 };
 989
 990 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 991    positive, shift that token.  If negative, reduce the rule which
 992    number is the opposite.  If zero, do what YYDEFACT says.
 993    If YYTABLE_NINF, syntax error.  */
 994 #define YYTABLE_NINF -114
 995 static const yytype_int16 yytable[] =
 996 {
 997       48,   140,   180,   182,   131,   132,   131,   308,   138,   130,
 998      131,   130,   143,    60,   202,   130,    61,   141,   238,   136,
 999       62,   238,   173,    59,   174,   175,   356,   168,   189,   190,
1000      327,    66,   168,   328,   177,    48,   331,    63,    48,   131,
1001      132,   137,    48,    72,   130,    20,   131,   131,   230,    64,
1002       20,   130,   130,    48,   168,   140,    69,   203,    48,   183,
1003      234,   356,   168,   185,   239,    48,    68,   239,   131,    86,
1004      206,   170,    20,   130,   199,   205,   168,   191,   192,   185,
1005       20,   114,    70,   114,    71,   186,    48,   114,   168,   140,
1006      184,    86,   361,   197,    20,   362,   200,   168,   357,    74,
1007      168,   186,   198,    86,   131,    82,    20,    81,  -113,   130,
1008      -45,   249,   144,   281,   282,    20,   114,   145,    20,   146,
1009      236,   147,   148,    48,    48,   242,   243,   131,   178,   247,
1010      149,   150,   130,   151,   245,    76,    77,    78,   194,   152,
1011       48,   153,   237,   154,   155,   114,   156,   157,   158,   196,
1012      195,   229,   159,   160,   140,   161,   246,   162,   131,   201,
1013      279,   187,   137,   130,   186,   163,   164,   165,   166,   167,
1014      -44,   171,   183,    48,    48,   231,   232,   241,   248,   250,
1015      207,    48,   269,   254,   211,   212,   213,   255,   215,   216,
1016      217,   218,   219,   220,   221,   222,   223,   224,   225,   226,
1017      227,   228,   256,   259,   114,   200,   310,   237,   260,   261,
1018      312,   313,   314,   262,   316,   317,   318,   319,   320,   321,
1019      322,   323,   324,   325,   326,   263,   264,   265,   363,   266,
1020      267,   268,   270,   271,   333,    48,   272,   284,   337,    48,
1021      246,   273,   251,   252,   253,   285,   286,   290,   257,   303,
1022      291,   -53,   131,   304,   279,   309,   332,   130,   329,   335,
1023      336,   338,   339,   340,   341,   342,   343,   344,   345,   140,
1024      346,   369,   347,   349,   348,   353,   351,   355,   366,   354,
1025      367,   364,   368,    48,   172,   307,   181,    48,    48,    48,
1026      350,    48,    48,    48,    48,    48,    48,    48,    48,    48,
1027       48,    48,   142,    67,   244,   302,     0,   365,     0,     0,
1028        0,    48,     0,   306,     0,    48,     0,     0,     0,     0,
1029        0,     0,     0,     0,     0,     0,     0,     0,     0,    48,
1030        1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
1031       11,    12,    13,    14,    15,    16,    17,    18,    19,     0,
1032       20,    21,     0,    22,    48,    23,    24,    25,    26,    27,
1033       28,    29,    30,    31,    32,    33,    34,     0,     0,     0,
1034        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1035        0,   358,   358,     0,     0,   358,     0,     0,     0,     0,
1036       35,   358,    36,    37,    38,     0,    39,    40,    41,    42,
1037        0,    43,    44,    45,    46,     1,     2,     3,     4,     5,
1038        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
1039       16,    17,    18,    19,     0,    20,    21,     0,    22,     0,
1040       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
1041       33,    34,     0,     0,     0,     0,     0,     0,     0,     0,
1042        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1043        0,     0,     0,     0,     0,    35,     0,    36,     0,    38,
1044        0,    39,    40,    41,    42,     0,    43,    44,    45,    46,
1045       76,    77,    78,    83,     0,     0,    84,     4,     5,     6,
1046        7,     8,     9,    10,    11,    12,    13,    14,     0,     0,
1047       85,    86,    19,    87,    20,    88,    89,     0,    90,    23,
1048       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
1049       34,    91,    92,    93,    94,    95,    96,    97,    98,    99,
1050      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
1051      110,   111,   112,     0,     0,     0,     0,     0,    83,     0,
1052      113,    84,     4,     5,     6,     7,     8,     9,    10,    11,
1053       12,    13,    14,     0,     0,    85,    86,    19,     0,    20,
1054       88,     0,     0,     0,    23,    24,    25,    26,    27,    28,
1055       29,    30,    31,    32,    33,    34,     0,     0,     0,     0,
1056      204,     0,     0,    84,     4,     5,     6,     7,     8,     9,
1057       10,    11,    12,    13,    14,     0,     0,    85,     0,    19,
1058        0,    20,    88,     0,     0,   113,    23,    24,    25,    26,
1059       27,    28,    29,    30,    31,    32,    33,    34,     0,     0,
1060        0,     0,     0,     0,     0,    84,     4,     5,     6,     7,
1061        8,     9,    10,    11,    12,    13,    14,     0,     0,    85,
1062       86,    19,     0,    20,    88,     0,     0,   113,    23,    24,
1063       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1064        0,     0,     0,     0,     0,     0,     0,    84,     4,     5,
1065        6,     7,     8,     9,    10,    11,    12,    13,    14,     0,
1066        0,    85,     0,    19,     0,    20,    88,     0,     0,   135,
1067       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
1068       33,    34,     0,     0,     0,     0,     0,     0,     0,     3,
1069        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
1070       14,     0,     0,    85,     0,    19,     0,    20,    88,   275,
1071        0,   135,    23,    24,    25,    26,    27,    28,    29,    30,
1072       31,    32,    33,    34,     3,     4,     5,     6,     7,     8,
1073        9,    10,    11,    12,    13,    14,     0,     0,    85,     0,
1074       19,     0,    20,     0,     0,     0,     0,    23,    24,    25,
1075       26,    27,    28,    29,    30,    31,    32,    33,    34,     3,
1076        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
1077       14,     0,     0,     0,     0,    19,     0,    20,     0,     0,
1078        0,     0,    23,    24,    25,    26,    27,    28,    29,    30,
1079       31,    32,    33,    34,     3,     4,     5,     6,     7,     8,
1080        9,    10,    11,    12,    13,    14,     0,     0,     0,     0,
1081       19,     0,    20,     0,     0,     0,     0,    23,    24,    25,
1082       26,    27,    28,    29,    30,    31,    32,    33,     3,     4,
1083        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1084        0,     0,     0,     0,     0,     0,    20,     0,     0,     0,
1085        0,    23,    24,    25,    26,    27,    28,    29,    30,    31,
1086       32,    33
1087 };
1088
1089 static const yytype_int16 yycheck[] =
1090 {
1091        0,    86,   123,   124,    81,    81,    83,   280,    83,    81,
1092       87,    83,    87,    35,   140,    87,    38,    87,    31,    83,
1093       42,    31,    68,    67,    70,    71,     9,    10,    79,    80,
1094       73,    53,    10,    76,   118,    35,   309,     0,    38,   116,
1095      116,    83,    42,    65,   116,    28,   123,   124,   174,     3,
1096       28,   123,   124,    53,    10,   140,    73,   141,    58,    72,
1097      181,     9,    10,   127,    77,    65,    69,    77,   145,    25,
1098      145,   113,    28,   145,   138,   145,    10,    79,    80,   143,
1099       28,    81,    78,    83,    28,   127,    86,    87,    10,   174,
1100       24,    25,   348,   135,    28,   351,   138,    10,    81,    70,
1101       10,   143,    24,    25,   181,    28,    28,    68,    76,   181,
1102       72,    24,    71,   239,    24,    28,   116,    72,    28,    72,
1103      184,    72,    72,   123,   124,   191,   192,   204,    75,   204,
1104       72,    72,   204,    72,   198,     4,     5,     6,    70,    72,
1105      140,    72,   184,    72,    72,   145,    72,    72,    72,    76,
1106       71,   173,    72,    72,   239,    72,   198,    72,   235,    71,
1107      235,   127,   204,   235,   206,    72,    72,    72,    72,    72,
1108       72,    69,    72,   173,   174,     9,    24,    71,    73,    76,
1109      146,   181,    73,    76,   150,   151,   152,    76,   154,   155,
1110      156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
1111      166,   167,    76,    76,   204,   247,   283,   249,    76,    76,
1112      287,   288,   289,    76,   291,   292,   293,   294,   295,   296,
1113      297,   298,   299,   300,   301,    76,    76,    76,   354,    76,
1114       76,    76,    73,    76,   311,   235,    69,    76,   315,   239,
1115      282,    71,   208,   209,   210,    73,    73,    76,   214,    71,
1116       76,    76,   329,    73,   329,    78,    73,   329,    76,    73,
1117       73,    73,    73,    73,    73,    73,    73,    73,    73,   354,
1118       73,     9,    76,    73,    76,    73,    75,    73,    73,    76,
1119       73,    82,    73,   283,   116,   279,   124,   287,   288,   289,
1120      329,   291,   292,   293,   294,   295,   296,   297,   298,   299,
1121      300,   301,    87,    58,   196,   271,    -1,   357,    -1,    -1,
1122       -1,   311,    -1,   279,    -1,   315,    -1,    -1,    -1,    -1,
1123       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   329,
1124        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
1125       18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
1126       28,    29,    -1,    31,   354,    33,    34,    35,    36,    37,
1127       38,    39,    40,    41,    42,    43,    44,    -1,    -1,    -1,
1128       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1129       -1,   347,   348,    -1,    -1,   351,    -1,    -1,    -1,    -1,
1130       68,   357,    70,    71,    72,    -1,    74,    75,    76,    77,
1131       -1,    79,    80,    81,    82,     8,     9,    10,    11,    12,
1132       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
1133       23,    24,    25,    26,    -1,    28,    29,    -1,    31,    -1,
1134       33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
1135       43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1136       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1137       -1,    -1,    -1,    -1,    -1,    68,    -1,    70,    -1,    72,
1138       -1,    74,    75,    76,    77,    -1,    79,    80,    81,    82,
1139        4,     5,     6,     7,    -1,    -1,    10,    11,    12,    13,
1140       14,    15,    16,    17,    18,    19,    20,    21,    -1,    -1,
1141       24,    25,    26,    27,    28,    29,    30,    -1,    32,    33,
1142       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
1143       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
1144       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
1145       64,    65,    66,    -1,    -1,    -1,    -1,    -1,     7,    -1,
1146       74,    10,    11,    12,    13,    14,    15,    16,    17,    18,
1147       19,    20,    21,    -1,    -1,    24,    25,    26,    -1,    28,
1148       29,    -1,    -1,    -1,    33,    34,    35,    36,    37,    38,
1149       39,    40,    41,    42,    43,    44,    -1,    -1,    -1,    -1,
1150        7,    -1,    -1,    10,    11,    12,    13,    14,    15,    16,
1151       17,    18,    19,    20,    21,    -1,    -1,    24,    -1,    26,
1152       -1,    28,    29,    -1,    -1,    74,    33,    34,    35,    36,
1153       37,    38,    39,    40,    41,    42,    43,    44,    -1,    -1,
1154       -1,    -1,    -1,    -1,    -1,    10,    11,    12,    13,    14,
1155       15,    16,    17,    18,    19,    20,    21,    -1,    -1,    24,
1156       25,    26,    -1,    28,    29,    -1,    -1,    74,    33,    34,
1157       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
1158       -1,    -1,    -1,    -1,    -1,    -1,    -1,    10,    11,    12,
1159       13,    14,    15,    16,    17,    18,    19,    20,    21,    -1,
1160       -1,    24,    -1,    26,    -1,    28,    29,    -1,    -1,    74,
1161       33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
1162       43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    10,
1163       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
1164       21,    -1,    -1,    24,    -1,    26,    -1,    28,    29,    30,
1165       -1,    74,    33,    34,    35,    36,    37,    38,    39,    40,
1166       41,    42,    43,    44,    10,    11,    12,    13,    14,    15,
1167       16,    17,    18,    19,    20,    21,    -1,    -1,    24,    -1,
1168       26,    -1,    28,    -1,    -1,    -1,    -1,    33,    34,    35,
1169       36,    37,    38,    39,    40,    41,    42,    43,    44,    10,
1170       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
1171       21,    -1,    -1,    -1,    -1,    26,    -1,    28,    -1,    -1,
1172       -1,    -1,    33,    34,    35,    36,    37,    38,    39,    40,
1173       41,    42,    43,    44,    10,    11,    12,    13,    14,    15,
1174       16,    17,    18,    19,    20,    21,    -1,    -1,    -1,    -1,
1175       26,    -1,    28,    -1,    -1,    -1,    -1,    33,    34,    35,
1176       36,    37,    38,    39,    40,    41,    42,    43,    10,    11,
1177       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
1178       -1,    -1,    -1,    -1,    -1,    -1,    28,    -1,    -1,    -1,
1179       -1,    33,    34,    35,    36,    37,    38,    39,    40,    41,
1180       42,    43
1181 };
1182
1183 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1184    symbol of state STATE-NUM.  */
1185 static const yytype_uint8 yystos[] =
1186 {
1187        0,     8,     9,    10,    11,    12,    13,    14,    15,    16,
1188       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
1189       28,    29,    31,    33,    34,    35,    36,    37,    38,    39,
1190       40,    41,    42,    43,    44,    68,    70,    71,    72,    74,
1191       75,    76,    77,    79,    80,    81,    82,    84,    85,   117,
1192      119,   121,   151,   153,   154,   155,   156,   157,   120,    67,
1193      151,   151,   151,     0,     3,    86,   151,   121,    69,    73,
1194       78,    28,   151,    87,    70,   122,     4,     5,     6,   123,
1195      125,    68,    28,     7,    10,    24,    25,    27,    29,    30,
1196       32,    45,    46,    47,    48,    49,    50,    51,    52,    53,
1197       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
1198       64,    65,    66,    74,    85,    88,    89,    90,    91,    92,
1199       93,    94,    98,   100,   101,   102,   110,   114,   115,   116,
1200      117,   119,   125,   128,   124,    74,    93,    94,   114,   152,
1201      154,    91,    92,   114,    71,    72,    72,    72,    72,    72,
1202       72,    72,    72,    72,    72,    72,    72,    72,    72,    72,
1203       72,    72,    72,    72,    72,    72,    72,    72,    10,    85,
1204       94,    69,    88,    68,    70,    71,   103,   103,    75,    95,
1205      115,   100,   115,    72,    24,    93,    94,   102,   111,    79,
1206       80,    79,    80,   118,    70,    71,    76,    94,    24,    93,
1207       94,    71,   152,   103,     7,    91,   114,   102,   130,   132,
1208      133,   102,   102,   102,   138,   102,   102,   102,   102,   102,
1209      102,   102,   102,   102,   102,   102,   102,   102,   102,   151,
1210      152,     9,    24,    97,   115,    99,    93,    94,    31,    77,
1211      112,    71,   118,   118,   123,    93,    94,   114,    73,    24,
1212       76,   102,   102,   102,    76,    76,    76,   102,   140,    76,
1213       76,    76,    76,    76,    76,    76,    76,    76,    76,    73,
1214       73,    76,    69,    71,    96,    30,   104,   105,   107,   114,
1215      113,   152,    24,   129,    76,    73,    73,   134,   136,   137,
1216       76,    76,   141,   143,   145,   147,   142,   144,   146,   148,
1217      149,   150,   102,    71,    73,   106,   102,   111,   112,    78,
1218      119,   131,   119,   119,   119,   139,   119,   119,   119,   119,
1219      119,   119,   119,   119,   119,   119,   119,    73,    76,    76,
1220      108,   112,    73,   119,   135,    73,    73,   119,    73,    73,
1221       73,    73,    73,    73,    73,    73,    73,    76,    76,    73,
1222      105,    75,   109,    73,    76,    73,     9,    81,   102,   126,
1223      127,   126,   126,   152,    82,   127,    73,    73,    73,     9
1224 };
1225
1226 #define yyerrok    (yyerrstatus = 0)
1227 #define yyclearin  (yychar = YYEMPTY)
1228 #define YYEMPTY    (-2)
1229 #define YYEOF    0
1230
1231 #define YYACCEPT  goto yyacceptlab
1232 #define YYABORT    goto yyabortlab
1233 #define YYERROR    goto yyerrorlab
1234
1235
1236 /* Like YYERROR except do call yyerror.  This remains here temporarily
1237    to ease the transition to the new meaning of YYERROR, for GCC.
1238    Once GCC version 2 has supplanted version 1, this can go.  */
1239
1240 #define YYFAIL    goto yyerrlab
1241
1242 #define YYRECOVERING()  (!!yyerrstatus)
1243
1244 #define YYBACKUP(Token, Value)          \
1245 do                \
1246   if (yychar == YYEMPTY && yylen == 1)        \
1247     {                \
1248       yychar = (Token);            \
1249       yylval = (Value);            \
1250       yytoken = YYTRANSLATE (yychar);        \
1251       YYPOPSTACK (1);            \
1252       goto yybackup;            \
1253     }                \
1254   else                \
1255     {                \
1256       yyerror (YY_("syntax error: cannot back up")); \
1257       YYERROR;              \
1258     }                \
1259 while (YYID (0))
1260
1261
1262 #define YYTERROR  1
1263 #define YYERRCODE  256
1264
1265
1266 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1267    If N is 0, then set CURRENT to the empty location which ends
1268    the previous symbol: RHS[0] (always defined).  */
1269
1270 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1271 #ifndef YYLLOC_DEFAULT
1272 # define YYLLOC_DEFAULT(Current, Rhs, N)        \
1273     do                  \
1274       if (YYID (N))                                                    \
1275   {                \
1276     (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;  \
1277     (Current).first_column = YYRHSLOC (Rhs, 1).first_column;  \
1278     (Current).last_line    = YYRHSLOC (Rhs, N).last_line;    \
1279     (Current).last_column  = YYRHSLOC (Rhs, N).last_column;  \
1280   }                \
1281       else                \
1282   {                \
1283     (Current).first_line   = (Current).last_line   =    \
1284       YYRHSLOC (Rhs, 0).last_line;        \
1285     (Current).first_column = (Current).last_column =    \
1286       YYRHSLOC (Rhs, 0).last_column;        \
1287   }                \
1288     while (YYID (0))
1289 #endif
1290
1291
1292 /* YY_LOCATION_PRINT -- Print the location on the stream.
1293    This macro was not mandated originally: define only if we know
1294    we won't break user code: when these are the locations we know.  */
1295
1296 #ifndef YY_LOCATION_PRINT
1297 # if YYLTYPE_IS_TRIVIAL
1298 #  define YY_LOCATION_PRINT(File, Loc)      \
1299      fprintf (File, "%d.%d-%d.%d",      \
1300         (Loc).first_line, (Loc).first_column,  \
1301         (Loc).last_line,  (Loc).last_column)
1302 # else
1303 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1304 # endif
1305 #endif
1306
1307
1308 /* YYLEX -- calling `yylex' with the right arguments.  */
1309
1310 #ifdef YYLEX_PARAM
1311 # define YYLEX yylex (YYLEX_PARAM)
1312 #else
1313 # define YYLEX yylex ()
1314 #endif
1315
1316 /* Enable debugging if requested.  */
1317 #if YYDEBUG
1318
1319 # ifndef YYFPRINTF
1320 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1321 #  define YYFPRINTF fprintf
1322 # endif
1323
1324 # define YYDPRINTF(Args)      \
1325 do {            \
1326   if (yydebug)          \
1327     YYFPRINTF Args;        \
1328 } while (YYID (0))
1329
1330 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)        \
1331 do {                    \
1332   if (yydebug)                  \
1333     {                    \
1334       YYFPRINTF (stderr, "%s ", Title);            \
1335       yy_symbol_print (stderr,              \
1336       Type, Value); \
1337       YYFPRINTF (stderr, "\n");              \
1338     }                    \
1339 } while (YYID (0))
1340
1341
1342 /*--------------------------------.
1343 | Print this symbol on YYOUTPUT.  |
1344 `--------------------------------*/
1345
1346 /*ARGSUSED*/
1347 #if (defined __STDC__ || defined __C99__FUNC__ \
1348      || defined __cplusplus || defined _MSC_VER)
1349 static void
1350 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1351 #else
1352 static void
1353 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1354     FILE *yyoutput;
1355     int yytype;
1356     YYSTYPE const * const yyvaluep;
1357 #endif
1358 {
1359   if (!yyvaluep)
1360     return;
1361 # ifdef YYPRINT
1362   if (yytype < YYNTOKENS)
1363     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1364 # else
1365   YYUSE (yyoutput);
1366 # endif
1367   switch (yytype)
1368     {
1369       default:
1370   break;
1371     }
1372 }
1373
1374
1375 /*--------------------------------.
1376 | Print this symbol on YYOUTPUT.  |
1377 `--------------------------------*/
1378
1379 #if (defined __STDC__ || defined __C99__FUNC__ \
1380      || defined __cplusplus || defined _MSC_VER)
1381 static void
1382 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1383 #else
1384 static void
1385 yy_symbol_print (yyoutput, yytype, yyvaluep)
1386     FILE *yyoutput;
1387     int yytype;
1388     YYSTYPE const * const yyvaluep;
1389 #endif
1390 {
1391   if (yytype < YYNTOKENS)
1392     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1393   else
1394     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1395
1396   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1397   YYFPRINTF (yyoutput, ")");
1398 }
1399
1400 /*------------------------------------------------------------------.
1401 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1402 | TOP (included).                                                   |
1403 `------------------------------------------------------------------*/
1404
1405 #if (defined __STDC__ || defined __C99__FUNC__ \
1406      || defined __cplusplus || defined _MSC_VER)
1407 static void
1408 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1409 #else
1410 static void
1411 yy_stack_print (yybottom, yytop)
1412     yytype_int16 *yybottom;
1413     yytype_int16 *yytop;
1414 #endif
1415 {
1416   YYFPRINTF (stderr, "Stack now");
1417   for (; yybottom <= yytop; yybottom++)
1418     {
1419       int yybot = *yybottom;
1420       YYFPRINTF (stderr, " %d", yybot);
1421     }
1422   YYFPRINTF (stderr, "\n");
1423 }
1424
1425 # define YY_STACK_PRINT(Bottom, Top)        \
1426 do {                \
1427   if (yydebug)              \
1428     yy_stack_print ((Bottom), (Top));        \
1429 } while (YYID (0))
1430
1431
1432 /*------------------------------------------------.
1433 | Report that the YYRULE is going to be reduced.  |
1434 `------------------------------------------------*/
1435
1436 #if (defined __STDC__ || defined __C99__FUNC__ \
1437      || defined __cplusplus || defined _MSC_VER)
1438 static void
1439 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1440 #else
1441 static void
1442 yy_reduce_print (yyvsp, yyrule)
1443     YYSTYPE *yyvsp;
1444     int yyrule;
1445 #endif
1446 {
1447   int yynrhs = yyr2[yyrule];
1448   int yyi;
1449   unsigned long int yylno = yyrline[yyrule];
1450   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1451        yyrule - 1, yylno);
1452   /* The symbols being reduced.  */
1453   for (yyi = 0; yyi < yynrhs; yyi++)
1454     {
1455       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
1456       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1457            &(yyvsp[(yyi + 1) - (yynrhs)])
1458                       );
1459       YYFPRINTF (stderr, "\n");
1460     }
1461 }
1462
1463 # define YY_REDUCE_PRINT(Rule)    \
1464 do {          \
1465   if (yydebug)        \
1466     yy_reduce_print (yyvsp, Rule); \
1467 } while (YYID (0))
1468
1469 /* Nonzero means print parse trace.  It is left uninitialized so that
1470    multiple parsers can coexist.  */
1471 int yydebug;
1472 #else /* !YYDEBUG */
1473 # define YYDPRINTF(Args)
1474 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1475 # define YY_STACK_PRINT(Bottom, Top)
1476 # define YY_REDUCE_PRINT(Rule)
1477 #endif /* !YYDEBUG */
1478
1479
1480 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1481 #ifndef  YYINITDEPTH
1482 # define YYINITDEPTH 200
1483 #endif
1484
1485 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1486    if the built-in stack extension method is used).
1487
1488    Do not make this value too large; the results are undefined if
1489    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1490    evaluated with infinite-precision integer arithmetic.  */
1491
1492 #ifndef YYMAXDEPTH
1493 # define YYMAXDEPTH 10000
1494 #endif
1495
1496 \f
1497
1498 #if YYERROR_VERBOSE
1499
1500 # ifndef yystrlen
1501 #  if defined __GLIBC__ && defined _STRING_H
1502 #   define yystrlen strlen
1503 #  else
1504 /* Return the length of YYSTR.  */
1505 #if (defined __STDC__ || defined __C99__FUNC__ \
1506      || defined __cplusplus || defined _MSC_VER)
1507 static YYSIZE_T
1508 yystrlen (const char *yystr)
1509 #else
1510 static YYSIZE_T
1511 yystrlen (yystr)
1512     const char *yystr;
1513 #endif
1514 {
1515   YYSIZE_T yylen;
1516   for (yylen = 0; yystr[yylen]; yylen++)
1517     continue;
1518   return yylen;
1519 }
1520 #  endif
1521 # endif
1522
1523 # ifndef yystpcpy
1524 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1525 #   define yystpcpy stpcpy
1526 #  else
1527 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1528    YYDEST.  */
1529 #if (defined __STDC__ || defined __C99__FUNC__ \
1530      || defined __cplusplus || defined _MSC_VER)
1531 static char *
1532 yystpcpy (char *yydest, const char *yysrc)
1533 #else
1534 static char *
1535 yystpcpy (yydest, yysrc)
1536     char *yydest;
1537     const char *yysrc;
1538 #endif
1539 {
1540   char *yyd = yydest;
1541   const char *yys = yysrc;
1542
1543   while ((*yyd++ = *yys++) != '\0')
1544     continue;
1545
1546   return yyd - 1;
1547 }
1548 #  endif
1549 # endif
1550
1551 # ifndef yytnamerr
1552 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1553    quotes and backslashes, so that it's suitable for yyerror.  The
1554    heuristic is that double-quoting is unnecessary unless the string
1555    contains an apostrophe, a comma, or backslash (other than
1556    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1557    null, do not copy; instead, return the length of what the result
1558    would have been.  */
1559 static YYSIZE_T
1560 yytnamerr (char *yyres, const char *yystr)
1561 {
1562   if (*yystr == '"')
1563     {
1564       YYSIZE_T yyn = 0;
1565       char const *yyp = yystr;
1566
1567       for (;;)
1568   switch (*++yyp)
1569     {
1570     case '\'':
1571     case ',':
1572       goto do_not_strip_quotes;
1573
1574     case '\\':
1575       if (*++yyp != '\\')
1576         goto do_not_strip_quotes;
1577       /* Fall through.  */
1578     default:
1579       if (yyres)
1580         yyres[yyn] = *yyp;
1581       yyn++;
1582       break;
1583
1584     case '"':
1585       if (yyres)
1586         yyres[yyn] = '\0';
1587       return yyn;
1588     }
1589     do_not_strip_quotes: ;
1590     }
1591
1592   if (! yyres)
1593     return yystrlen (yystr);
1594
1595   return yystpcpy (yyres, yystr) - yyres;
1596 }
1597 # endif
1598
1599 /* Copy into YYRESULT an error message about the unexpected token
1600    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
1601    including the terminating null byte.  If YYRESULT is null, do not
1602    copy anything; just return the number of bytes that would be
1603    copied.  As a special case, return 0 if an ordinary "syntax error"
1604    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1605    size calculation.  */
1606 static YYSIZE_T
1607 yysyntax_error (char *yyresult, int yystate, int yychar)
1608 {
1609   int yyn = yypact[yystate];
1610
1611   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1612     return 0;
1613   else
1614     {
1615       int yytype = YYTRANSLATE (yychar);
1616       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1617       YYSIZE_T yysize = yysize0;
1618       YYSIZE_T yysize1;
1619       int yysize_overflow = 0;
1620       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1621       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1622       int yyx;
1623
1624 # if 0
1625       /* This is so xgettext sees the translatable formats that are
1626    constructed on the fly.  */
1627       YY_("syntax error, unexpected %s");
1628       YY_("syntax error, unexpected %s, expecting %s");
1629       YY_("syntax error, unexpected %s, expecting %s or %s");
1630       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1631       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1632 # endif
1633       char *yyfmt;
1634       char const *yyf;
1635       static char const yyunexpected[] = "syntax error, unexpected %s";
1636       static char const yyexpecting[] = ", expecting %s";
1637       static char const yyor[] = " or %s";
1638       char yyformat[sizeof yyunexpected
1639         + sizeof yyexpecting - 1
1640         + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1641            * (sizeof yyor - 1))];
1642       char const *yyprefix = yyexpecting;
1643
1644       /* Start YYX at -YYN if negative to avoid negative indexes in
1645    YYCHECK.  */
1646       int yyxbegin = yyn < 0 ? -yyn : 0;
1647
1648       /* Stay within bounds of both yycheck and yytname.  */
1649       int yychecklim = YYLAST - yyn + 1;
1650       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1651       int yycount = 1;
1652
1653       yyarg[0] = yytname[yytype];
1654       yyfmt = yystpcpy (yyformat, yyunexpected);
1655
1656       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1657   if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1658     {
1659       if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1660         {
1661     yycount = 1;
1662     yysize = yysize0;
1663     yyformat[sizeof yyunexpected - 1] = '\0';
1664     break;
1665         }
1666       yyarg[yycount++] = yytname[yyx];
1667       yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1668       yysize_overflow |= (yysize1 < yysize);
1669       yysize = yysize1;
1670       yyfmt = yystpcpy (yyfmt, yyprefix);
1671       yyprefix = yyor;
1672     }
1673
1674       yyf = YY_(yyformat);
1675       yysize1 = yysize + yystrlen (yyf);
1676       yysize_overflow |= (yysize1 < yysize);
1677       yysize = yysize1;
1678
1679       if (yysize_overflow)
1680   return YYSIZE_MAXIMUM;
1681
1682       if (yyresult)
1683   {
1684     /* Avoid sprintf, as that infringes on the user's name space.
1685        Don't have undefined behavior even if the translation
1686        produced a string with the wrong number of "%s"s.  */
1687     char *yyp = yyresult;
1688     int yyi = 0;
1689     while ((*yyp = *yyf) != '\0')
1690       {
1691         if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1692     {
1693       yyp += yytnamerr (yyp, yyarg[yyi++]);
1694       yyf += 2;
1695     }
1696         else
1697     {
1698       yyp++;
1699       yyf++;
1700     }
1701       }
1702   }
1703       return yysize;
1704     }
1705 }
1706 #endif /* YYERROR_VERBOSE */
1707 \f
1708
1709 /*-----------------------------------------------.
1710 | Release the memory associated to this symbol.  |
1711 `-----------------------------------------------*/
1712
1713 /*ARGSUSED*/
1714 #if (defined __STDC__ || defined __C99__FUNC__ \
1715      || defined __cplusplus || defined _MSC_VER)
1716 static void
1717 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1718 #else
1719 static void
1720 yydestruct (yymsg, yytype, yyvaluep)
1721     const char *yymsg;
1722     int yytype;
1723     YYSTYPE *yyvaluep;
1724 #endif
1725 {
1726   YYUSE (yyvaluep);
1727
1728   if (!yymsg)
1729     yymsg = "Deleting";
1730   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1731
1732   switch (yytype)
1733     {
1734
1735       default:
1736   break;
1737     }
1738 }
1739
1740 /* Prevent warnings from -Wmissing-prototypes.  */
1741 #ifdef YYPARSE_PARAM
1742 #if defined __STDC__ || defined __cplusplus
1743 int yyparse (void *YYPARSE_PARAM);
1744 #else
1745 int yyparse ();
1746 #endif
1747 #else /* ! YYPARSE_PARAM */
1748 #if defined __STDC__ || defined __cplusplus
1749 int yyparse (void);
1750 #else
1751 int yyparse ();
1752 #endif
1753 #endif /* ! YYPARSE_PARAM */
1754
1755
1756 /* The lookahead symbol.  */
1757 int yychar;
1758
1759 /* The semantic value of the lookahead symbol.  */
1760 YYSTYPE yylval;
1761
1762 /* Number of syntax errors so far.  */
1763 int yynerrs;
1764
1765
1766
1767 /*-------------------------.
1768 | yyparse or yypush_parse.  |
1769 `-------------------------*/
1770
1771 #ifdef YYPARSE_PARAM
1772 #if (defined __STDC__ || defined __C99__FUNC__ \
1773      || defined __cplusplus || defined _MSC_VER)
1774 int
1775 yyparse (void *YYPARSE_PARAM)
1776 #else
1777 int
1778 yyparse (YYPARSE_PARAM)
1779     void *YYPARSE_PARAM;
1780 #endif
1781 #else /* ! YYPARSE_PARAM */
1782 #if (defined __STDC__ || defined __C99__FUNC__ \
1783      || defined __cplusplus || defined _MSC_VER)
1784 int
1785 yyparse (void)
1786 #else
1787 int
1788 yyparse ()
1789
1790 #endif
1791 #endif
1792 {
1793
1794
1795     int yystate;
1796     /* Number of tokens to shift before error messages enabled.  */
1797     int yyerrstatus;
1798
1799     /* The stacks and their tools:
1800        `yyss': related to states.
1801        `yyvs': related to semantic values.
1802
1803        Refer to the stacks thru separate pointers, to allow yyoverflow
1804        to reallocate them elsewhere.  */
1805
1806     /* The state stack.  */
1807     yytype_int16 yyssa[YYINITDEPTH];
1808     yytype_int16 *yyss;
1809     yytype_int16 *yyssp;
1810
1811     /* The semantic value stack.  */
1812     YYSTYPE yyvsa[YYINITDEPTH];
1813     YYSTYPE *yyvs;
1814     YYSTYPE *yyvsp;
1815
1816     YYSIZE_T yystacksize;
1817
1818   int yyn;
1819   int yyresult;
1820   /* Lookahead token as an internal (translated) token number.  */
1821   int yytoken;
1822   /* The variables used to return semantic value and location from the
1823      action routines.  */
1824   YYSTYPE yyval;
1825
1826 #if YYERROR_VERBOSE
1827   /* Buffer for error messages, and its allocated size.  */
1828   char yymsgbuf[128];
1829   char *yymsg = yymsgbuf;
1830   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1831 #endif
1832
1833 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1834
1835   /* The number of symbols on the RHS of the reduced rule.
1836      Keep to zero when no symbol should be popped.  */
1837   int yylen = 0;
1838
1839   yytoken = 0;
1840   yyss = yyssa;
1841   yyvs = yyvsa;
1842   yystacksize = YYINITDEPTH;
1843
1844   YYDPRINTF ((stderr, "Starting parse\n"));
1845
1846   yystate = 0;
1847   yyerrstatus = 0;
1848   yynerrs = 0;
1849   yychar = YYEMPTY; /* Cause a token to be read.  */
1850
1851   /* Initialize stack pointers.
1852      Waste one element of value and location stack
1853      so that they stay on the same level as the state stack.
1854      The wasted elements are never initialized.  */
1855   yyssp = yyss;
1856   yyvsp = yyvs;
1857
1858   goto yysetstate;
1859
1860 /*------------------------------------------------------------.
1861 | yynewstate -- Push a new state, which is found in yystate.  |
1862 `------------------------------------------------------------*/
1863  yynewstate:
1864   /* In all cases, when you get here, the value and location stacks
1865      have just been pushed.  So pushing a state here evens the stacks.  */
1866   yyssp++;
1867
1868  yysetstate:
1869   *yyssp = yystate;
1870
1871   if (yyss + yystacksize - 1 <= yyssp)
1872     {
1873       /* Get the current used size of the three stacks, in elements.  */
1874       YYSIZE_T yysize = yyssp - yyss + 1;
1875
1876 #ifdef yyoverflow
1877       {
1878   /* Give user a chance to reallocate the stack.  Use copies of
1879      these so that the &'s don't force the real ones into
1880      memory.  */
1881   YYSTYPE *yyvs1 = yyvs;
1882   yytype_int16 *yyss1 = yyss;
1883
1884   /* Each stack pointer address is followed by the size of the
1885      data in use in that stack, in bytes.  This used to be a
1886      conditional around just the two extra args, but that might
1887      be undefined if yyoverflow is a macro.  */
1888   yyoverflow (YY_("memory exhausted"),
1889         &yyss1, yysize * sizeof (*yyssp),
1890         &yyvs1, yysize * sizeof (*yyvsp),
1891         &yystacksize);
1892
1893   yyss = yyss1;
1894   yyvs = yyvs1;
1895       }
1896 #else /* no yyoverflow */
1897 # ifndef YYSTACK_RELOCATE
1898       goto yyexhaustedlab;
1899 # else
1900       /* Extend the stack our own way.  */
1901       if (YYMAXDEPTH <= yystacksize)
1902   goto yyexhaustedlab;
1903       yystacksize *= 2;
1904       if (YYMAXDEPTH < yystacksize)
1905   yystacksize = YYMAXDEPTH;
1906
1907       {
1908   yytype_int16 *yyss1 = yyss;
1909   union yyalloc *yyptr =
1910     (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1911   if (! yyptr)
1912     goto yyexhaustedlab;
1913   YYSTACK_RELOCATE (yyss_alloc, yyss);
1914   YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1915 #  undef YYSTACK_RELOCATE
1916   if (yyss1 != yyssa)
1917     YYSTACK_FREE (yyss1);
1918       }
1919 # endif
1920 #endif /* no yyoverflow */
1921
1922       yyssp = yyss + yysize - 1;
1923       yyvsp = yyvs + yysize - 1;
1924
1925       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1926       (unsigned long int) yystacksize));
1927
1928       if (yyss + yystacksize - 1 <= yyssp)
1929   YYABORT;
1930     }
1931
1932   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1933
1934   if (yystate == YYFINAL)
1935     YYACCEPT;
1936
1937   goto yybackup;
1938
1939 /*-----------.
1940 | yybackup.  |
1941 `-----------*/
1942 yybackup:
1943
1944   /* Do appropriate processing given the current state.  Read a
1945      lookahead token if we need one and don't already have one.  */
1946
1947   /* First try to decide what to do without reference to lookahead token.  */
1948   yyn = yypact[yystate];
1949   if (yyn == YYPACT_NINF)
1950     goto yydefault;
1951
1952   /* Not known => get a lookahead token if don't already have one.  */
1953
1954   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1955   if (yychar == YYEMPTY)
1956     {
1957       YYDPRINTF ((stderr, "Reading a token: "));
1958       yychar = YYLEX;
1959     }
1960
1961   if (yychar <= YYEOF)
1962     {
1963       yychar = yytoken = YYEOF;
1964       YYDPRINTF ((stderr, "Now at end of input.\n"));
1965     }
1966   else
1967     {
1968       yytoken = YYTRANSLATE (yychar);
1969       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1970     }
1971
1972   /* If the proper action on seeing token YYTOKEN is to reduce or to
1973      detect an error, take that action.  */
1974   yyn += yytoken;
1975   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1976     goto yydefault;
1977   yyn = yytable[yyn];
1978   if (yyn <= 0)
1979     {
1980       if (yyn == 0 || yyn == YYTABLE_NINF)
1981   goto yyerrlab;
1982       yyn = -yyn;
1983       goto yyreduce;
1984     }
1985
1986   /* Count tokens shifted since error; after three, turn off error
1987      status.  */
1988   if (yyerrstatus)
1989     yyerrstatus--;
1990
1991   /* Shift the lookahead token.  */
1992   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1993
1994   /* Discard the shifted token.  */
1995   yychar = YYEMPTY;
1996
1997   yystate = yyn;
1998   *++yyvsp = yylval;
1999
2000   goto yynewstate;
2001
2002
2003 /*-----------------------------------------------------------.
2004 | yydefault -- do the default action for the current state.  |
2005 `-----------------------------------------------------------*/
2006 yydefault:
2007   yyn = yydefact[yystate];
2008   if (yyn == 0)
2009     goto yyerrlab;
2010   goto yyreduce;
2011
2012
2013 /*-----------------------------.
2014 | yyreduce -- Do a reduction.  |
2015 `-----------------------------*/
2016 yyreduce:
2017   /* yyn is the number of a rule to reduce with.  */
2018   yylen = yyr2[yyn];
2019
2020   /* If YYLEN is nonzero, implement the default value of the action:
2021      `$$ = $1'.
2022
2023      Otherwise, the following line sets YYVAL to garbage.
2024      This behavior is undocumented and Bison
2025      users should not rely upon it.  Assigning to YYVAL
2026      unconditionally makes the parser a bit smaller, and it avoids a
2027      GCC warning that YYVAL may be used uninitialized.  */
2028   yyval = yyvsp[1-yylen];
2029
2030
2031   YY_REDUCE_PRINT (yyn);
2032   switch (yyn)
2033     {
2034         case 3:
2035
2036 /* Line 1455 of yacc.c  */
2037 #line 284 "vtkParse.y"
2038     {
2039            ((yyval.vtkid)).name = (yyvsp[(1) - (2)].str);
2040            ((yyval.vtkid)).external = 1;
2041          ;}
2042     break;
2043
2044   case 4:
2045
2046 /* Line 1455 of yacc.c  */
2047 #line 289 "vtkParse.y"
2048     {
2049            ((yyval.vtkid)).name = (yyvsp[(1) - (1)].str);
2050            ((yyval.vtkid)).external = 0;
2051          ;}
2052     break;
2053
2054   case 5:
2055
2056 /* Line 1455 of yacc.c  */
2057 #line 295 "vtkParse.y"
2058     {
2059       data.ClassName = vtkstrdup((yyvsp[(2) - (2)].str));
2060       ;}
2061     break;
2062
2063   case 13:
2064
2065 /* Line 1455 of yacc.c  */
2066 #line 305 "vtkParse.y"
2067     { output_function(); ;}
2068     break;
2069
2070   case 14:
2071
2072 /* Line 1455 of yacc.c  */
2073 #line 306 "vtkParse.y"
2074     { output_function(); ;}
2075     break;
2076
2077   case 15:
2078
2079 /* Line 1455 of yacc.c  */
2080 #line 307 "vtkParse.y"
2081     { legacySig(); output_function(); ;}
2082     break;
2083
2084   case 19:
2085
2086 /* Line 1455 of yacc.c  */
2087 #line 313 "vtkParse.y"
2088     { preSig("~"); ;}
2089     break;
2090
2091   case 20:
2092
2093 /* Line 1455 of yacc.c  */
2094 #line 314 "vtkParse.y"
2095     { preSig("virtual ~"); ;}
2096     break;
2097
2098   case 22:
2099
2100 /* Line 1455 of yacc.c  */
2101 #line 317 "vtkParse.y"
2102     {
2103          currentFunction->ReturnType = (yyvsp[(1) - (2)].integer);
2104          ;}
2105     break;
2106
2107   case 23:
2108
2109 /* Line 1455 of yacc.c  */
2110 #line 321 "vtkParse.y"
2111     {
2112          currentFunction->ReturnType = (yyvsp[(1) - (3)].integer);
2113          ;}
2114     break;
2115
2116   case 24:
2117
2118 /* Line 1455 of yacc.c  */
2119 #line 325 "vtkParse.y"
2120     {
2121          preSig("virtual ");
2122          currentFunction->ReturnType = (yyvsp[(2) - (4)].integer);
2123          ;}
2124     break;
2125
2126   case 25:
2127
2128 /* Line 1455 of yacc.c  */
2129 #line 330 "vtkParse.y"
2130     {
2131          preSig("virtual ");
2132          currentFunction->ReturnType = (yyvsp[(2) - (3)].integer);
2133          ;}
2134     break;
2135
2136   case 26:
2137
2138 /* Line 1455 of yacc.c  */
2139 #line 335 "vtkParse.y"
2140     {
2141          preSig("virtual ");
2142          ;}
2143     break;
2144
2145   case 27:
2146
2147 /* Line 1455 of yacc.c  */
2148 #line 341 "vtkParse.y"
2149     {
2150          output_function();
2151          ;}
2152     break;
2153
2154   case 28:
2155
2156 /* Line 1455 of yacc.c  */
2157 #line 345 "vtkParse.y"
2158     {
2159          currentFunction->ReturnType = (yyvsp[(1) - (2)].integer);
2160          output_function();
2161          ;}
2162     break;
2163
2164   case 29:
2165
2166 /* Line 1455 of yacc.c  */
2167 #line 350 "vtkParse.y"
2168     {
2169          currentFunction->ReturnType = (yyvsp[(1) - (3)].integer);
2170          output_function();
2171          ;}
2172     break;
2173
2174   case 30:
2175
2176 /* Line 1455 of yacc.c  */
2177 #line 355 "vtkParse.y"
2178     {
2179          preSig("virtual ");
2180          currentFunction->ReturnType = (yyvsp[(2) - (4)].integer);
2181          output_function();
2182          ;}
2183     break;
2184
2185   case 31:
2186
2187 /* Line 1455 of yacc.c  */
2188 #line 361 "vtkParse.y"
2189     {
2190          preSig("virtual ");
2191          currentFunction->ReturnType = (yyvsp[(2) - (3)].integer);
2192          output_function();
2193          ;}
2194     break;
2195
2196   case 32:
2197
2198 /* Line 1455 of yacc.c  */
2199 #line 367 "vtkParse.y"
2200     {
2201          preSig("virtual ");
2202          output_function();
2203          ;}
2204     break;
2205
2206   case 33:
2207
2208 /* Line 1455 of yacc.c  */
2209 #line 373 "vtkParse.y"
2210     {
2211       currentFunction->IsOperator = 1;
2212       vtkParseDebug("Converted operator", 0);
2213     ;}
2214     break;
2215
2216   case 34:
2217
2218 /* Line 1455 of yacc.c  */
2219 #line 378 "vtkParse.y"
2220     { postSig(")"); ;}
2221     break;
2222
2223   case 35:
2224
2225 /* Line 1455 of yacc.c  */
2226 #line 378 "vtkParse.y"
2227     { postSig(";"); openSig = 0; ;}
2228     break;
2229
2230   case 36:
2231
2232 /* Line 1455 of yacc.c  */
2233 #line 379 "vtkParse.y"
2234     {
2235       openSig = 1;
2236       currentFunction->Name = (yyvsp[(1) - (4)].str);
2237       vtkParseDebug("Parsed func", (yyvsp[(1) - (4)].str));
2238     ;}
2239     break;
2240
2241   case 37:
2242
2243 /* Line 1455 of yacc.c  */
2244 #line 385 "vtkParse.y"
2245     {
2246       postSig(") = 0;");
2247       currentFunction->Name = (yyvsp[(1) - (3)].str);
2248       vtkParseDebug("Parsed func", (yyvsp[(1) - (3)].str));
2249       currentFunction->IsPureVirtual = 1;
2250       data.IsAbstract = 1;
2251     ;}
2252     break;
2253
2254   case 39:
2255
2256 /* Line 1455 of yacc.c  */
2257 #line 393 "vtkParse.y"
2258     {postSig(" const");;}
2259     break;
2260
2261   case 40:
2262
2263 /* Line 1455 of yacc.c  */
2264 #line 395 "vtkParse.y"
2265     {postSig(" ("); ;}
2266     break;
2267
2268   case 42:
2269
2270 /* Line 1455 of yacc.c  */
2271 #line 397 "vtkParse.y"
2272     {postSig("const ");;}
2273     break;
2274
2275   case 43:
2276
2277 /* Line 1455 of yacc.c  */
2278 #line 399 "vtkParse.y"
2279     {postSig("static ");;}
2280     break;
2281
2282   case 44:
2283
2284 /* Line 1455 of yacc.c  */
2285 #line 401 "vtkParse.y"
2286     {postSig(((yyvsp[(1) - (1)].vtkid)).name);;}
2287     break;
2288
2289   case 45:
2290
2291 /* Line 1455 of yacc.c  */
2292 #line 401 "vtkParse.y"
2293     {postSig((yyvsp[(1) - (1)].str));;}
2294     break;
2295
2296   case 52:
2297
2298 /* Line 1455 of yacc.c  */
2299 #line 410 "vtkParse.y"
2300     { currentFunction->NumberOfArguments++;;}
2301     break;
2302
2303   case 53:
2304
2305 /* Line 1455 of yacc.c  */
2306 #line 411 "vtkParse.y"
2307     { currentFunction->NumberOfArguments++; postSig(", ");;}
2308     break;
2309
2310   case 55:
2311
2312 /* Line 1455 of yacc.c  */
2313 #line 414 "vtkParse.y"
2314     {
2315       currentFunction->ArgCounts[currentFunction->NumberOfArguments] = 0;
2316       currentFunction->ArgTypes[currentFunction->NumberOfArguments] =
2317         (yyvsp[(1) - (1)].integer);;}
2318     break;
2319
2320   case 56:
2321
2322 /* Line 1455 of yacc.c  */
2323 #line 419 "vtkParse.y"
2324     {
2325       currentFunction->ArgCounts[currentFunction->NumberOfArguments] =
2326         (yyvsp[(2) - (2)].integer) / 0x10000;
2327       currentFunction->ArgTypes[currentFunction->NumberOfArguments] =
2328         (yyvsp[(1) - (2)].integer) + (yyvsp[(2) - (2)].integer) % 0x10000;
2329     ;}
2330     break;
2331
2332   case 58:
2333
2334 /* Line 1455 of yacc.c  */
2335 #line 426 "vtkParse.y"
2336     {
2337       postSig("void (*func)(void *) ");
2338       currentFunction->ArgCounts[currentFunction->NumberOfArguments] = 0;
2339       currentFunction->ArgTypes[currentFunction->NumberOfArguments] = 0x5000;
2340     ;}
2341     break;
2342
2343   case 61:
2344
2345 /* Line 1455 of yacc.c  */
2346 #line 434 "vtkParse.y"
2347     {delSig();;}
2348     break;
2349
2350   case 62:
2351
2352 /* Line 1455 of yacc.c  */
2353 #line 434 "vtkParse.y"
2354     {delSig();;}
2355     break;
2356
2357   case 63:
2358
2359 /* Line 1455 of yacc.c  */
2360 #line 436 "vtkParse.y"
2361     { (yyval.integer) = (yyvsp[(2) - (2)].integer); ;}
2362     break;
2363
2364   case 64:
2365
2366 /* Line 1455 of yacc.c  */
2367 #line 444 "vtkParse.y"
2368     { (yyval.integer) = 0; ;}
2369     break;
2370
2371   case 65:
2372
2373 /* Line 1455 of yacc.c  */
2374 #line 445 "vtkParse.y"
2375     { char temp[100]; sprintf(temp,"[%i]",(yyvsp[(1) - (1)].integer));
2376                    postSig(temp); ;}
2377     break;
2378
2379   case 66:
2380
2381 /* Line 1455 of yacc.c  */
2382 #line 447 "vtkParse.y"
2383     { (yyval.integer) = 0x300 + 0x10000 * (yyvsp[(1) - (3)].integer) + (yyvsp[(3) - (3)].integer) % 0x1000; ;}
2384     break;
2385
2386   case 67:
2387
2388 /* Line 1455 of yacc.c  */
2389 #line 449 "vtkParse.y"
2390     { postSig("[]"); (yyval.integer) = 0x300 + (yyvsp[(4) - (4)].integer) % 0x1000; ;}
2391     break;
2392
2393   case 68:
2394
2395 /* Line 1455 of yacc.c  */
2396 #line 451 "vtkParse.y"
2397     {(yyval.integer) = 0x1000 + (yyvsp[(2) - (2)].integer);;}
2398     break;
2399
2400   case 69:
2401
2402 /* Line 1455 of yacc.c  */
2403 #line 452 "vtkParse.y"
2404     {(yyval.integer) = (yyvsp[(1) - (1)].integer);;}
2405     break;
2406
2407   case 70:
2408
2409 /* Line 1455 of yacc.c  */
2410 #line 453 "vtkParse.y"
2411     {(yyval.integer) = 0x2000 + (yyvsp[(2) - (2)].integer);;}
2412     break;
2413
2414   case 71:
2415
2416 /* Line 1455 of yacc.c  */
2417 #line 454 "vtkParse.y"
2418     {(yyval.integer) = 0x3000 + (yyvsp[(3) - (3)].integer);;}
2419     break;
2420
2421   case 72:
2422
2423 /* Line 1455 of yacc.c  */
2424 #line 456 "vtkParse.y"
2425     {(yyval.integer) = (yyvsp[(1) - (1)].integer);;}
2426     break;
2427
2428   case 73:
2429
2430 /* Line 1455 of yacc.c  */
2431 #line 458 "vtkParse.y"
2432     {(yyval.integer) = (yyvsp[(1) - (2)].integer) + (yyvsp[(2) - (2)].integer);;}
2433     break;
2434
2435   case 74:
2436
2437 /* Line 1455 of yacc.c  */
2438 #line 459 "vtkParse.y"
2439     {(yyval.integer) = (yyvsp[(1) - (1)].integer);;}
2440     break;
2441
2442   case 75:
2443
2444 /* Line 1455 of yacc.c  */
2445 #line 461 "vtkParse.y"
2446     {(yyval.integer) = (yyvsp[(1) - (1)].integer);;}
2447     break;
2448
2449   case 76:
2450
2451 /* Line 1455 of yacc.c  */
2452 #line 462 "vtkParse.y"
2453     { postSig("&"); (yyval.integer) = (yyvsp[(1) - (2)].integer);;}
2454     break;
2455
2456   case 77:
2457
2458 /* Line 1455 of yacc.c  */
2459 #line 463 "vtkParse.y"
2460     { postSig("*"); (yyval.integer) = 0x400 + (yyvsp[(1) - (2)].integer);;}
2461     break;
2462
2463   case 78:
2464
2465 /* Line 1455 of yacc.c  */
2466 #line 465 "vtkParse.y"
2467     { postSig("vtkStdString "); (yyval.integer) = 0x1303; ;}
2468     break;
2469
2470   case 79:
2471
2472 /* Line 1455 of yacc.c  */
2473 #line 475 "vtkParse.y"
2474     { postSig("&"); (yyval.integer) = 0x100;;}
2475     break;
2476
2477   case 80:
2478
2479 /* Line 1455 of yacc.c  */
2480 #line 476 "vtkParse.y"
2481     { postSig("*"); (yyval.integer) = 0x300;;}
2482     break;
2483
2484   case 81:
2485
2486 /* Line 1455 of yacc.c  */
2487 #line 477 "vtkParse.y"
2488     { (yyval.integer) = 0x100 + (yyvsp[(2) - (2)].integer);;}
2489     break;
2490
2491   case 82:
2492
2493 /* Line 1455 of yacc.c  */
2494 #line 478 "vtkParse.y"
2495     { (yyval.integer) = 0x400 + (yyvsp[(2) - (2)].integer);;}
2496     break;
2497
2498   case 83:
2499
2500 /* Line 1455 of yacc.c  */
2501 #line 480 "vtkParse.y"
2502     {postSig("unsigned ");;}
2503     break;
2504
2505   case 84:
2506
2507 /* Line 1455 of yacc.c  */
2508 #line 481 "vtkParse.y"
2509     { (yyval.integer) = 0x10 + (yyvsp[(3) - (3)].integer);;}
2510     break;
2511
2512   case 85:
2513
2514 /* Line 1455 of yacc.c  */
2515 #line 482 "vtkParse.y"
2516     { (yyval.integer) = (yyvsp[(1) - (1)].integer);;}
2517     break;
2518
2519   case 86:
2520
2521 /* Line 1455 of yacc.c  */
2522 #line 485 "vtkParse.y"
2523     { postSig("vtkTypeInt8 "); (yyval.integer) = VTK_PARSE_INT8; ;}
2524     break;
2525
2526   case 87:
2527
2528 /* Line 1455 of yacc.c  */
2529 #line 486 "vtkParse.y"
2530     { postSig("vtkTypeUInt8 "); (yyval.integer) = VTK_PARSE_UINT8; ;}
2531     break;
2532
2533   case 88:
2534
2535 /* Line 1455 of yacc.c  */
2536 #line 487 "vtkParse.y"
2537     { postSig("vtkTypeInt16 "); (yyval.integer) = VTK_PARSE_INT16; ;}
2538     break;
2539
2540   case 89:
2541
2542 /* Line 1455 of yacc.c  */
2543 #line 488 "vtkParse.y"
2544     { postSig("vtkTypeUInt16 "); (yyval.integer) = VTK_PARSE_UINT16; ;}
2545     break;
2546
2547   case 90:
2548
2549 /* Line 1455 of yacc.c  */
2550 #line 489 "vtkParse.y"
2551     { postSig("vtkTypeInt32 "); (yyval.integer) = VTK_PARSE_INT32; ;}
2552     break;
2553
2554   case 91:
2555
2556 /* Line 1455 of yacc.c  */
2557 #line 490 "vtkParse.y"
2558     { postSig("vtkTypeUInt32 "); (yyval.integer) = VTK_PARSE_UINT32; ;}
2559     break;
2560
2561   case 92:
2562
2563 /* Line 1455 of yacc.c  */
2564 #line 491 "vtkParse.y"
2565     { postSig("vtkTypeInt64 "); (yyval.integer) = VTK_PARSE_INT64; ;}
2566     break;
2567
2568   case 93:
2569
2570 /* Line 1455 of yacc.c  */
2571 #line 492 "vtkParse.y"
2572     { postSig("vtkTypeUInt64 "); (yyval.integer) = VTK_PARSE_UINT64; ;}
2573     break;
2574
2575   case 94:
2576
2577 /* Line 1455 of yacc.c  */
2578 #line 493 "vtkParse.y"
2579     { postSig("vtkTypeFloat32 "); (yyval.integer) = VTK_PARSE_FLOAT32; ;}
2580     break;
2581
2582   case 95:
2583
2584 /* Line 1455 of yacc.c  */
2585 #line 494 "vtkParse.y"
2586     { postSig("vtkTypeFloat64 "); (yyval.integer) = VTK_PARSE_FLOAT64; ;}
2587     break;
2588
2589   case 96:
2590
2591 /* Line 1455 of yacc.c  */
2592 #line 495 "vtkParse.y"
2593     { postSig("float "); (yyval.integer) = 0x1;;}
2594     break;
2595
2596   case 97:
2597
2598 /* Line 1455 of yacc.c  */
2599 #line 496 "vtkParse.y"
2600     { postSig("void "); (yyval.integer) = 0x2;;}
2601     break;
2602
2603   case 98:
2604
2605 /* Line 1455 of yacc.c  */
2606 #line 497 "vtkParse.y"
2607     { postSig("char "); (yyval.integer) = 0x3;;}
2608     break;
2609
2610   case 99:
2611
2612 /* Line 1455 of yacc.c  */
2613 #line 498 "vtkParse.y"
2614     { postSig("int "); (yyval.integer) = 0x4;;}
2615     break;
2616
2617   case 100:
2618
2619 /* Line 1455 of yacc.c  */
2620 #line 499 "vtkParse.y"
2621     { postSig("short "); (yyval.integer) = 0x5;;}
2622     break;
2623
2624   case 101:
2625
2626 /* Line 1455 of yacc.c  */
2627 #line 500 "vtkParse.y"
2628     { postSig("long "); (yyval.integer) = 0x6;;}
2629     break;
2630
2631   case 102:
2632
2633 /* Line 1455 of yacc.c  */
2634 #line 501 "vtkParse.y"
2635     { postSig("double "); (yyval.integer) = 0x7;;}
2636     break;
2637
2638   case 103:
2639
2640 /* Line 1455 of yacc.c  */
2641 #line 502 "vtkParse.y"
2642     {
2643       char ctmpid[2048];
2644       sprintf(ctmpid,"%s ",(yyvsp[(1) - (1)].str));
2645       postSig(ctmpid);
2646       (yyval.integer) = 0x8;;}
2647     break;
2648
2649   case 104:
2650
2651 /* Line 1455 of yacc.c  */
2652 #line 508 "vtkParse.y"
2653     {
2654       char ctmpid[2048];
2655       sprintf(ctmpid,"%s ",((yyvsp[(1) - (1)].vtkid)).name);
2656       postSig(ctmpid);
2657       (yyval.integer) = 0x9;
2658       currentFunction->ArgClasses[currentFunction->NumberOfArguments] =
2659         vtkstrdup(((yyvsp[(1) - (1)].vtkid)).name);
2660       currentFunction->ArgExternals[currentFunction->NumberOfArguments] =
2661         ((yyvsp[(1) - (1)].vtkid)).external;
2662       /* store the string into the return value just in case we need it */
2663       /* this is a parsing hack because the first "type" parser will */
2664       /* possibly be ht ereturn type of the first argument */
2665       if ((!currentFunction->ReturnClass) &&
2666           (!currentFunction->NumberOfArguments))
2667         {
2668         currentFunction->ReturnClass = vtkstrdup(((yyvsp[(1) - (1)].vtkid)).name);
2669         currentFunction->ReturnExternal = ((yyvsp[(1) - (1)].vtkid)).external;
2670         }
2671     ;}
2672     break;
2673
2674   case 105:
2675
2676 /* Line 1455 of yacc.c  */
2677 #line 527 "vtkParse.y"
2678     { postSig("vtkIdType "); (yyval.integer) = 0xA;;}
2679     break;
2680
2681   case 106:
2682
2683 /* Line 1455 of yacc.c  */
2684 #line 528 "vtkParse.y"
2685     { postSig("long long "); (yyval.integer) = 0xB;;}
2686     break;
2687
2688   case 107:
2689
2690 /* Line 1455 of yacc.c  */
2691 #line 529 "vtkParse.y"
2692     { postSig("__int64 "); (yyval.integer) = 0xC;;}
2693     break;
2694
2695   case 108:
2696
2697 /* Line 1455 of yacc.c  */
2698 #line 530 "vtkParse.y"
2699     { postSig("signed char "); (yyval.integer) = 0xD;;}
2700     break;
2701
2702   case 109:
2703
2704 /* Line 1455 of yacc.c  */
2705 #line 531 "vtkParse.y"
2706     { postSig("bool "); (yyval.integer) = 0xE;;}
2707     break;
2708
2709   case 112:
2710
2711 /* Line 1455 of yacc.c  */
2712 #line 536 "vtkParse.y"
2713     {
2714       data.SuperClasses[data.NumberOfSuperClasses] = vtkstrdup((yyvsp[(2) - (2)].str));
2715       data.NumberOfSuperClasses++;
2716     ;}
2717     break;
2718
2719   case 113:
2720
2721 /* Line 1455 of yacc.c  */
2722 #line 541 "vtkParse.y"
2723     {
2724       data.SuperClasses[data.NumberOfSuperClasses] = vtkstrdup((yyvsp[(2) - (2)].str));
2725       data.NumberOfSuperClasses++;
2726     ;}
2727     break;
2728
2729   case 115:
2730
2731 /* Line 1455 of yacc.c  */
2732 #line 546 "vtkParse.y"
2733     {in_public = 1; in_protected = 0;;}
2734     break;
2735
2736   case 116:
2737
2738 /* Line 1455 of yacc.c  */
2739 #line 547 "vtkParse.y"
2740     {in_public = 0; in_protected = 0;;}
2741     break;
2742
2743   case 117:
2744
2745 /* Line 1455 of yacc.c  */
2746 #line 548 "vtkParse.y"
2747     {in_public = 0; in_protected = 1;;}
2748     break;
2749
2750   case 120:
2751
2752 /* Line 1455 of yacc.c  */
2753 #line 552 "vtkParse.y"
2754     {(yyval.integer) = (yyvsp[(1) - (1)].integer);;}
2755     break;
2756
2757   case 121:
2758
2759 /* Line 1455 of yacc.c  */
2760 #line 553 "vtkParse.y"
2761     {(yyval.integer) = -1;;}
2762     break;
2763
2764   case 122:
2765
2766 /* Line 1455 of yacc.c  */
2767 #line 553 "vtkParse.y"
2768     {(yyval.integer) = -1;;}
2769     break;
2770
2771   case 123:
2772
2773 /* Line 1455 of yacc.c  */
2774 #line 557 "vtkParse.y"
2775     {preSig("void Set"); postSig(" ("); ;}
2776     break;
2777
2778   case 124:
2779
2780 /* Line 1455 of yacc.c  */
2781 #line 558 "vtkParse.y"
2782     {
2783    postSig(");");
2784    sprintf(temps,"Set%s",(yyvsp[(3) - (7)].str));
2785    currentFunction->Name = vtkstrdup(temps);
2786    currentFunction->NumberOfArguments = 1;
2787    currentFunction->ArgTypes[0] = (yyvsp[(6) - (7)].integer);
2788    currentFunction->ArgCounts[0] = 0;
2789    currentFunction->ReturnType = 0x2;
2790    output_function();
2791    ;}
2792     break;
2793
2794   case 125:
2795
2796 /* Line 1455 of yacc.c  */
2797 #line 568 "vtkParse.y"
2798     {postSig("Get");;}
2799     break;
2800
2801   case 126:
2802
2803 /* Line 1455 of yacc.c  */
2804 #line 568 "vtkParse.y"
2805     {postSig(" ();"); invertSig = 1;;}
2806     break;
2807
2808   case 127:
2809
2810 /* Line 1455 of yacc.c  */
2811 #line 570 "vtkParse.y"
2812     {
2813    sprintf(temps,"Get%s",(yyvsp[(4) - (8)].str));
2814    currentFunction->Name = vtkstrdup(temps);
2815    currentFunction->NumberOfArguments = 0;
2816    currentFunction->ReturnType = (yyvsp[(7) - (8)].integer);
2817    output_function();
2818    ;}
2819     break;
2820
2821   case 128:
2822
2823 /* Line 1455 of yacc.c  */
2824 #line 577 "vtkParse.y"
2825     {preSig("void Set");;}
2826     break;
2827
2828   case 129:
2829
2830 /* Line 1455 of yacc.c  */
2831 #line 578 "vtkParse.y"
2832     {
2833    postSig(" (char *);");
2834    sprintf(temps,"Set%s",(yyvsp[(4) - (5)].str));
2835    currentFunction->Name = vtkstrdup(temps);
2836    currentFunction->NumberOfArguments = 1;
2837    currentFunction->ArgTypes[0] = 0x303;
2838    currentFunction->ArgCounts[0] = 0;
2839    currentFunction->ReturnType = 0x2;
2840    output_function();
2841    ;}
2842     break;
2843
2844   case 130:
2845
2846 /* Line 1455 of yacc.c  */
2847 #line 588 "vtkParse.y"
2848     {preSig("char *Get");;}
2849     break;
2850
2851   case 131:
2852
2853 /* Line 1455 of yacc.c  */
2854 #line 589 "vtkParse.y"
2855     {
2856    postSig(" ();");
2857    sprintf(temps,"Get%s",(yyvsp[(4) - (5)].str));
2858    currentFunction->Name = vtkstrdup(temps);
2859    currentFunction->NumberOfArguments = 0;
2860    currentFunction->ReturnType = 0x303;
2861    output_function();
2862    ;}
2863     break;
2864
2865   case 132:
2866
2867 /* Line 1455 of yacc.c  */
2868 #line 598 "vtkParse.y"
2869     {preSig("void Set"); postSig(" ("); ;}
2870     break;
2871
2872   case 133:
2873
2874 /* Line 1455 of yacc.c  */
2875 #line 599 "vtkParse.y"
2876     {postSig(");"); openSig = 0;;}
2877     break;
2878
2879   case 134:
2880
2881 /* Line 1455 of yacc.c  */
2882 #line 600 "vtkParse.y"
2883     {
2884    char *local = vtkstrdup(currentFunction->Signature);
2885    sscanf (currentFunction->Signature, "%*s %*s (%s);", local);
2886    sprintf(temps,"Set%s",(yyvsp[(3) - (10)].str));
2887    currentFunction->Name = vtkstrdup(temps);
2888    currentFunction->NumberOfArguments = 1;
2889    currentFunction->ArgTypes[0] = (yyvsp[(6) - (10)].integer);
2890    currentFunction->ArgCounts[0] = 0;
2891    currentFunction->ReturnType = 0x2;
2892    output_function();
2893
2894    currentFunction->Signature = (char *)malloc(2048);
2895    sigAllocatedLength = 2048;
2896    sprintf(currentFunction->Signature,"%s Get%sMinValue ();",local,(yyvsp[(3) - (10)].str));
2897    sprintf(temps,"Get%sMinValue",(yyvsp[(3) - (10)].str));
2898    currentFunction->Name = vtkstrdup(temps);
2899    currentFunction->NumberOfArguments = 0;
2900    currentFunction->ReturnType = (yyvsp[(6) - (10)].integer);
2901    output_function();
2902
2903    currentFunction->Signature = (char *)malloc(2048);
2904    sigAllocatedLength = 2048;
2905    sprintf(currentFunction->Signature,"%s Get%sMaxValue ();",local,(yyvsp[(3) - (10)].str));
2906    sprintf(temps,"Get%sMaxValue",(yyvsp[(3) - (10)].str));
2907    currentFunction->Name = vtkstrdup(temps);
2908    currentFunction->NumberOfArguments = 0;
2909    currentFunction->ReturnType = (yyvsp[(6) - (10)].integer);
2910    output_function();
2911    ;}
2912     break;
2913
2914   case 135:
2915
2916 /* Line 1455 of yacc.c  */
2917 #line 630 "vtkParse.y"
2918     {preSig("void Set"); postSig(" ("); ;}
2919     break;
2920
2921   case 136:
2922
2923 /* Line 1455 of yacc.c  */
2924 #line 631 "vtkParse.y"
2925     {
2926    postSig("*);");
2927    sprintf(temps,"Set%s",(yyvsp[(3) - (7)].str));
2928    currentFunction->Name = vtkstrdup(temps);
2929    currentFunction->NumberOfArguments = 1;
2930    currentFunction->ArgTypes[0] = 0x309;
2931    currentFunction->ArgCounts[0] = 1;
2932    currentFunction->ReturnType = 0x2;
2933    output_function();
2934    ;}
2935     break;
2936
2937   case 137:
2938
2939 /* Line 1455 of yacc.c  */
2940 #line 642 "vtkParse.y"
2941     {preSig("void Set"); postSig(" ("); ;}
2942     break;
2943
2944   case 138:
2945
2946 /* Line 1455 of yacc.c  */
2947 #line 643 "vtkParse.y"
2948     {
2949    postSig("*);");
2950    sprintf(temps,"Set%s",(yyvsp[(3) - (7)].str));
2951    currentFunction->Name = vtkstrdup(temps);
2952    currentFunction->NumberOfArguments = 1;
2953    currentFunction->ArgTypes[0] = 0x309;
2954    currentFunction->ArgCounts[0] = 1;
2955    currentFunction->ReturnType = 0x2;
2956    output_function();
2957    ;}
2958     break;
2959
2960   case 139:
2961
2962 /* Line 1455 of yacc.c  */
2963 #line 653 "vtkParse.y"
2964     {postSig("*Get");;}
2965     break;
2966
2967   case 140:
2968
2969 /* Line 1455 of yacc.c  */
2970 #line 654 "vtkParse.y"
2971     {postSig(" ();"); invertSig = 1;;}
2972     break;
2973
2974   case 141:
2975
2976 /* Line 1455 of yacc.c  */
2977 #line 655 "vtkParse.y"
2978     {
2979    sprintf(temps,"Get%s",(yyvsp[(4) - (8)].str));
2980    currentFunction->Name = vtkstrdup(temps);
2981    currentFunction->NumberOfArguments = 0;
2982    currentFunction->ReturnType = 0x309;
2983    output_function();
2984    ;}
2985     break;
2986
2987   case 142:
2988
2989 /* Line 1455 of yacc.c  */
2990 #line 663 "vtkParse.y"
2991     {preSig("void "); postSig("On ();"); openSig = 0; ;}
2992     break;
2993
2994   case 143:
2995
2996 /* Line 1455 of yacc.c  */
2997 #line 665 "vtkParse.y"
2998     {
2999    sprintf(temps,"%sOn",(yyvsp[(3) - (7)].str));
3000    currentFunction->Name = vtkstrdup(temps);
3001    currentFunction->NumberOfArguments = 0;
3002    currentFunction->ReturnType = 0x2;
3003    output_function();
3004    currentFunction->Signature = (char *)malloc(2048);
3005    sigAllocatedLength = 2048;
3006    sprintf(currentFunction->Signature,"void %sOff ();",(yyvsp[(3) - (7)].str));
3007    sprintf(temps,"%sOff",(yyvsp[(3) - (7)].str));
3008    currentFunction->Name = vtkstrdup(temps);
3009    currentFunction->NumberOfArguments = 0;
3010    output_function();
3011    ;}
3012     break;
3013
3014   case 144:
3015
3016 /* Line 1455 of yacc.c  */
3017 #line 680 "vtkParse.y"
3018     {
3019      free (currentFunction->Signature);
3020      currentFunction->Signature = NULL;
3021      ;}
3022     break;
3023
3024   case 145:
3025
3026 /* Line 1455 of yacc.c  */
3027 #line 685 "vtkParse.y"
3028     {
3029    char *local = vtkstrdup(currentFunction->Signature);
3030    sprintf(currentFunction->Signature,"void Set%s (%s, %s);",(yyvsp[(3) - (7)].str),
3031      local, local);
3032    sprintf(temps,"Set%s",(yyvsp[(3) - (7)].str));
3033    currentFunction->Name = vtkstrdup(temps);
3034    currentFunction->NumberOfArguments = 2;
3035    currentFunction->ArgTypes[0] = (yyvsp[(6) - (7)].integer);
3036    currentFunction->ArgCounts[0] = 0;
3037    currentFunction->ArgTypes[1] = (yyvsp[(6) - (7)].integer);
3038    currentFunction->ArgCounts[1] = 0;
3039    currentFunction->ReturnType = 0x2;
3040    output_function();
3041
3042    currentFunction->Signature = (char *)malloc(2048);
3043    sigAllocatedLength = 2048;
3044    sprintf(currentFunction->Signature,"void Set%s (%s a[2]);",(yyvsp[(3) - (7)].str),
3045      local);
3046    currentFunction->Name = vtkstrdup(temps);
3047    currentFunction->NumberOfArguments = 1;
3048    currentFunction->ArgTypes[0] = 0x300 + (yyvsp[(6) - (7)].integer);
3049    currentFunction->ArgCounts[0] = 0x2;
3050    output_function();
3051    ;}
3052     break;
3053
3054   case 146:
3055
3056 /* Line 1455 of yacc.c  */
3057 #line 710 "vtkParse.y"
3058     {
3059      free (currentFunction->Signature);
3060      currentFunction->Signature = NULL;
3061      ;}
3062     break;
3063
3064   case 147:
3065
3066 /* Line 1455 of yacc.c  */
3067 #line 715 "vtkParse.y"
3068     {
3069    char *local = vtkstrdup(currentFunction->Signature);
3070    sprintf(currentFunction->Signature,"%s *Get%s ();",local, (yyvsp[(3) - (7)].str));
3071    sprintf(temps,"Get%s",(yyvsp[(3) - (7)].str));
3072    currentFunction->Name = vtkstrdup(temps);
3073    currentFunction->NumberOfArguments = 0;
3074    currentFunction->ReturnType = 0x300 + (yyvsp[(6) - (7)].integer);
3075    currentFunction->HaveHint = 1;
3076    currentFunction->HintSize = 2;
3077    output_function();
3078    ;}
3079     break;
3080
3081   case 148:
3082
3083 /* Line 1455 of yacc.c  */
3084 #line 727 "vtkParse.y"
3085     {
3086      free (currentFunction->Signature);
3087      currentFunction->Signature = NULL;
3088      ;}
3089     break;
3090
3091   case 149:
3092
3093 /* Line 1455 of yacc.c  */
3094 #line 732 "vtkParse.y"
3095     {
3096    char *local = vtkstrdup(currentFunction->Signature);
3097    sprintf(currentFunction->Signature,"void Set%s (%s, %s, %s);",
3098      (yyvsp[(3) - (7)].str), local, local, local);
3099    sprintf(temps,"Set%s",(yyvsp[(3) - (7)].str));
3100    currentFunction->Name = vtkstrdup(temps);
3101    currentFunction->NumberOfArguments = 3;
3102    currentFunction->ArgTypes[0] = (yyvsp[(6) - (7)].integer);
3103    currentFunction->ArgCounts[0] = 0;
3104    currentFunction->ArgTypes[1] = (yyvsp[(6) - (7)].integer);
3105    currentFunction->ArgCounts[1] = 0;
3106    currentFunction->ArgTypes[2] = (yyvsp[(6) - (7)].integer);
3107    currentFunction->ArgCounts[2] = 0;
3108    currentFunction->ReturnType = 0x2;
3109    output_function();
3110
3111    currentFunction->Signature = (char *)malloc(2048);
3112    sigAllocatedLength = 2048;
3113    sprintf(currentFunction->Signature,"void Set%s (%s a[3]);",(yyvsp[(3) - (7)].str),
3114      local);
3115    currentFunction->Name = vtkstrdup(temps);
3116    currentFunction->NumberOfArguments = 1;
3117    currentFunction->ArgTypes[0] = 0x300 + (yyvsp[(6) - (7)].integer);
3118    currentFunction->ArgCounts[0] = 3;
3119    output_function();
3120    ;}
3121     break;
3122
3123   case 150:
3124
3125 /* Line 1455 of yacc.c  */
3126 #line 759 "vtkParse.y"
3127     {
3128      free (currentFunction->Signature);
3129      currentFunction->Signature = NULL;
3130      ;}
3131     break;
3132
3133   case 151:
3134
3135 /* Line 1455 of yacc.c  */
3136 #line 764 "vtkParse.y"
3137     {
3138    char *local = vtkstrdup(currentFunction->Signature);
3139    sprintf(currentFunction->Signature,"%s *Get%s ();",local, (yyvsp[(3) - (7)].str));
3140    sprintf(temps,"Get%s",(yyvsp[(3) - (7)].str));
3141    currentFunction->Name = vtkstrdup(temps);
3142    currentFunction->NumberOfArguments = 0;
3143    currentFunction->ReturnType = 0x300 + (yyvsp[(6) - (7)].integer);
3144    currentFunction->HaveHint = 1;
3145    currentFunction->HintSize = 3;
3146    output_function();
3147    ;}
3148     break;
3149
3150   case 152:
3151
3152 /* Line 1455 of yacc.c  */
3153 #line 776 "vtkParse.y"
3154     {
3155      free (currentFunction->Signature);
3156      currentFunction->Signature = NULL;
3157      ;}
3158     break;
3159
3160   case 153:
3161
3162 /* Line 1455 of yacc.c  */
3163 #line 781 "vtkParse.y"
3164     {
3165    char *local = vtkstrdup(currentFunction->Signature);
3166    sprintf(currentFunction->Signature,"void Set%s (%s, %s, %s, %s);",
3167      (yyvsp[(3) - (7)].str), local, local, local, local);
3168    sprintf(temps,"Set%s",(yyvsp[(3) - (7)].str));
3169    currentFunction->Name = vtkstrdup(temps);
3170    currentFunction->NumberOfArguments = 4;
3171    currentFunction->ArgTypes[0] = (yyvsp[(6) - (7)].integer);
3172    currentFunction->ArgCounts[0] = 0;
3173    currentFunction->ArgTypes[1] = (yyvsp[(6) - (7)].integer);
3174    currentFunction->ArgCounts[1] = 0;
3175    currentFunction->ArgTypes[2] = (yyvsp[(6) - (7)].integer);
3176    currentFunction->ArgCounts[2] = 0;
3177    currentFunction->ArgTypes[3] = (yyvsp[(6) - (7)].integer);
3178    currentFunction->ArgCounts[3] = 0;
3179    currentFunction->ReturnType = 0x2;
3180    output_function();
3181
3182    currentFunction->Signature = (char *)malloc(2048);
3183    sigAllocatedLength = 2048;
3184    sprintf(currentFunction->Signature,"void Set%s (%s a[4]);",(yyvsp[(3) - (7)].str),
3185      local);
3186    currentFunction->Name = vtkstrdup(temps);
3187    currentFunction->NumberOfArguments = 1;
3188    currentFunction->ArgTypes[0] = 0x300 + (yyvsp[(6) - (7)].integer);
3189    currentFunction->ArgCounts[0] = 4;
3190    output_function();
3191    ;}
3192     break;
3193
3194   case 154:
3195
3196 /* Line 1455 of yacc.c  */
3197 #line 810 "vtkParse.y"
3198     {
3199      free (currentFunction->Signature);
3200      currentFunction->Signature = NULL;
3201      ;}
3202     break;
3203
3204   case 155:
3205
3206 /* Line 1455 of yacc.c  */
3207 #line 815 "vtkParse.y"
3208     {
3209    char *local = vtkstrdup(currentFunction->Signature);
3210    sprintf(currentFunction->Signature,"%s *Get%s ();",local, (yyvsp[(3) - (7)].str));
3211    sprintf(temps,"Get%s",(yyvsp[(3) - (7)].str));
3212    currentFunction->Name = vtkstrdup(temps);
3213    currentFunction->NumberOfArguments = 0;
3214    currentFunction->ReturnType = 0x300 + (yyvsp[(6) - (7)].integer);
3215    currentFunction->HaveHint = 1;
3216    currentFunction->HintSize = 4;
3217    output_function();
3218    ;}
3219     break;
3220
3221   case 156:
3222
3223 /* Line 1455 of yacc.c  */
3224 #line 827 "vtkParse.y"
3225     {
3226      free (currentFunction->Signature);
3227      currentFunction->Signature = NULL;
3228      ;}
3229     break;
3230
3231   case 157:
3232
3233 /* Line 1455 of yacc.c  */
3234 #line 832 "vtkParse.y"
3235     {
3236    char *local = vtkstrdup(currentFunction->Signature);
3237    sprintf(currentFunction->Signature,"void Set%s (%s, %s, %s, %s, %s, %s);",
3238      (yyvsp[(3) - (7)].str), local, local, local, local, local, local);
3239    sprintf(temps,"Set%s",(yyvsp[(3) - (7)].str));
3240    currentFunction->Name = vtkstrdup(temps);
3241    currentFunction->NumberOfArguments = 6;
3242    currentFunction->ArgTypes[0] = (yyvsp[(6) - (7)].integer);
3243    currentFunction->ArgCounts[0] = 0;
3244    currentFunction->ArgTypes[1] = (yyvsp[(6) - (7)].integer);
3245    currentFunction->ArgCounts[1] = 0;
3246    currentFunction->ArgTypes[2] = (yyvsp[(6) - (7)].integer);
3247    currentFunction->ArgCounts[2] = 0;
3248    currentFunction->ArgTypes[3] = (yyvsp[(6) - (7)].integer);
3249    currentFunction->ArgCounts[3] = 0;
3250    currentFunction->ArgTypes[4] = (yyvsp[(6) - (7)].integer);
3251    currentFunction->ArgCounts[4] = 0;
3252    currentFunction->ArgTypes[5] = (yyvsp[(6) - (7)].integer);
3253    currentFunction->ArgCounts[5] = 0;
3254    currentFunction->ReturnType = 0x2;
3255    output_function();
3256
3257    currentFunction->Signature = (char *)malloc(2048);
3258    sigAllocatedLength = 2048;
3259    sprintf(currentFunction->Signature,"void Set%s (%s a[6]);",(yyvsp[(3) - (7)].str),
3260      local);
3261    currentFunction->Name = vtkstrdup(temps);
3262    currentFunction->NumberOfArguments = 1;
3263    currentFunction->ArgTypes[0] = 0x300 + (yyvsp[(6) - (7)].integer);
3264    currentFunction->ArgCounts[0] = 6;
3265    output_function();
3266    ;}
3267     break;
3268
3269   case 158:
3270
3271 /* Line 1455 of yacc.c  */
3272 #line 865 "vtkParse.y"
3273     {
3274      free (currentFunction->Signature);
3275      currentFunction->Signature = NULL;
3276      ;}
3277     break;
3278
3279   case 159:
3280
3281 /* Line 1455 of yacc.c  */
3282 #line 870 "vtkParse.y"
3283     {
3284    char *local = vtkstrdup(currentFunction->Signature);
3285    sprintf(currentFunction->Signature,"%s *Get%s ();",local, (yyvsp[(3) - (7)].str));
3286    sprintf(temps,"Get%s",(yyvsp[(3) - (7)].str));
3287    currentFunction->Name = vtkstrdup(temps);
3288    currentFunction->NumberOfArguments = 0;
3289    currentFunction->ReturnType = 0x300 + (yyvsp[(6) - (7)].integer);
3290    currentFunction->HaveHint = 1;
3291    currentFunction->HintSize = 6;
3292    output_function();
3293    ;}
3294     break;
3295
3296   case 160:
3297
3298 /* Line 1455 of yacc.c  */
3299 #line 882 "vtkParse.y"
3300     {
3301       free (currentFunction->Signature);
3302       currentFunction->Signature = NULL;
3303       ;}
3304     break;
3305
3306   case 161:
3307
3308 /* Line 1455 of yacc.c  */
3309 #line 887 "vtkParse.y"
3310     {
3311    char *local = vtkstrdup(currentFunction->Signature);
3312    sprintf(currentFunction->Signature,"void Set%s (%s [%i]);",(yyvsp[(3) - (9)].str),
3313       local, (yyvsp[(8) - (9)].integer));
3314      sprintf(temps,"Set%s",(yyvsp[(3) - (9)].str));
3315      currentFunction->Name = vtkstrdup(temps);
3316      currentFunction->ReturnType = 0x2;
3317      currentFunction->NumberOfArguments = 1;
3318      currentFunction->ArgTypes[0] = 0x300 + (yyvsp[(6) - (9)].integer);
3319      currentFunction->ArgCounts[0] = (yyvsp[(8) - (9)].integer);
3320      output_function();
3321    ;}
3322     break;
3323
3324   case 162:
3325
3326 /* Line 1455 of yacc.c  */
3327 #line 900 "vtkParse.y"
3328     {
3329      free (currentFunction->Signature);
3330      currentFunction->Signature = NULL;
3331      ;}
3332     break;
3333
3334   case 163:
3335
3336 /* Line 1455 of yacc.c  */
3337 #line 905 "vtkParse.y"
3338     {
3339    char *local = vtkstrdup(currentFunction->Signature);
3340    sprintf(currentFunction->Signature,"%s *Get%s ();",local, (yyvsp[(3) - (9)].str));
3341    sprintf(temps,"Get%s",(yyvsp[(3) - (9)].str));
3342    currentFunction->Name = vtkstrdup(temps);
3343    currentFunction->NumberOfArguments = 0;
3344    currentFunction->ReturnType = 0x300 + (yyvsp[(6) - (9)].integer);
3345    currentFunction->HaveHint = 1;
3346    currentFunction->HintSize = (yyvsp[(8) - (9)].integer);
3347    output_function();
3348    ;}
3349     break;
3350
3351   case 164:
3352
3353 /* Line 1455 of yacc.c  */
3354 #line 917 "vtkParse.y"
3355     {
3356      sprintf(currentFunction->Signature,"vtkCoordinate *Get%sCoordinate ();",
3357        (yyvsp[(3) - (4)].str));
3358
3359      sprintf(temps,"Get%sCoordinate",(yyvsp[(3) - (4)].str));
3360      currentFunction->Name = vtkstrdup(temps);
3361      currentFunction->NumberOfArguments = 0;
3362      currentFunction->ReturnType = 0x309;
3363      currentFunction->ReturnClass = vtkstrdup("vtkCoordinate");
3364      output_function();
3365
3366      currentFunction->Signature = (char *)malloc(2048);
3367      sigAllocatedLength = 2048;
3368      sprintf(currentFunction->Signature,"void Set%s (double, double);",
3369        (yyvsp[(3) - (4)].str));
3370      sprintf(temps,"Set%s",(yyvsp[(3) - (4)].str));
3371      currentFunction->Name = vtkstrdup(temps);
3372      currentFunction->NumberOfArguments = 2;
3373      currentFunction->ArgTypes[0] = 0x7;
3374      currentFunction->ArgCounts[0] = 0;
3375      currentFunction->ArgTypes[1] = 0x7;
3376      currentFunction->ArgCounts[1] = 0;
3377      currentFunction->ReturnType = 0x2;
3378      output_function();
3379
3380      currentFunction->Signature = (char *)malloc(2048);
3381      sigAllocatedLength = 2048;
3382      sprintf(currentFunction->Signature,"void Set%s (double a[2]);",
3383        (yyvsp[(3) - (4)].str));
3384      currentFunction->Name = vtkstrdup(temps);
3385      currentFunction->NumberOfArguments = 1;
3386      currentFunction->ArgTypes[0] = 0x307;
3387      currentFunction->ArgCounts[0] = 2;
3388      output_function();
3389
3390      currentFunction->Signature = (char *)malloc(2048);
3391      sigAllocatedLength = 2048;
3392      sprintf(currentFunction->Signature,"double *Get%s ();", (yyvsp[(3) - (4)].str));
3393      sprintf(temps,"Get%s",(yyvsp[(3) - (4)].str));
3394      currentFunction->Name = vtkstrdup(temps);
3395      currentFunction->NumberOfArguments = 0;
3396      currentFunction->ReturnType = 0x307;
3397      currentFunction->HaveHint = 1;
3398      currentFunction->HintSize = 2;
3399      output_function();
3400    ;}
3401     break;
3402
3403   case 165:
3404
3405 /* Line 1455 of yacc.c  */
3406 #line 964 "vtkParse.y"
3407     {
3408      sprintf(currentFunction->Signature,"vtkCoordinate *Get%sCoordinate ();",
3409        (yyvsp[(3) - (4)].str));
3410
3411      sprintf(temps,"Get%sCoordinate",(yyvsp[(3) - (4)].str));
3412      currentFunction->Name = vtkstrdup(temps);
3413      currentFunction->NumberOfArguments = 0;
3414      currentFunction->ReturnType = 0x309;
3415      currentFunction->ReturnClass = vtkstrdup("vtkCoordinate");
3416      output_function();
3417
3418      currentFunction->Signature = (char *)malloc(2048);
3419      sigAllocatedLength = 2048;
3420      sprintf(currentFunction->Signature,"void Set%s (double, double, double);",
3421        (yyvsp[(3) - (4)].str));
3422      sprintf(temps,"Set%s",(yyvsp[(3) - (4)].str));
3423      currentFunction->Name = vtkstrdup(temps);
3424      currentFunction->NumberOfArguments = 3;
3425      currentFunction->ArgTypes[0] = 0x7;
3426      currentFunction->ArgCounts[0] = 0;
3427      currentFunction->ArgTypes[1] = 0x7;
3428      currentFunction->ArgCounts[1] = 0;
3429      currentFunction->ArgTypes[2] = 0x7;
3430      currentFunction->ArgCounts[2] = 0;
3431      currentFunction->ReturnType = 0x2;
3432      output_function();
3433
3434      currentFunction->Signature = (char *)malloc(2048);
3435      sigAllocatedLength = 2048;
3436      sprintf(currentFunction->Signature,"void Set%s (double a[3]);",
3437        (yyvsp[(3) - (4)].str));
3438      currentFunction->Name = vtkstrdup(temps);
3439      currentFunction->NumberOfArguments = 1;
3440      currentFunction->ArgTypes[0] = 0x307;
3441      currentFunction->ArgCounts[0] = 3;
3442      output_function();
3443
3444      currentFunction->Signature = (char *)malloc(2048);
3445      sigAllocatedLength = 2048;
3446      sprintf(currentFunction->Signature,"double *Get%s ();", (yyvsp[(3) - (4)].str));
3447      sprintf(temps,"Get%s",(yyvsp[(3) - (4)].str));
3448      currentFunction->Name = vtkstrdup(temps);
3449      currentFunction->NumberOfArguments = 0;
3450      currentFunction->ReturnType = 0x307;
3451      currentFunction->HaveHint = 1;
3452      currentFunction->HintSize = 3;
3453      output_function();
3454    ;}
3455     break;
3456
3457   case 166:
3458
3459 /* Line 1455 of yacc.c  */
3460 #line 1013 "vtkParse.y"
3461     {
3462    currentFunction->Signature = (char *)malloc(2048);
3463    sigAllocatedLength = 2048;
3464    sprintf(currentFunction->Signature, "const char *GetClassName ();");
3465    sprintf(temps,"GetClassName");
3466    currentFunction->Name = vtkstrdup(temps);
3467    currentFunction->NumberOfArguments = 0;
3468    currentFunction->ReturnType = 0x1303;
3469    output_function();
3470
3471    currentFunction->Signature = (char *)malloc(2048);
3472    sigAllocatedLength = 2048;
3473    sprintf(currentFunction->Signature,
3474            "int IsA (const char *name);");
3475    sprintf(temps,"IsA");
3476    currentFunction->Name = vtkstrdup(temps);
3477    currentFunction->NumberOfArguments = 1;
3478    currentFunction->ArgTypes[0] = 0x1303;
3479    currentFunction->ArgCounts[0] = 0;
3480    currentFunction->ReturnType = 0x4;
3481    output_function();
3482
3483    currentFunction->Signature = (char *)malloc(2048);
3484    sigAllocatedLength = 2048;
3485    sprintf(currentFunction->Signature, "%s *NewInstance ();",
3486            (yyvsp[(3) - (6)].str));
3487    sprintf(temps,"NewInstance");
3488    currentFunction->Name = vtkstrdup(temps);
3489    currentFunction->NumberOfArguments = 0;
3490    currentFunction->ReturnType = 0x309;
3491    currentFunction->ReturnClass = vtkstrdup((yyvsp[(3) - (6)].str));
3492    output_function();
3493
3494    if ( data.IsConcrete )
3495      {
3496      currentFunction->Signature = (char *)malloc(2048);
3497      sigAllocatedLength = 2048;
3498      sprintf(currentFunction->Signature, "%s *SafeDownCast (vtkObject* o);",
3499              (yyvsp[(3) - (6)].str));
3500      sprintf(temps,"SafeDownCast");
3501      currentFunction->Name = vtkstrdup(temps);
3502      currentFunction->NumberOfArguments = 1;
3503      currentFunction->ArgTypes[0] = 0x309;
3504      currentFunction->ArgCounts[0] = 1;
3505      currentFunction->ArgClasses[0] = vtkstrdup("vtkObject");
3506      currentFunction->ReturnType = 0x2309;
3507      currentFunction->ReturnClass = vtkstrdup((yyvsp[(3) - (6)].str));
3508      output_function();
3509      }
3510    ;}
3511     break;
3512
3513   case 167:
3514
3515 /* Line 1455 of yacc.c  */
3516 #line 1064 "vtkParse.y"
3517     {
3518    currentFunction->Signature = (char *)malloc(2048);
3519    sigAllocatedLength = 2048;
3520    sprintf(currentFunction->Signature, "const char *GetClassName ();");
3521    sprintf(temps,"GetClassName");
3522    currentFunction->Name = vtkstrdup(temps);
3523    currentFunction->NumberOfArguments = 0;
3524    currentFunction->ReturnType = 0x1303;
3525    output_function();
3526
3527    currentFunction->Signature = (char *)malloc(2048);
3528    sigAllocatedLength = 2048;
3529    sprintf(currentFunction->Signature,
3530            "int IsA (const char *name);");
3531    sprintf(temps,"IsA");
3532    currentFunction->Name = vtkstrdup(temps);
3533    currentFunction->NumberOfArguments = 1;
3534    currentFunction->ArgTypes[0] = 0x1303;
3535    currentFunction->ArgCounts[0] = 0;
3536    currentFunction->ReturnType = 0x4;
3537    output_function();
3538
3539    currentFunction->Signature = (char *)malloc(2048);
3540    sigAllocatedLength = 2048;
3541    sprintf(currentFunction->Signature, "%s *NewInstance ();",
3542            (yyvsp[(3) - (7)].str));
3543    sprintf(temps,"NewInstance");
3544    currentFunction->Name = vtkstrdup(temps);
3545    currentFunction->NumberOfArguments = 0;
3546    currentFunction->ReturnType = 0x309;
3547    currentFunction->ReturnClass = vtkstrdup((yyvsp[(3) - (7)].str));
3548    output_function();
3549
3550    if ( data.IsConcrete )
3551      {
3552      currentFunction->Signature = (char *)malloc(2048);
3553      sigAllocatedLength = 2048;
3554      sprintf(currentFunction->Signature, "%s *SafeDownCast (vtkObject* o);",
3555              (yyvsp[(3) - (7)].str));
3556      sprintf(temps,"SafeDownCast");
3557      currentFunction->Name = vtkstrdup(temps);
3558      currentFunction->NumberOfArguments = 1;
3559      currentFunction->ArgTypes[0] = 0x309;
3560      currentFunction->ArgCounts[0] = 1;
3561      currentFunction->ArgClasses[0] = vtkstrdup("vtkObject");
3562      currentFunction->ReturnType = 0x2309;
3563      currentFunction->ReturnClass = vtkstrdup((yyvsp[(3) - (7)].str));
3564      output_function();
3565      }
3566    ;}
3567     break;
3568
3569
3570
3571 /* Line 1455 of yacc.c  */
3572 #line 3573 "vtkParse.tab.c"
3573       default: break;
3574     }
3575   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3576
3577   YYPOPSTACK (yylen);
3578   yylen = 0;
3579   YY_STACK_PRINT (yyss, yyssp);
3580
3581   *++yyvsp = yyval;
3582
3583   /* Now `shift' the result of the reduction.  Determine what state
3584      that goes to, based on the state we popped back to and the rule
3585      number reduced by.  */
3586
3587   yyn = yyr1[yyn];
3588
3589   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3590   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3591     yystate = yytable[yystate];
3592   else
3593     yystate = yydefgoto[yyn - YYNTOKENS];
3594
3595   goto yynewstate;
3596
3597
3598 /*------------------------------------.
3599 | yyerrlab -- here on detecting error |
3600 `------------------------------------*/
3601 yyerrlab:
3602   /* If not already recovering from an error, report this error.  */
3603   if (!yyerrstatus)
3604     {
3605       ++yynerrs;
3606 #if ! YYERROR_VERBOSE
3607       yyerror (YY_("syntax error"));
3608 #else
3609       {
3610   YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
3611   if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
3612     {
3613       YYSIZE_T yyalloc = 2 * yysize;
3614       if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
3615         yyalloc = YYSTACK_ALLOC_MAXIMUM;
3616       if (yymsg != yymsgbuf)
3617         YYSTACK_FREE (yymsg);
3618       yymsg = (char *) YYSTACK_ALLOC (yyalloc);
3619       if (yymsg)
3620         yymsg_alloc = yyalloc;
3621       else
3622         {
3623     yymsg = yymsgbuf;
3624     yymsg_alloc = sizeof yymsgbuf;
3625         }
3626     }
3627
3628   if (0 < yysize && yysize <= yymsg_alloc)
3629     {
3630       (void) yysyntax_error (yymsg, yystate, yychar);
3631       yyerror (yymsg);
3632     }
3633   else
3634     {
3635       yyerror (YY_("syntax error"));
3636       if (yysize != 0)
3637         goto yyexhaustedlab;
3638     }
3639       }
3640 #endif
3641     }
3642
3643
3644
3645   if (yyerrstatus == 3)
3646     {
3647       /* If just tried and failed to reuse lookahead token after an
3648    error, discard it.  */
3649
3650       if (yychar <= YYEOF)
3651   {
3652     /* Return failure if at end of input.  */
3653     if (yychar == YYEOF)
3654       YYABORT;
3655   }
3656       else
3657   {
3658     yydestruct ("Error: discarding",
3659           yytoken, &yylval);
3660     yychar = YYEMPTY;
3661   }
3662     }
3663
3664   /* Else will try to reuse lookahead token after shifting the error
3665      token.  */
3666   goto yyerrlab1;
3667
3668
3669 /*---------------------------------------------------.
3670 | yyerrorlab -- error raised explicitly by YYERROR.  |
3671 `---------------------------------------------------*/
3672 yyerrorlab:
3673
3674   /* Pacify compilers like GCC when the user code never invokes
3675      YYERROR and the label yyerrorlab therefore never appears in user
3676      code.  */
3677   if (/*CONSTCOND*/ 0)
3678      goto yyerrorlab;
3679
3680   /* Do not reclaim the symbols of the rule which action triggered
3681      this YYERROR.  */
3682   YYPOPSTACK (yylen);
3683   yylen = 0;
3684   YY_STACK_PRINT (yyss, yyssp);
3685   yystate = *yyssp;
3686   goto yyerrlab1;
3687
3688
3689 /*-------------------------------------------------------------.
3690 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
3691 `-------------------------------------------------------------*/
3692 yyerrlab1:
3693   yyerrstatus = 3;  /* Each real token shifted decrements this.  */
3694
3695   for (;;)
3696     {
3697       yyn = yypact[yystate];
3698       if (yyn != YYPACT_NINF)
3699   {
3700     yyn += YYTERROR;
3701     if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3702       {
3703         yyn = yytable[yyn];
3704         if (0 < yyn)
3705     break;
3706       }
3707   }
3708
3709       /* Pop the current state because it cannot handle the error token.  */
3710       if (yyssp == yyss)
3711   YYABORT;
3712
3713
3714       yydestruct ("Error: popping",
3715       yystos[yystate], yyvsp);
3716       YYPOPSTACK (1);
3717       yystate = *yyssp;
3718       YY_STACK_PRINT (yyss, yyssp);
3719     }
3720
3721   *++yyvsp = yylval;
3722
3723
3724   /* Shift the error token.  */
3725   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3726
3727   yystate = yyn;
3728   goto yynewstate;
3729
3730
3731 /*-------------------------------------.
3732 | yyacceptlab -- YYACCEPT comes here.  |
3733 `-------------------------------------*/
3734 yyacceptlab:
3735   yyresult = 0;
3736   goto yyreturn;
3737
3738 /*-----------------------------------.
3739 | yyabortlab -- YYABORT comes here.  |
3740 `-----------------------------------*/
3741 yyabortlab:
3742   yyresult = 1;
3743   goto yyreturn;
3744
3745 #if !defined(yyoverflow) || YYERROR_VERBOSE
3746 /*-------------------------------------------------.
3747 | yyexhaustedlab -- memory exhaustion comes here.  |
3748 `-------------------------------------------------*/
3749 yyexhaustedlab:
3750   yyerror (YY_("memory exhausted"));
3751   yyresult = 2;
3752   /* Fall through.  */
3753 #endif
3754
3755 yyreturn:
3756   if (yychar != YYEMPTY)
3757      yydestruct ("Cleanup: discarding lookahead",
3758      yytoken, &yylval);
3759   /* Do not reclaim the symbols of the rule which action triggered
3760      this YYABORT or YYACCEPT.  */
3761   YYPOPSTACK (yylen);
3762   YY_STACK_PRINT (yyss, yyssp);
3763   while (yyssp != yyss)
3764     {
3765       yydestruct ("Cleanup: popping",
3766       yystos[*yyssp], yyvsp);
3767       YYPOPSTACK (1);
3768     }
3769 #ifndef yyoverflow
3770   if (yyss != yyssa)
3771     YYSTACK_FREE (yyss);
3772 #endif
3773 #if YYERROR_VERBOSE
3774   if (yymsg != yymsgbuf)
3775     YYSTACK_FREE (yymsg);
3776 #endif
3777   /* Make sure YYID is used.  */
3778   return YYID (yyresult);
3779 }
3780
3781
3782
3783 /* Line 1675 of yacc.c  */
3784 #line 1132 "vtkParse.y"
3785
3786 #include <string.h>
3787 #include "lex.yy.c"
3788
3789 static void vtkParseDebug(const char* s1, const char* s2)
3790 {
3791   if ( getenv("DEBUG") )
3792     {
3793     fprintf(stderr, "   %s", s1);
3794     if ( s2 )
3795       {
3796       fprintf(stderr, " %s", s2);
3797       }
3798     fprintf(stderr, "\n");
3799     }
3800 }
3801
3802 /* initialize the structure */
3803 void InitFunction(FunctionInfo *func)
3804 {
3805   func->Name = NULL;
3806   func->NumberOfArguments = 0;
3807   func->ArrayFailure = 0;
3808   func->IsPureVirtual = 0;
3809   func->IsPublic = 0;
3810   func->IsOperator = 0;
3811   func->HaveHint = 0;
3812   func->HintSize = 0;
3813   func->ReturnType = 0x2;
3814   func->ReturnClass = NULL;
3815   func->Comment = NULL;
3816   func->Signature = NULL;
3817   func->IsLegacy = 0;
3818   sigAllocatedLength = 0;
3819   openSig = 1;
3820   invertSig = 0;
3821 }
3822
3823 /* when the cpp file doesn't have enough info use the hint file */
3824 void look_for_hint(void)
3825 {
3826   char h_cls[80];
3827   char h_func[80];
3828   unsigned int  h_type;
3829   int  h_value;
3830
3831   /* reset the position */
3832   if (!fhint)
3833     {
3834     return;
3835     }
3836   rewind(fhint);
3837
3838   /* first find a hint */
3839   while (fscanf(fhint,"%s %s %x %i",h_cls,h_func,&h_type,&h_value) != EOF)
3840     {
3841     if ((!strcmp(h_cls,data.ClassName))&&
3842         currentFunction->Name &&
3843         (!strcmp(h_func,currentFunction->Name))&&
3844         ((int)h_type == currentFunction->ReturnType))
3845       {
3846       currentFunction->HaveHint = 1;
3847       currentFunction->HintSize = h_value;
3848       }
3849     }
3850 }
3851
3852 /* a simple routine that updates a few variables */
3853 void output_function()
3854 {
3855   int i;
3856
3857   /* a void argument is the same as no arguements */
3858   if (currentFunction->ArgTypes[0] % 0x1000 == 0x2)
3859     {
3860     currentFunction->NumberOfArguments = 0;
3861     }
3862
3863   currentFunction->IsPublic = in_public;
3864   currentFunction->IsProtected = in_protected;
3865
3866   /* look for VAR FUNCTIONS */
3867   if (currentFunction->NumberOfArguments
3868       && (currentFunction->ArgTypes[0] == 0x5000))
3869     {
3870     if (currentFunction->NumberOfArguments == 2)
3871       {
3872       currentFunction->NumberOfArguments = 1;
3873       }
3874     else
3875       {
3876       currentFunction->ArrayFailure = 1;
3877       }
3878     }
3879
3880   /* is it a delete function */
3881   if (currentFunction->Name && !strcmp("Delete",currentFunction->Name))
3882     {
3883     data.HasDelete = 1;
3884     }
3885
3886
3887   /* if we need a return type hint and dont currently have one */
3888   /* then try to find one */
3889   if (!currentFunction->HaveHint)
3890     {
3891     switch (currentFunction->ReturnType % 0x1000)
3892       {
3893       case 0x301: case 0x302: case 0x307: case 0x30A: case 0x30B: case 0x30C:
3894       case 0x304: case 0x305: case 0x306: case 0x313:
3895         look_for_hint();
3896         break;
3897       }
3898     }
3899
3900   /* reject multi-dimensional arrays from wrappers */
3901   for (i = 0; i < currentFunction->NumberOfArguments; i++)
3902     {
3903     if ((currentFunction->ArgTypes[i] % 0x1000)/0x100 == 0x6 ||
3904         (currentFunction->ArgTypes[i] % 0x1000)/0x100 == 0x9)
3905       {
3906       currentFunction->ArrayFailure = 1;
3907       }
3908     }
3909
3910   if (HaveComment)
3911     {
3912     currentFunction->Comment = vtkstrdup(CommentText);
3913     }
3914
3915   data.NumberOfFunctions++;
3916   currentFunction = data.Functions + data.NumberOfFunctions;
3917   InitFunction(currentFunction);
3918 }
3919
3920 extern void vtkParseOutput(FILE *,FileInfo *);
3921
3922 int main(int argc,char *argv[])
3923 {
3924   FILE *fin;
3925   int ret;
3926   FILE *fout;
3927
3928   if (argc < 4 || argc > 5)
3929     {
3930     fprintf(stderr,
3931             "Usage: %s input_file <hint_file> is_concrete output_file\n",argv[0]);
3932     exit(1);
3933     }
3934
3935   if (!(fin = fopen(argv[1],"r")))
3936     {
3937     fprintf(stderr,"Error opening input file %s\n",argv[1]);
3938     exit(1);
3939     }
3940
3941   fhint = 0;
3942   data.FileName = argv[1];
3943   data.NameComment = NULL;
3944   data.Description = NULL;
3945   data.Caveats = NULL;
3946   data.SeeAlso = NULL;
3947   CommentState = 0;
3948
3949   if (argc == 5)
3950     {
3951     if (!(fhint = fopen(argv[2],"r")))
3952       {
3953       fprintf(stderr,"Error opening hint file %s\n",argv[2]);
3954       exit(1);
3955       }
3956     data.IsConcrete = atoi(argv[3]);
3957     }
3958   else
3959     {
3960     data.IsConcrete = atoi(argv[2]);
3961     }
3962
3963   currentFunction = data.Functions;
3964   InitFunction(currentFunction);
3965
3966   yyin = fin;
3967   yyout = stdout;
3968   ret = yyparse();
3969   if (ret)
3970     {
3971     fprintf(stdout,
3972             "*** SYNTAX ERROR found in parsing the header file %s before line %d ***\n",
3973             argv[1], yylineno);
3974     return ret;
3975     }
3976
3977   if (argc == 5)
3978     {
3979     fout = fopen(argv[4],"w");
3980     data.OutputFileName = argv[4];
3981     }
3982   else
3983     {
3984     fout = fopen(argv[3],"w");
3985     data.OutputFileName = argv[3];
3986     }
3987
3988   if (!fout)
3989     {
3990     fprintf(stderr,"Error opening output file %s\n",argv[3]);
3991     exit(1);
3992     }
3993   vtkParseOutput(fout,&data);
3994   fclose (fout);
3995
3996   return 0;
3997 }
3998
3999
4000