Back to index

salome-paravis  6.5.0
vtkParse.tab.c
Go to the documentation of this file.
00001 
00002 /* A Bison parser, made by GNU Bison 2.4.1.  */
00003 
00004 /* Skeleton implementation for Bison's Yacc-like parsers in C
00005 
00006       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
00007    Free Software Foundation, Inc.
00008 
00009    This program is free software: you can redistribute it and/or modify
00010    it under the terms of the GNU General Public License as published by
00011    the Free Software Foundation, either version 3 of the License, or
00012    (at your option) any later version.
00013 
00014    This program is distributed in the hope that it will be useful,
00015    but WITHOUT ANY WARRANTY; without even the implied warranty of
00016    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017    GNU General Public License for more details.
00018 
00019    You should have received a copy of the GNU General Public License
00020    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
00021 
00022 /* As a special exception, you may create a larger work that contains
00023    part or all of the Bison parser skeleton and distribute that work
00024    under terms of your choice, so long as that work isn't itself a
00025    parser generator using the skeleton or a modified version thereof
00026    as a parser skeleton.  Alternatively, if you modify or redistribute
00027    the parser skeleton itself, you may (at your option) remove this
00028    special exception, which will cause the skeleton and the resulting
00029    Bison output files to be licensed under the GNU General Public
00030    License without this special exception.
00031 
00032    This special exception was added by the Free Software Foundation in
00033    version 2.2 of Bison.  */
00034 
00035 /* C LALR(1) parser skeleton written by Richard Stallman, by
00036    simplifying the original so-called "semantic" parser.  */
00037 
00038 /* All symbols defined below should begin with yy or YY, to avoid
00039    infringing on user name space.  This should be done even for local
00040    variables, as they might otherwise be expanded by user macros.
00041    There are some unavoidable exceptions within include files to
00042    define necessary library symbols; they are noted "INFRINGES ON
00043    USER NAME SPACE" below.  */
00044 
00045 /* Identify Bison output.  */
00046 #define YYBISON 1
00047 
00048 /* Bison version.  */
00049 #define YYBISON_VERSION "2.4.1"
00050 
00051 /* Skeleton name.  */
00052 #define YYSKELETON_NAME "yacc.c"
00053 
00054 /* Pure parsers.  */
00055 #define YYPURE 0
00056 
00057 /* Push parsers.  */
00058 #define YYPUSH 0
00059 
00060 /* Pull parsers.  */
00061 #define YYPULL 1
00062 
00063 /* Using locations.  */
00064 #define YYLSP_NEEDED 0
00065 
00066 
00067 
00068 /* Copy the first part of user declarations.  */
00069 
00070 /* Line 189 of yacc.c  */
00071 #line 15 "vtkParse.y"
00072 
00073 
00074 /*
00075 
00076 This file must be translated to C and modified to build everywhere.
00077 
00078 Run yacc like this:
00079 
00080   yacc -b vtkParse vtkParse.y
00081 
00082 Modify vtkParse.tab.c:
00083   - convert TABs to spaces (eight per tab)
00084   - remove spaces from ends of lines, s/ *$//g
00085   - remove the "goto yyerrlab1;" that appears right before yyerrlab1:
00086   - remove the #defined constants that appear right after the anonymous_enums
00087 
00088 */
00089 
00090 #include <stdio.h>
00091 #include <stdlib.h>
00092 #include <string.h>
00093 #define yyerror(a) fprintf(stderr,"%s\n",a)
00094 #define yywrap() 1
00095 
00096 /* Make sure yacc-generated code knows we have included stdlib.h.  */
00097 #ifndef _STDLIB_H
00098 # define _STDLIB_H
00099 #endif
00100 #define YYINCLUDED_STDLIB_H
00101 
00102 /* Borland and MSVC do not define __STDC__ properly. */
00103 #if !defined(__STDC__)
00104 # if (defined(_MSC_VER) && _MSC_VER >= 1200) || defined(__BORLANDC__)
00105 #  define __STDC__ 1
00106 # endif
00107 #endif
00108 
00109 /* Disable warnings in generated code. */
00110 #if defined(_MSC_VER)
00111 # pragma warning (disable: 4127) /* conditional expression is constant */
00112 # pragma warning (disable: 4244) /* conversion to smaller integer type */
00113 #endif
00114 #if defined(__BORLANDC__)
00115 # pragma warn -8004 /* assigned a value that is never used */
00116 # pragma warn -8008 /* conditional is always true */
00117 # pragma warn -8066 /* unreachable code */
00118 #endif
00119 
00120 /* Map from the type anonymous_enumeration in vtkType.h to the VTK wrapping type
00121    system number for the type. */
00122 
00123 #include "vtkParse.h"
00124 #include "vtkParseInternal.h"
00125 #include "vtkParsePreprocess.h"
00126 #include "vtkType.h"
00127 
00128 static unsigned int vtkParseTypeMap[] =
00129   {
00130   VTK_PARSE_VOID,               /* VTK_VOID                0 */
00131   0,                            /* VTK_BIT                 1 */
00132   VTK_PARSE_CHAR,               /* VTK_CHAR                2 */
00133   VTK_PARSE_UNSIGNED_CHAR,      /* VTK_UNSIGNED_CHAR       3 */
00134   VTK_PARSE_SHORT,              /* VTK_SHORT               4 */
00135   VTK_PARSE_UNSIGNED_SHORT,     /* VTK_UNSIGNED_SHORT      5 */
00136   VTK_PARSE_INT,                /* VTK_INT                 6 */
00137   VTK_PARSE_UNSIGNED_INT,       /* VTK_UNSIGNED_INT        7 */
00138   VTK_PARSE_LONG,               /* VTK_LONG                8 */
00139   VTK_PARSE_UNSIGNED_LONG,      /* VTK_UNSIGNED_LONG       9 */
00140   VTK_PARSE_FLOAT,              /* VTK_FLOAT              10 */
00141   VTK_PARSE_DOUBLE,             /* VTK_DOUBLE             11 */
00142   VTK_PARSE_ID_TYPE,            /* VTK_ID_TYPE            12 */
00143   VTK_PARSE_STRING,             /* VTK_STRING             13 */
00144   0,                            /* VTK_OPAQUE             14 */
00145   VTK_PARSE_SIGNED_CHAR,        /* VTK_SIGNED_CHAR        15 */
00146   VTK_PARSE_LONG_LONG,          /* VTK_LONG_LONG          16 */
00147   VTK_PARSE_UNSIGNED_LONG_LONG, /* VTK_UNSIGNED_LONG_LONG 17 */
00148   VTK_PARSE___INT64,            /* VTK___INT64            18 */
00149   VTK_PARSE_UNSIGNED___INT64,   /* VTK_UNSIGNED___INT64   19 */
00150   0,                            /* VTK_VARIANT            20 */
00151   0,                            /* VTK_OBJECT             21 */
00152   VTK_PARSE_UNICODE_STRING      /* VTK_UNICODE_STRING     22 */
00153   };
00154 
00155 /* Define some constants to simplify references to the table lookup in
00156    the type_primitive production rule code.  */
00157 #define VTK_PARSE_INT8 vtkParseTypeMap[VTK_TYPE_INT8]
00158 #define VTK_PARSE_UINT8 vtkParseTypeMap[VTK_TYPE_UINT8]
00159 #define VTK_PARSE_INT16 vtkParseTypeMap[VTK_TYPE_INT16]
00160 #define VTK_PARSE_UINT16 vtkParseTypeMap[VTK_TYPE_UINT16]
00161 #define VTK_PARSE_INT32 vtkParseTypeMap[VTK_TYPE_INT32]
00162 #define VTK_PARSE_UINT32 vtkParseTypeMap[VTK_TYPE_UINT32]
00163 #define VTK_PARSE_INT64 vtkParseTypeMap[VTK_TYPE_INT64]
00164 #define VTK_PARSE_UINT64 vtkParseTypeMap[VTK_TYPE_UINT64]
00165 #define VTK_PARSE_FLOAT32 vtkParseTypeMap[VTK_TYPE_FLOAT32]
00166 #define VTK_PARSE_FLOAT64 vtkParseTypeMap[VTK_TYPE_FLOAT64]
00167 
00168 #define vtkParseDebug(s1, s2) \
00169   if ( parseDebug ) { fprintf(stderr, "   %s %s\n", s1, s2); }
00170 
00171 /* the tokenizer */
00172 int yylex(void);
00173 
00174 /* the "preprocessor" */
00175 PreprocessInfo preprocessor = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
00176 
00177 /* global variables */
00178 FileInfo data;
00179 
00180 int            NumberOfConcreteClasses = 0;
00181 const char   **ConcreteClasses;
00182 
00183 NamespaceInfo *currentNamespace = NULL;
00184 ClassInfo     *currentClass = NULL;
00185 FunctionInfo  *currentFunction = NULL;
00186 TemplateArgs  *currentTemplate = NULL;
00187 
00188 const char    *currentEnumName = 0;
00189 const char    *currentEnumValue = 0;
00190 
00191 int            parseDebug;
00192 parse_access_t access_level = VTK_ACCESS_PUBLIC;
00193 int            IgnoreBTX = 0;
00194 
00195 /* helper functions */
00196 void start_class(const char *classname, int is_struct_or_union);
00197 void reject_class(const char *classname, int is_struct_or_union);
00198 void end_class();
00199 void output_function(void);
00200 void reject_function(void);
00201 void set_return(FunctionInfo *func, unsigned int type,
00202                 const char *typeclass, int count);
00203 void add_argument(FunctionInfo *func, unsigned int type,
00204                   const char *classname, int count);
00205 void add_using(const char *name, int is_namespace);
00206 void start_enum(const char *enumname);
00207 void add_enum(const char *name, const char *value);
00208 void end_enum();
00209 void add_constant(const char *name, const char *value,
00210                   unsigned int type, const char *typeclass, int global);
00211 const char *add_const_scope(const char *name);
00212 void prepend_scope(char *cp, const char *arg);
00213 unsigned int add_indirection(unsigned int tval, unsigned int ptr);
00214 unsigned int add_indirection_to_array(unsigned int ptr);
00215 void handle_complex_type(ValueInfo *val, unsigned int datatype,
00216                          unsigned int extra, const char *funcSig);
00217 void handle_function_type(ValueInfo *arg, const char *name,
00218                           const char *funcSig);
00219 
00220 void outputSetVectorMacro(const char *var, unsigned int argType,
00221                           const char *typeText, int n);
00222 void outputGetVectorMacro(const char *var, unsigned int argType,
00223                           const char *typeText, int n);
00224 
00225 /*----------------------------------------------------------------
00226  * String utility methods
00227  *
00228  * Strings are centrally allocated and are const, and they are not
00229  * freed until the program exits.  If they need to be freed before
00230  * then, vtkstrfree() can be called.
00231  */
00232 
00233 size_t stringChunkPos = 0;
00234 int numberOfChunks = 0;
00235 char **stringArray = NULL;
00236 
00237 /* allocate a string of n+1 bytes */
00238 static char *vtkstralloc(size_t n)
00239 {
00240   size_t chunk_size = 8176;
00241   size_t nextChunkPos;
00242   char *cp;
00243 
00244   // align next start position on an 8-byte boundary
00245   nextChunkPos = (((stringChunkPos + n + 8) | 7 ) - 7);
00246 
00247   if (numberOfChunks == 0 || nextChunkPos > chunk_size)
00248     {
00249     if (n + 1 > chunk_size)
00250       {
00251       chunk_size = n + 1;
00252       }
00253     cp = (char *)malloc(chunk_size);
00254     vtkParse_AddStringToArray((const char ***)&stringArray, &numberOfChunks,
00255                               cp);
00256     stringChunkPos = 0;
00257     nextChunkPos = (((n + 8) | 7) - 7);
00258     }
00259 
00260   cp = &stringArray[numberOfChunks-1][stringChunkPos];
00261   cp[0] = '\0';
00262 
00263   stringChunkPos = nextChunkPos;
00264 
00265   return cp;
00266 }
00267 
00268 /* free all allocated strings */
00269 void vtkstrfree()
00270 {
00271   int i;
00272 
00273   for (i = 0; i < numberOfChunks; i++)
00274     {
00275     free(stringArray[i]);
00276     }
00277   if (stringArray)
00278     {
00279     free(stringArray);
00280     }
00281 
00282   stringArray = NULL;
00283   numberOfChunks = 0;
00284 }
00285 
00286 /* duplicate the first n bytes of a string and terminate */
00287 static const char *vtkstrndup(const char *in, size_t n)
00288 {
00289   char *res = NULL;
00290 
00291   res = vtkstralloc(n);
00292   strncpy(res, in, n);
00293   res[n] = '\0';
00294 
00295   return res;
00296 }
00297 
00298 /* duplicate a string */
00299 static const char *vtkstrdup(const char *in)
00300 {
00301   if (in)
00302     {
00303     return vtkstrndup(in, strlen(in));
00304     }
00305 
00306   return in;
00307 }
00308 
00309 /* helper function for concatenating strings */
00310 static const char *vtkstrncat(size_t n, const char **str)
00311 {
00312   char *cp;
00313   size_t i;
00314   size_t j[8];
00315   size_t m = 0;
00316 
00317   for (i = 0; i < n; i++)
00318     {
00319     j[i] = 0;
00320     if (str[i])
00321       {
00322       j[i] = strlen(str[i]);
00323       m += j[i];
00324       }
00325     }
00326   cp = vtkstralloc(m);
00327   m = 0;
00328   for (i = 0; i < n; i++)
00329     {
00330     if (j[i])
00331       {
00332       strncpy(&cp[m], str[i], j[i]);
00333       m += j[i];
00334       }
00335     }
00336   cp[m] = '\0';
00337 
00338   return cp;
00339 }
00340 
00341 /* concatenate strings */
00342 static const char *vtkstrcat(const char *str1, const char *str2)
00343 {
00344   const char *cp[2];
00345 
00346   cp[0] = str1;
00347   cp[1] = str2;
00348   return vtkstrncat(2, cp);
00349 }
00350 
00351 static const char *vtkstrcat3(const char *str1, const char *str2,
00352                               const char *str3)
00353 {
00354   const char *cp[3];
00355 
00356   cp[0] = str1;
00357   cp[1] = str2;
00358   cp[2] = str3;
00359   return vtkstrncat(3, cp);
00360 }
00361 
00362 static const char *vtkstrcat4(const char *str1, const char *str2,
00363                               const char *str3, const char *str4)
00364 {
00365   const char *cp[4];
00366 
00367   cp[0] = str1;
00368   cp[1] = str2;
00369   cp[2] = str3;
00370   cp[3] = str4;
00371   return vtkstrncat(4, cp);
00372 }
00373 
00374 static const char *vtkstrcat5(const char *str1, const char *str2,
00375                               const char *str3, const char *str4,
00376                               const char *str5)
00377 {
00378   const char *cp[5];
00379 
00380   cp[0] = str1;
00381   cp[1] = str2;
00382   cp[2] = str3;
00383   cp[3] = str4;
00384   cp[4] = str5;
00385   return vtkstrncat(5, cp);
00386 }
00387 
00388 static const char *vtkstrcat6(const char *str1, const char *str2,
00389                               const char *str3, const char *str4,
00390                               const char *str5, const char *str6)
00391 {
00392   const char *cp[6];
00393 
00394   cp[0] = str1;
00395   cp[1] = str2;
00396   cp[2] = str3;
00397   cp[3] = str4;
00398   cp[4] = str5;
00399   cp[5] = str6;
00400   return vtkstrncat(6, cp);
00401 }
00402 
00403 static const char *vtkstrcat7(const char *str1, const char *str2,
00404                               const char *str3, const char *str4,
00405                               const char *str5, const char *str6,
00406                               const char *str7)
00407 {
00408   const char *cp[7];
00409 
00410   cp[0] = str1;
00411   cp[1] = str2;
00412   cp[2] = str3;
00413   cp[3] = str4;
00414   cp[4] = str5;
00415   cp[5] = str6;
00416   cp[6] = str7;
00417   return vtkstrncat(7, cp);
00418 }
00419 
00420 /*----------------------------------------------------------------
00421  * Comments
00422  */
00423 
00424 /* "private" variables */
00425 char          *commentText = NULL;
00426 size_t         commentLength = 0;
00427 size_t         commentAllocatedLength = 0;
00428 int            commentState = 0;
00429 
00430 const char *getComment()
00431 {
00432   if (commentState != 0)
00433     {
00434     return commentText;
00435     }
00436   return NULL;
00437 }
00438 
00439 void clearComment()
00440 {
00441   commentLength = 0;
00442   if (commentText)
00443     {
00444     commentText[commentLength] = '\0';
00445     }
00446   commentState = 0;
00447 }
00448 
00449 void addCommentLine(const char *line, size_t n)
00450 {
00451   if (commentState <= 0)
00452     {
00453     clearComment();
00454     return;
00455     }
00456 
00457   if (commentText == NULL)
00458     {
00459     commentAllocatedLength = n+80;
00460     commentText = (char *)malloc(commentAllocatedLength);
00461     commentLength = 0;
00462     commentText[0] = '\0';
00463     }
00464   else if (commentLength + n + 2 > commentAllocatedLength)
00465     {
00466     commentAllocatedLength = commentAllocatedLength + commentLength + n + 2;
00467     commentText = (char *)realloc(commentText, commentAllocatedLength);
00468     }
00469 
00470   if (n > 0)
00471     {
00472     memcpy(&commentText[commentLength], line, n);
00473     }
00474   commentLength += n;
00475   commentText[commentLength++] = '\n';
00476   commentText[commentLength] = '\0';
00477 }
00478 
00479 void closeComment()
00480 {
00481   switch (commentState)
00482     {
00483     case 1:
00484       /* Make comment persist until a new comment starts */
00485       commentState = -1;
00486       break;
00487     case 2:
00488       data.Description = vtkstrdup(getComment());
00489       clearComment();
00490       break;
00491     case 3:
00492       data.SeeAlso = vtkstrdup(getComment());
00493       clearComment();
00494       break;
00495     case 4:
00496       data.Caveats = vtkstrdup(getComment());
00497       clearComment();
00498       break;
00499     }
00500 }
00501 
00502 void closeOrClearComment()
00503 {
00504   if (commentState < 0)
00505     {
00506     clearComment();
00507     }
00508   else
00509     {
00510     closeComment();
00511     }
00512 }
00513 
00514 void setCommentState(int state)
00515 {
00516   switch (state)
00517     {
00518     case 0:
00519       closeComment();
00520       break;
00521     default:
00522       closeComment();
00523       clearComment();
00524       break;
00525     }
00526 
00527   commentState = state;
00528 }
00529 
00530 
00531 /*----------------------------------------------------------------
00532  * Namespaces
00533  *
00534  * operates on: currentNamespace
00535  */
00536 
00537 /* "private" variables */
00538 NamespaceInfo *namespaceStack[10];
00539 int namespaceDepth = 0;
00540 
00541 /* enter a namespace */
00542 void pushNamespace(const char *name)
00543 {
00544   int i;
00545   NamespaceInfo *oldNamespace = currentNamespace;
00546 
00547   for (i = 0; i < oldNamespace->NumberOfNamespaces; i++)
00548     {
00549     /* see if the namespace already exists */
00550     if (strcmp(name, oldNamespace->Namespaces[i]->Name) == 0)
00551       {
00552       currentNamespace = oldNamespace->Namespaces[i];
00553       }
00554     }
00555 
00556   /* create a new namespace */
00557   if (i == oldNamespace->NumberOfNamespaces)
00558     {
00559     currentNamespace = (NamespaceInfo *)malloc(sizeof(NamespaceInfo));
00560     vtkParse_InitNamespace(currentNamespace);
00561     currentNamespace->Name = vtkstrdup(name);
00562     vtkParse_AddNamespaceToNamespace(oldNamespace, currentNamespace);
00563     }
00564 
00565   namespaceStack[namespaceDepth++] = oldNamespace;
00566 }
00567 
00568 /* leave the namespace */
00569 void popNamespace()
00570 {
00571   currentNamespace = namespaceStack[--namespaceDepth];
00572 }
00573 
00574 
00575 /*----------------------------------------------------------------
00576  * Classes
00577  *
00578  * operates on: currentClass, access_level
00579  */
00580 
00581 /* "private" variables */
00582 ClassInfo *classStack[10];
00583 parse_access_t classAccessStack[10];
00584 int classDepth = 0;
00585 
00586 /* start an internal class definition */
00587 void pushClass()
00588 {
00589   classAccessStack[classDepth] = access_level;
00590   classStack[classDepth++] = currentClass;
00591 }
00592 
00593 /* leave the internal class */
00594 void popClass()
00595 {
00596   currentClass = classStack[--classDepth];
00597   access_level = classAccessStack[classDepth];
00598 }
00599 
00600 
00601 /*----------------------------------------------------------------
00602  * Templates
00603  *
00604  * operates on: currentTemplate
00605  */
00606 
00607 /* "private" variables */
00608 TemplateArgs *templateStack[10];
00609 int templateDepth = 0;
00610 
00611 /* begin a template */
00612 void startTemplate()
00613 {
00614   currentTemplate = (TemplateArgs *)malloc(sizeof(TemplateArgs));
00615   vtkParse_InitTemplateArgs(currentTemplate);
00616 }
00617 
00618 /* clear a template, if set */
00619 void clearTemplate()
00620 {
00621   if (currentTemplate)
00622     {
00623     free(currentTemplate);
00624     }
00625   currentTemplate = NULL;
00626 }
00627 
00628 /* push the template onto the stack, and start a new one */
00629 void pushTemplate()
00630 {
00631   templateStack[templateDepth++] = currentTemplate;
00632   startTemplate();
00633 }
00634 
00635 /* pop a template off the stack */
00636 void popTemplate()
00637 {
00638   currentTemplate = templateStack[--templateDepth];
00639 }
00640 
00641 /*----------------------------------------------------------------
00642  * Function signatures
00643  *
00644  * operates on: currentFunction
00645  */
00646 
00647 /* "private" variables */
00648 int sigClosed = 0;
00649 size_t sigMark[10];
00650 size_t sigLength = 0;
00651 size_t sigAllocatedLength = 0;
00652 int sigMarkDepth = 0;
00653 char *signature = NULL;
00654 
00655 /* start a new signature */
00656 void startSig()
00657 {
00658   signature = NULL;
00659   sigLength = 0;
00660   sigAllocatedLength = 0;
00661   sigClosed = 0;
00662   sigMarkDepth = 0;
00663   sigMark[0] = 0;
00664 }
00665 
00666 /* get the signature */
00667 const char *getSig()
00668 {
00669   return signature;
00670 }
00671 
00672 /* reallocate Signature if n chars cannot be appended */
00673 void checkSigSize(size_t n)
00674 {
00675   const char *ccp;
00676 
00677   if (sigAllocatedLength == 0)
00678     {
00679     sigAllocatedLength = 80 + n;
00680     signature = vtkstralloc(sigAllocatedLength);
00681     signature[0] = '\0';
00682     }
00683   else if (sigLength + n > sigAllocatedLength)
00684     {
00685     sigAllocatedLength += sigLength + n;
00686     ccp = signature;
00687     signature = vtkstralloc(sigAllocatedLength);
00688     strncpy(signature, ccp, sigLength);
00689     signature[sigLength] = '\0';
00690     }
00691 }
00692 
00693 /* close the signature, i.e. allow no more additions to it */
00694 void closeSig()
00695 {
00696   sigClosed = 1;
00697 }
00698 
00699 /* re-open the signature */
00700 void openSig()
00701 {
00702   sigClosed = 0;
00703 }
00704 
00705 /* insert text at the beginning of the signature */
00706 void preSig(const char *arg)
00707 {
00708   size_t n;
00709 
00710   n = strlen(arg);
00711 
00712   if (!signature)
00713     {
00714     checkSigSize(n);
00715     strncpy(signature, arg, n);
00716     signature[n] = '\0';
00717     sigLength = n;
00718     }
00719   else if (!sigClosed && n > 0)
00720     {
00721     checkSigSize(n);
00722     memmove(&signature[n], signature, sigLength);
00723     strncpy(signature, arg, n);
00724     sigLength += n;
00725     signature[sigLength] = '\0';
00726     }
00727 }
00728 
00729 /* append text to the end of the signature */
00730 void postSig(const char *arg)
00731 {
00732   size_t n;
00733 
00734   n = strlen(arg);
00735 
00736   if (!signature)
00737     {
00738     checkSigSize(n);
00739     strncpy(signature, arg, n);
00740     signature[n] = '\0';
00741     sigLength = n;
00742     }
00743   else if (!sigClosed)
00744     {
00745     checkSigSize(n);
00746     strncpy(&signature[sigLength], arg, n);
00747     sigLength += n;
00748     signature[sigLength] = '\0';
00749     }
00750 }
00751 
00752 /* prepend a scope:: to the ID at the end of the signature */
00753 void preScopeSig(const char *arg)
00754 {
00755   size_t n;
00756 
00757   n = strlen(arg);
00758 
00759   if (!signature)
00760     {
00761     checkSigSize(n);
00762     strncpy(signature, arg, n);
00763     signature[n] = '\0';
00764     sigLength = n;
00765     }
00766   else if (!sigClosed)
00767     {
00768     checkSigSize(n+2);
00769     prepend_scope(signature, arg);
00770     sigLength = strlen(signature);
00771     }
00772 }
00773 
00774 /* set a mark in the signature for later operations */
00775 void markSig()
00776 {
00777   sigMark[sigMarkDepth] = 0;
00778   if (signature)
00779     {
00780     sigMark[sigMarkDepth] = sigLength;
00781     }
00782   sigMarkDepth++;
00783 }
00784 
00785 /* get the contents of the sig from the mark, and clear the mark */
00786 const char *copySig()
00787 {
00788   const char *cp = NULL;
00789   if (sigMarkDepth > 0)
00790     {
00791     sigMarkDepth--;
00792     }
00793   if (signature)
00794     {
00795     cp = &signature[sigMark[sigMarkDepth]];
00796     }
00797   return cp;
00798 }
00799 
00800 /* swap the signature text using the mark as the radix */
00801 void swapSig()
00802 {
00803   if (sigMarkDepth > 0)
00804     {
00805     sigMarkDepth--;
00806     }
00807   if (signature && sigMark[sigMarkDepth] > 0)
00808     {
00809     size_t i, m, n, nn;
00810     char c;
00811     char *cp;
00812     cp = signature;
00813     n = sigLength;
00814     m = sigMark[sigMarkDepth];
00815     nn = m/2;
00816     for (i = 0; i < nn; i++)
00817       {
00818       c = cp[i]; cp[i] = cp[m-i-1]; cp[m-i-1] = c;
00819       }
00820     nn = (n-m)/2;
00821     for (i = 0; i < nn; i++)
00822       {
00823       c = cp[i+m]; cp[i+m] = cp[n-i-1]; cp[n-i-1] = c;
00824       }
00825     nn = n/2;
00826     for (i = 0; i < nn; i++)
00827       {
00828       c = cp[i]; cp[i] = cp[n-i-1]; cp[n-i-1] = c;
00829       }
00830     }
00831 }
00832 
00833 /* chop the last space from the signature */
00834 void chopSig(void)
00835 {
00836   if (signature)
00837     {
00838     size_t n = sigLength;
00839     if (n > 0 && signature[n-1] == ' ')
00840       {
00841       signature[n-1] = '\0';
00842       sigLength--;
00843       }
00844     }
00845 }
00846 
00847 /* mark this signature as legacy */
00848 void legacySig(void)
00849 {
00850   currentFunction->IsLegacy = 1;
00851 }
00852 
00853 /*----------------------------------------------------------------
00854  * Storage type for vars and functions
00855  */
00856 
00857 /* "private" variables */
00858 unsigned int storageType = 0;
00859 
00860 /* save the storage type */
00861 void setStorageType(unsigned int val)
00862 {
00863   storageType = val;
00864 }
00865 
00866 /* modify the indirection (pointers, refs) in the storage type */
00867 void setStorageTypeIndirection(unsigned int ind)
00868 {
00869   storageType = (storageType & ~VTK_PARSE_INDIRECT);
00870   ind = (ind & VTK_PARSE_INDIRECT);
00871   storageType = (storageType | ind);
00872 }
00873 
00874 /* retrieve the storage type */
00875 unsigned int getStorageType()
00876 {
00877   return storageType;
00878 }
00879 
00880 /*----------------------------------------------------------------
00881  * Array information
00882  */
00883 
00884 /* "private" variables */
00885 int numberOfDimensions = 0;
00886 const char **arrayDimensions = NULL;
00887 
00888 /* clear the array counter */
00889 void clearArray(void)
00890 {
00891   numberOfDimensions = 0;
00892   arrayDimensions = NULL;
00893 }
00894 
00895 /* add another dimension */
00896 void pushArraySize(const char *size)
00897 {
00898   vtkParse_AddStringToArray(&arrayDimensions, &numberOfDimensions,
00899                             vtkstrdup(size));
00900 }
00901 
00902 /* add another dimension to the front */
00903 void pushArrayFront(const char *size)
00904 {
00905   int i;
00906 
00907   vtkParse_AddStringToArray(&arrayDimensions, &numberOfDimensions, 0);
00908 
00909   for (i = numberOfDimensions-1; i > 0; i--)
00910     {
00911     arrayDimensions[i] = arrayDimensions[i-1];
00912     }
00913 
00914   arrayDimensions[0] = vtkstrdup(size);
00915 }
00916 
00917 /* get the number of dimensions */
00918 int getArrayNDims()
00919 {
00920   return numberOfDimensions;
00921 }
00922 
00923 /* get the whole array */
00924 const char **getArray()
00925 {
00926   if (numberOfDimensions > 0)
00927     {
00928     return arrayDimensions;
00929     }
00930   return NULL;
00931 }
00932 
00933 /*----------------------------------------------------------------
00934  * Variables and Arguments
00935  */
00936 
00937 /* "private" variables */
00938 char *currentVarName = 0;
00939 char *currentVarValue = 0;
00940 char *currentId = 0;
00941 
00942 /* clear the var Id */
00943 void clearVarName(void)
00944 {
00945   currentVarName = NULL;
00946 }
00947 
00948 /* set the var Id */
00949 void setVarName(const char *text)
00950 {
00951   static char static_text[2048];
00952   currentVarName = static_text;
00953   strcpy(static_text, text);
00954 }
00955 
00956 /* return the var id */
00957 const char *getVarName()
00958 {
00959   return currentVarName;
00960 }
00961 
00962 /* variable value -------------- */
00963 
00964 /* clear the var value */
00965 void clearVarValue(void)
00966 {
00967   currentVarValue = NULL;
00968 }
00969 
00970 /* set the var value */
00971 void setVarValue(const char *text)
00972 {
00973   static char static_text[2048];
00974   currentVarValue = static_text;
00975   strcpy(static_text, text);
00976 }
00977 
00978 /* return the var value */
00979 const char *getVarValue()
00980 {
00981   return currentVarValue;
00982 }
00983 
00984 /* variable type -------------- */
00985 
00986 /* clear the current Id */
00987 void clearTypeId(void)
00988 {
00989   currentId = NULL;
00990 }
00991 
00992 /* set the current Id, it is sticky until cleared */
00993 void setTypeId(const char *text)
00994 {
00995   static char static_text[2048];
00996   if (currentId == NULL)
00997     {
00998     currentId = static_text;
00999     strcpy(static_text, text);
01000     }
01001 }
01002 
01003 /* set the signature and type together */
01004 void typeSig(const char *text)
01005 {
01006   size_t n;
01007 
01008   postSig(text);
01009   postSig(" ");
01010 
01011   if (currentId == 0)
01012     {
01013     setTypeId(text);
01014     }
01015   else if ((currentId[0] == 'u' && strcmp(currentId, "unsigned") == 0) ||
01016            (currentId[0] == 's' && strcmp(currentId, "signed") == 0))
01017     {
01018     n = strlen(currentId);
01019     currentId[n] = ' ';
01020     strcpy(&currentId[n+1], text);
01021     }
01022 }
01023 
01024 /* return the current Id */
01025 const char *getTypeId()
01026 {
01027   return currentId;
01028 }
01029 
01030 /*----------------------------------------------------------------
01031  * Specifically for function pointers, the scope (i.e. class) that
01032  * the function is a method of.
01033  */
01034 
01035 const char *pointerScopeStack[10];
01036 int pointerScopeDepth = 0;
01037 
01038 /* save the scope for scoped method pointers */
01039 void scopeSig(const char *scope)
01040 {
01041   if (scope && scope[0] != '\0')
01042     {
01043     postSig(scope);
01044     }
01045   else
01046     {
01047     scope = NULL;
01048     }
01049   pointerScopeStack[pointerScopeDepth++] = vtkstrdup(scope);
01050 }
01051 
01052 /* get the scope back */
01053 const char *getScope()
01054 {
01055   return pointerScopeStack[--pointerScopeDepth];
01056 }
01057 
01058 /*----------------------------------------------------------------
01059  * Function stack
01060  *
01061  * operates on: currentFunction
01062  */
01063 
01064 /* "private" variables */
01065 FunctionInfo *functionStack[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
01066 const char *functionVarNameStack[10];
01067 const char *functionTypeIdStack[10];
01068 int functionDepth = 0;
01069 
01070 void pushFunction()
01071 {
01072   functionStack[functionDepth] = currentFunction;
01073   currentFunction = (FunctionInfo *)malloc(sizeof(FunctionInfo));
01074   vtkParse_InitFunction(currentFunction);
01075   if (!functionStack[functionDepth])
01076     {
01077     startSig();
01078     }
01079   functionVarNameStack[functionDepth] = vtkstrdup(getVarName());
01080   functionTypeIdStack[functionDepth] = vtkstrdup(getTypeId());
01081   clearVarName();
01082   clearTypeId();
01083   functionDepth++;
01084   functionStack[functionDepth] = 0;
01085 }
01086 
01087 void popFunction()
01088 {
01089   FunctionInfo *newFunction = currentFunction;
01090 
01091   --functionDepth;
01092   currentFunction = functionStack[functionDepth];
01093   clearVarName();
01094   if (functionVarNameStack[functionDepth])
01095     {
01096     setVarName(functionVarNameStack[functionDepth]);
01097     }
01098   clearTypeId();
01099   if (functionTypeIdStack[functionDepth])
01100     {
01101     setTypeId(functionTypeIdStack[functionDepth]);
01102     }
01103 
01104   functionStack[functionDepth+1] = newFunction;
01105 }
01106 
01107 FunctionInfo *getFunction()
01108 {
01109   return functionStack[functionDepth+1];
01110 }
01111 
01112 /*----------------------------------------------------------------
01113  * Utility methods
01114  */
01115 
01116 /* prepend a scope:: to a name */
01117 void prepend_scope(char *cp, const char *arg)
01118 {
01119   size_t i, j, m, n;
01120   int depth;
01121 
01122   m = strlen(cp);
01123   n = strlen(arg);
01124   i = m;
01125   while (i > 0 &&
01126          ((cp[i-1] >= 'a' && cp[i-1] <= 'z') ||
01127           (cp[i-1] >= 'A' && cp[i-1] <= 'Z') ||
01128           (cp[i-1] >= '0' && cp[i-1] <= '9') ||
01129           cp[i-1] == '_' || cp[i-1] == ':' ||
01130           cp[i-1] == '>'))
01131     {
01132     i--;
01133     if (cp[i] == '>')
01134       {
01135       depth = 1;
01136       while (i > 0)
01137         {
01138         i--;
01139         if (cp[i] == '<')
01140           {
01141           if (--depth == 0)
01142             {
01143             break;
01144             }
01145           }
01146         if (cp[i] == '>')
01147           {
01148           depth++;
01149           }
01150         }
01151       }
01152     }
01153 
01154   for (j = m; j > i; j--)
01155     {
01156     cp[j+n+1] = cp[j-1];
01157     }
01158   for (j = 0; j < n; j++)
01159     {
01160     cp[j+i] = arg[j];
01161     }
01162   cp[n+i] = ':'; cp[n+i+1] = ':';
01163   cp[m+n+2] = '\0';
01164 }
01165 
01166 /* expand a type by including pointers from another */
01167 unsigned int add_indirection(unsigned int type1, unsigned int type2)
01168 {
01169   unsigned int ptr1 = (type1 & VTK_PARSE_POINTER_MASK);
01170   unsigned int ptr2 = (type2 & VTK_PARSE_POINTER_MASK);
01171   unsigned int reverse = 0;
01172   unsigned int result;
01173 
01174   /* one of type1 or type2 will only have VTK_PARSE_INDIRECT, but
01175    * we don't know which one. */
01176   result = ((type1 & ~VTK_PARSE_POINTER_MASK) |
01177             (type2 & ~VTK_PARSE_POINTER_MASK));
01178 
01179   while (ptr2)
01180     {
01181     reverse = ((reverse << 2) | (ptr2 & VTK_PARSE_POINTER_LOWMASK));
01182     ptr2 = ((ptr2 >> 2) & VTK_PARSE_POINTER_MASK);
01183     }
01184 
01185   while (reverse)
01186     {
01187     ptr1 = ((ptr1 << 2) | (reverse & VTK_PARSE_POINTER_LOWMASK));
01188     reverse = ((reverse >> 2) & VTK_PARSE_POINTER_MASK);
01189 
01190     /* make sure we don't exceed the VTK_PARSE_POINTER bitfield */
01191     if ((ptr1 & VTK_PARSE_POINTER_MASK) != ptr1)
01192       {
01193       ptr1 = VTK_PARSE_BAD_INDIRECT;
01194       break;
01195       }
01196     }
01197 
01198   return (ptr1 | result);
01199 }
01200 
01201 /* There is only one array, so add any parenthetical indirection to it */
01202 unsigned int add_indirection_to_array(unsigned int type)
01203 {
01204   unsigned int ptrs = (type & VTK_PARSE_POINTER_MASK);
01205   unsigned int result = (type & ~VTK_PARSE_POINTER_MASK);
01206   unsigned int reverse = 0;
01207 
01208   if ((type & VTK_PARSE_INDIRECT) == VTK_PARSE_BAD_INDIRECT)
01209     {
01210     return (result | VTK_PARSE_BAD_INDIRECT);
01211     }
01212 
01213   while (ptrs)
01214     {
01215     reverse = ((reverse << 2) | (ptrs & VTK_PARSE_POINTER_LOWMASK));
01216     ptrs = ((ptrs >> 2) & VTK_PARSE_POINTER_MASK);
01217     }
01218 
01219   /* I know the reversal makes no difference, but it is still
01220    * nice to add the pointers in the correct order, just in
01221    * case const pointers are thrown into the mix. */
01222   while (reverse)
01223     {
01224     pushArrayFront("");
01225     reverse = ((reverse >> 2) & VTK_PARSE_POINTER_MASK);
01226     }
01227 
01228   return result;
01229 }
01230 
01231 
01232 
01233 /* Line 189 of yacc.c  */
01234 #line 1235 "vtkParse.tab.c"
01235 
01236 /* Enabling traces.  */
01237 #ifndef YYDEBUG
01238 # define YYDEBUG 0
01239 #endif
01240 
01241 /* Enabling verbose error messages.  */
01242 #ifdef YYERROR_VERBOSE
01243 # undef YYERROR_VERBOSE
01244 # define YYERROR_VERBOSE 1
01245 #else
01246 # define YYERROR_VERBOSE 0
01247 #endif
01248 
01249 /* Enabling the token table.  */
01250 #ifndef YYTOKEN_TABLE
01251 # define YYTOKEN_TABLE 0
01252 #endif
01253 
01254 
01255 /* Tokens.  */
01256 #ifndef YYTOKENTYPE
01257 # define YYTOKENTYPE
01258    /* Put the tokens into the symbol table, so that GDB and other debuggers
01259       know about them.  */
01260    enum yytokentype {
01261      STRUCT = 258,
01262      CLASS = 259,
01263      PUBLIC = 260,
01264      PRIVATE = 261,
01265      PROTECTED = 262,
01266      VIRTUAL = 263,
01267      ID = 264,
01268      STRING_LITERAL = 265,
01269      INT_LITERAL = 266,
01270      HEX_LITERAL = 267,
01271      OCT_LITERAL = 268,
01272      FLOAT_LITERAL = 269,
01273      CHAR_LITERAL = 270,
01274      ZERO = 271,
01275      FLOAT = 272,
01276      DOUBLE = 273,
01277      LONG_DOUBLE = 274,
01278      INT = 275,
01279      UNSIGNED_INT = 276,
01280      SHORT = 277,
01281      UNSIGNED_SHORT = 278,
01282      LONG = 279,
01283      UNSIGNED_LONG = 280,
01284      LONG_LONG = 281,
01285      UNSIGNED_LONG_LONG = 282,
01286      INT64__ = 283,
01287      UNSIGNED_INT64__ = 284,
01288      CHAR = 285,
01289      SIGNED_CHAR = 286,
01290      UNSIGNED_CHAR = 287,
01291      VOID = 288,
01292      BOOL = 289,
01293      SSIZE_T = 290,
01294      SIZE_T = 291,
01295      OSTREAM = 292,
01296      ISTREAM = 293,
01297      ENUM = 294,
01298      UNION = 295,
01299      CLASS_REF = 296,
01300      OTHER = 297,
01301      CONST = 298,
01302      CONST_PTR = 299,
01303      CONST_EQUAL = 300,
01304      OPERATOR = 301,
01305      UNSIGNED = 302,
01306      SIGNED = 303,
01307      FRIEND = 304,
01308      INLINE = 305,
01309      MUTABLE = 306,
01310      TEMPLATE = 307,
01311      TYPENAME = 308,
01312      TYPEDEF = 309,
01313      NAMESPACE = 310,
01314      USING = 311,
01315      VTK_ID = 312,
01316      STATIC = 313,
01317      EXTERN = 314,
01318      VAR_FUNCTION = 315,
01319      VTK_LEGACY = 316,
01320      NEW = 317,
01321      DELETE = 318,
01322      EXPLICIT = 319,
01323      STATIC_CAST = 320,
01324      DYNAMIC_CAST = 321,
01325      CONST_CAST = 322,
01326      REINTERPRET_CAST = 323,
01327      OP_LSHIFT_EQ = 324,
01328      OP_RSHIFT_EQ = 325,
01329      OP_LSHIFT = 326,
01330      OP_RSHIFT = 327,
01331      OP_ARROW_POINTER = 328,
01332      OP_ARROW = 329,
01333      OP_INCR = 330,
01334      OP_DECR = 331,
01335      OP_PLUS_EQ = 332,
01336      OP_MINUS_EQ = 333,
01337      OP_TIMES_EQ = 334,
01338      OP_DIVIDE_EQ = 335,
01339      OP_REMAINDER_EQ = 336,
01340      OP_AND_EQ = 337,
01341      OP_OR_EQ = 338,
01342      OP_XOR_EQ = 339,
01343      OP_LOGIC_AND_EQ = 340,
01344      OP_LOGIC_OR_EQ = 341,
01345      OP_LOGIC_AND = 342,
01346      OP_LOGIC_OR = 343,
01347      OP_LOGIC_EQ = 344,
01348      OP_LOGIC_NEQ = 345,
01349      OP_LOGIC_LEQ = 346,
01350      OP_LOGIC_GEQ = 347,
01351      ELLIPSIS = 348,
01352      DOUBLE_COLON = 349,
01353      LP = 350,
01354      LA = 351,
01355      QT_ID = 352,
01356      StdString = 353,
01357      UnicodeString = 354,
01358      IdType = 355,
01359      FloatType = 356,
01360      TypeInt8 = 357,
01361      TypeUInt8 = 358,
01362      TypeInt16 = 359,
01363      TypeUInt16 = 360,
01364      TypeInt32 = 361,
01365      TypeUInt32 = 362,
01366      TypeInt64 = 363,
01367      TypeUInt64 = 364,
01368      TypeFloat32 = 365,
01369      TypeFloat64 = 366,
01370      SetMacro = 367,
01371      GetMacro = 368,
01372      SetStringMacro = 369,
01373      GetStringMacro = 370,
01374      SetClampMacro = 371,
01375      SetObjectMacro = 372,
01376      GetObjectMacro = 373,
01377      BooleanMacro = 374,
01378      SetVector2Macro = 375,
01379      SetVector3Macro = 376,
01380      SetVector4Macro = 377,
01381      SetVector6Macro = 378,
01382      GetVector2Macro = 379,
01383      GetVector3Macro = 380,
01384      GetVector4Macro = 381,
01385      GetVector6Macro = 382,
01386      SetVectorMacro = 383,
01387      GetVectorMacro = 384,
01388      ViewportCoordinateMacro = 385,
01389      WorldCoordinateMacro = 386,
01390      TypeMacro = 387,
01391      VTK_BYTE_SWAP_DECL = 388
01392    };
01393 #endif
01394 
01395 
01396 
01397 
01398 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
01399 typedef union YYSTYPE
01400 {
01401 
01402 /* Line 214 of yacc.c  */
01403 #line 1182 "vtkParse.y"
01404 
01405   const char   *str;
01406   unsigned int  integer;
01407 
01408 
01409 
01410 /* Line 214 of yacc.c  */
01411 #line 1544 "vtkParse.tab.c"
01412 } YYSTYPE;
01413 # define YYSTYPE_IS_TRIVIAL 1
01414 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
01415 # define YYSTYPE_IS_DECLARED 1
01416 #endif
01417 
01418 
01419 /* Copy the second part of user declarations.  */
01420 
01421 
01422 /* Line 264 of yacc.c  */
01423 #line 1556 "vtkParse.tab.c"
01424 
01425 #ifdef short
01426 # undef short
01427 #endif
01428 
01429 #ifdef YYTYPE_UINT8
01430 typedef YYTYPE_UINT8 yytype_uint8;
01431 #else
01432 typedef unsigned char yytype_uint8;
01433 #endif
01434 
01435 #ifdef YYTYPE_INT8
01436 typedef YYTYPE_INT8 yytype_int8;
01437 #elif (defined __STDC__ || defined __C99__FUNC__ \
01438      || defined __cplusplus || defined _MSC_VER)
01439 typedef signed char yytype_int8;
01440 #else
01441 typedef short int yytype_int8;
01442 #endif
01443 
01444 #ifdef YYTYPE_UINT16
01445 typedef YYTYPE_UINT16 yytype_uint16;
01446 #else
01447 typedef unsigned short int yytype_uint16;
01448 #endif
01449 
01450 #ifdef YYTYPE_INT16
01451 typedef YYTYPE_INT16 yytype_int16;
01452 #else
01453 typedef short int yytype_int16;
01454 #endif
01455 
01456 #ifndef YYSIZE_T
01457 # ifdef __SIZE_TYPE__
01458 #  define YYSIZE_T __SIZE_TYPE__
01459 # elif defined size_t
01460 #  define YYSIZE_T size_t
01461 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
01462      || defined __cplusplus || defined _MSC_VER)
01463 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
01464 #  define YYSIZE_T size_t
01465 # else
01466 #  define YYSIZE_T unsigned int
01467 # endif
01468 #endif
01469 
01470 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
01471 
01472 #ifndef YY_
01473 # if YYENABLE_NLS
01474 #  if ENABLE_NLS
01475 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
01476 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
01477 #  endif
01478 # endif
01479 # ifndef YY_
01480 #  define YY_(msgid) msgid
01481 # endif
01482 #endif
01483 
01484 /* Suppress unused-variable warnings by "using" E.  */
01485 #if ! defined lint || defined __GNUC__
01486 # define YYUSE(e) ((void) (e))
01487 #else
01488 # define YYUSE(e) /* empty */
01489 #endif
01490 
01491 /* Identity function, used to suppress warnings about constant conditions.  */
01492 #ifndef lint
01493 # define YYID(n) (n)
01494 #else
01495 #if (defined __STDC__ || defined __C99__FUNC__ \
01496      || defined __cplusplus || defined _MSC_VER)
01497 static int
01498 YYID (int yyi)
01499 #else
01500 static int
01501 YYID (yyi)
01502     int yyi;
01503 #endif
01504 {
01505   return yyi;
01506 }
01507 #endif
01508 
01509 #if ! defined yyoverflow || YYERROR_VERBOSE
01510 
01511 /* The parser invokes alloca or malloc; define the necessary symbols.  */
01512 
01513 # ifdef YYSTACK_USE_ALLOCA
01514 #  if YYSTACK_USE_ALLOCA
01515 #   ifdef __GNUC__
01516 #    define YYSTACK_ALLOC __builtin_alloca
01517 #   elif defined __BUILTIN_VA_ARG_INCR
01518 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
01519 #   elif defined _AIX
01520 #    define YYSTACK_ALLOC __alloca
01521 #   elif defined _MSC_VER
01522 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
01523 #    define alloca _alloca
01524 #   else
01525 #    define YYSTACK_ALLOC alloca
01526 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
01527      || defined __cplusplus || defined _MSC_VER)
01528 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01529 #     ifndef _STDLIB_H
01530 #      define _STDLIB_H 1
01531 #     endif
01532 #    endif
01533 #   endif
01534 #  endif
01535 # endif
01536 
01537 # ifdef YYSTACK_ALLOC
01538    /* Pacify GCC's `empty if-body' warning.  */
01539 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
01540 #  ifndef YYSTACK_ALLOC_MAXIMUM
01541     /* The OS might guarantee only one guard page at the bottom of the stack,
01542        and a page size can be as small as 4096 bytes.  So we cannot safely
01543        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
01544        to allow for a few compiler-allocated temporary stack slots.  */
01545 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
01546 #  endif
01547 # else
01548 #  define YYSTACK_ALLOC YYMALLOC
01549 #  define YYSTACK_FREE YYFREE
01550 #  ifndef YYSTACK_ALLOC_MAXIMUM
01551 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
01552 #  endif
01553 #  if (defined __cplusplus && ! defined _STDLIB_H \
01554        && ! ((defined YYMALLOC || defined malloc) \
01555              && (defined YYFREE || defined free)))
01556 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
01557 #   ifndef _STDLIB_H
01558 #    define _STDLIB_H 1
01559 #   endif
01560 #  endif
01561 #  ifndef YYMALLOC
01562 #   define YYMALLOC malloc
01563 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
01564      || defined __cplusplus || defined _MSC_VER)
01565 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
01566 #   endif
01567 #  endif
01568 #  ifndef YYFREE
01569 #   define YYFREE free
01570 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
01571      || defined __cplusplus || defined _MSC_VER)
01572 void free (void *); /* INFRINGES ON USER NAME SPACE */
01573 #   endif
01574 #  endif
01575 # endif
01576 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
01577 
01578 
01579 #if (! defined yyoverflow \
01580      && (! defined __cplusplus \
01581          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
01582 
01583 /* A type that is properly aligned for any stack member.  */
01584 union yyalloc
01585 {
01586   yytype_int16 yyss_alloc;
01587   YYSTYPE yyvs_alloc;
01588 };
01589 
01590 /* The size of the maximum gap between one aligned stack and the next.  */
01591 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
01592 
01593 /* The size of an array large to enough to hold all stacks, each with
01594    N elements.  */
01595 # define YYSTACK_BYTES(N) \
01596      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
01597       + YYSTACK_GAP_MAXIMUM)
01598 
01599 /* Copy COUNT objects from FROM to TO.  The source and destination do
01600    not overlap.  */
01601 # ifndef YYCOPY
01602 #  if defined __GNUC__ && 1 < __GNUC__
01603 #   define YYCOPY(To, From, Count) \
01604       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
01605 #  else
01606 #   define YYCOPY(To, From, Count)                \
01607       do                                        \
01608         {                                        \
01609           YYSIZE_T yyi;                                \
01610           for (yyi = 0; yyi < (Count); yyi++)        \
01611             (To)[yyi] = (From)[yyi];                \
01612         }                                        \
01613       while (YYID (0))
01614 #  endif
01615 # endif
01616 
01617 /* Relocate STACK from its old location to the new one.  The
01618    local variables YYSIZE and YYSTACKSIZE give the old and new number of
01619    elements in the stack, and YYPTR gives the new location of the
01620    stack.  Advance YYPTR to a properly aligned location for the next
01621    stack.  */
01622 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                                \
01623     do                                                                        \
01624       {                                                                        \
01625         YYSIZE_T yynewbytes;                                                \
01626         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                        \
01627         Stack = &yyptr->Stack_alloc;                                        \
01628         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
01629         yyptr += yynewbytes / sizeof (*yyptr);                                \
01630       }                                                                        \
01631     while (YYID (0))
01632 
01633 #endif
01634 
01635 /* YYFINAL -- State number of the termination state.  */
01636 #define YYFINAL  2
01637 /* YYLAST -- Last index in YYTABLE.  */
01638 #define YYLAST   7055
01639 
01640 /* YYNTOKENS -- Number of terminals.  */
01641 #define YYNTOKENS  157
01642 /* YYNNTS -- Number of nonterminals.  */
01643 #define YYNNTS  196
01644 /* YYNRULES -- Number of rules.  */
01645 #define YYNRULES  581
01646 /* YYNRULES -- Number of states.  */
01647 #define YYNSTATES  1021
01648 
01649 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
01650 #define YYUNDEFTOK  2
01651 #define YYMAXUTOK   388
01652 
01653 #define YYTRANSLATE(YYX)                                                \
01654   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
01655 
01656 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
01657 static const yytype_uint8 yytranslate[] =
01658 {
01659        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01660        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01661        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01662        2,     2,     2,   155,     2,     2,     2,   149,   150,     2,
01663      135,   136,   147,   145,   142,   144,   156,   148,     2,     2,
01664        2,     2,     2,     2,     2,     2,     2,     2,   141,   134,
01665      139,   143,   140,     2,     2,     2,     2,     2,     2,     2,
01666        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01667        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01668        2,   153,     2,   154,   152,     2,     2,     2,     2,     2,
01669        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01670        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01671        2,     2,     2,   137,   151,   138,   146,     2,     2,     2,
01672        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01673        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01674        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01675        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01676        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01677        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01678        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01679        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01680        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01681        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01682        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01683        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
01684        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
01685        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
01686       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
01687       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
01688       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
01689       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
01690       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
01691       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
01692       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
01693       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
01694       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
01695      105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
01696      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
01697      125,   126,   127,   128,   129,   130,   131,   132,   133
01698 };
01699 
01700 #if YYDEBUG
01701 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
01702    YYRHS.  */
01703 static const yytype_uint16 yyprhs[] =
01704 {
01705        0,     0,     3,     4,     5,     9,    11,    15,    17,    19,
01706       21,    23,    27,    32,    34,    37,    41,    44,    47,    50,
01707       54,    57,    59,    62,    67,    72,    77,    79,    85,    86,
01708       93,    98,    99,   107,   108,   119,   120,   128,   129,   140,
01709      145,   146,   154,   155,   166,   171,   172,   173,   177,   181,
01710      183,   187,   189,   191,   195,   200,   203,   206,   208,   211,
01711      215,   219,   222,   226,   230,   233,   239,   241,   243,   244,
01712      247,   249,   253,   255,   258,   261,   264,   266,   268,   270,
01713      271,   278,   279,   285,   286,   288,   292,   294,   298,   300,
01714      302,   304,   306,   308,   310,   312,   314,   316,   318,   319,
01715      323,   324,   329,   330,   335,   337,   339,   341,   343,   345,
01716      347,   349,   351,   353,   355,   357,   359,   361,   364,   368,
01717      372,   375,   379,   382,   384,   390,   394,   399,   404,   409,
01718      413,   415,   420,   425,   429,   433,   434,   440,   442,   443,
01719      448,   451,   454,   455,   459,   461,   463,   464,   465,   469,
01720      474,   479,   482,   486,   491,   497,   501,   506,   513,   521,
01721      527,   534,   537,   541,   544,   548,   552,   554,   557,   560,
01722      563,   567,   569,   572,   575,   579,   583,   585,   588,   592,
01723      593,   594,   603,   604,   608,   609,   610,   618,   619,   623,
01724      624,   627,   630,   632,   634,   638,   639,   645,   646,   647,
01725      657,   658,   662,   663,   669,   670,   674,   675,   679,   684,
01726      686,   687,   693,   694,   695,   698,   700,   702,   703,   708,
01727      709,   710,   716,   718,   720,   723,   724,   726,   727,   731,
01728      736,   741,   745,   748,   749,   752,   753,   754,   759,   760,
01729      763,   764,   768,   771,   772,   778,   781,   782,   788,   790,
01730      792,   794,   796,   798,   799,   801,   802,   803,   809,   811,
01731      813,   816,   818,   821,   822,   824,   826,   827,   829,   830,
01732      833,   834,   840,   841,   843,   844,   846,   848,   850,   852,
01733      854,   856,   858,   860,   862,   864,   866,   868,   870,   872,
01734      874,   876,   878,   880,   882,   884,   886,   888,   890,   893,
01735      896,   900,   903,   906,   910,   912,   915,   917,   920,   922,
01736      925,   928,   930,   932,   934,   936,   937,   941,   942,   948,
01737      949,   955,   956,   962,   964,   965,   970,   972,   974,   976,
01738      978,   980,   982,   984,   986,   988,   990,   992,   996,  1000,
01739     1002,  1004,  1006,  1008,  1010,  1012,  1014,  1016,  1019,  1021,
01740     1023,  1026,  1028,  1030,  1032,  1035,  1038,  1041,  1044,  1046,
01741     1048,  1050,  1052,  1054,  1056,  1058,  1060,  1062,  1064,  1066,
01742     1068,  1070,  1072,  1074,  1076,  1078,  1080,  1082,  1084,  1086,
01743     1088,  1090,  1092,  1094,  1096,  1098,  1100,  1102,  1104,  1106,
01744     1108,  1110,  1112,  1114,  1116,  1118,  1120,  1122,  1124,  1126,
01745     1128,  1130,  1132,  1133,  1140,  1141,  1143,  1144,  1145,  1150,
01746     1152,  1153,  1157,  1158,  1162,  1164,  1165,  1170,  1171,  1172,
01747     1182,  1184,  1186,  1188,  1190,  1192,  1195,  1197,  1199,  1201,
01748     1203,  1205,  1207,  1209,  1210,  1218,  1219,  1220,  1221,  1231,
01749     1232,  1238,  1239,  1245,  1246,  1247,  1258,  1259,  1267,  1268,
01750     1269,  1270,  1280,  1287,  1288,  1296,  1297,  1305,  1306,  1314,
01751     1315,  1323,  1324,  1332,  1333,  1341,  1342,  1350,  1351,  1359,
01752     1360,  1370,  1371,  1381,  1386,  1391,  1399,  1402,  1405,  1409,
01753     1413,  1415,  1417,  1419,  1421,  1423,  1425,  1427,  1429,  1431,
01754     1433,  1435,  1437,  1439,  1441,  1443,  1445,  1447,  1449,  1451,
01755     1453,  1455,  1457,  1459,  1461,  1463,  1465,  1467,  1469,  1471,
01756     1473,  1475,  1477,  1479,  1481,  1483,  1485,  1487,  1489,  1491,
01757     1493,  1495,  1496,  1499,  1500,  1503,  1505,  1507,  1509,  1511,
01758     1513,  1515,  1517,  1519,  1521,  1523,  1525,  1527,  1529,  1531,
01759     1533,  1535,  1537,  1539,  1541,  1543,  1545,  1547,  1549,  1551,
01760     1553,  1555,  1557,  1559,  1561,  1563,  1565,  1567,  1569,  1571,
01761     1573,  1575,  1577,  1579,  1581,  1583,  1585,  1587,  1589,  1591,
01762     1593,  1595,  1597,  1599,  1601,  1603,  1605,  1607,  1611,  1615,
01763     1619,  1623
01764 };
01765 
01766 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
01767 static const yytype_int16 yyrhs[] =
01768 {
01769      158,     0,    -1,    -1,    -1,   158,   159,   160,    -1,   252,
01770       -1,   178,   254,   134,    -1,   196,    -1,   162,    -1,   161,
01771       -1,   194,    -1,   164,   254,   134,    -1,   197,   164,   254,
01772      134,    -1,    41,    -1,   214,   226,    -1,   197,   214,   226,
01773       -1,   213,   226,    -1,   208,   226,    -1,   209,   226,    -1,
01774      197,   208,   226,    -1,   206,   226,    -1,   321,    -1,   299,
01775      134,    -1,     9,   135,   346,   136,    -1,    57,   135,   346,
01776      136,    -1,    97,   135,   346,   136,    -1,   134,    -1,    59,
01777       10,   137,   158,   138,    -1,    -1,    55,   299,   163,   137,
01778      158,   138,    -1,    55,   137,   346,   138,    -1,    -1,     4,
01779      280,   165,   174,   137,   171,   138,    -1,    -1,     4,   280,
01780      139,   294,   140,   166,   174,   137,   171,   138,    -1,    -1,
01781        3,   280,   167,   174,   137,   171,   138,    -1,    -1,     3,
01782      280,   139,   294,   140,   168,   174,   137,   171,   138,    -1,
01783        3,   137,   346,   138,    -1,    -1,    40,   280,   169,   174,
01784      137,   171,   138,    -1,    -1,    40,   280,   139,   294,   140,
01785      170,   174,   137,   171,   138,    -1,    40,   137,   346,   138,
01786       -1,    -1,    -1,   171,   172,   173,    -1,   171,   177,   141,
01787       -1,   252,    -1,   178,   254,   134,    -1,   196,    -1,   194,
01788       -1,   164,   254,   134,    -1,   197,   164,   254,   134,    -1,
01789       49,   192,    -1,    49,   191,    -1,    41,    -1,   214,   226,
01790       -1,    49,   214,   226,    -1,   197,   214,   226,    -1,   211,
01791      226,    -1,    49,   211,   226,    -1,   197,   211,   226,    -1,
01792      207,   226,    -1,   133,   135,   346,   136,   134,    -1,   321,
01793       -1,   134,    -1,    -1,   141,   175,    -1,   176,    -1,   176,
01794      142,   175,    -1,   297,    -1,     6,   297,    -1,     7,   297,
01795       -1,     5,   297,    -1,     5,    -1,     6,    -1,     7,    -1,
01796       -1,    39,   280,   179,   137,   181,   138,    -1,    -1,    39,
01797      180,   137,   181,   138,    -1,    -1,   182,    -1,   182,   142,
01798      181,    -1,   280,    -1,   280,   143,   185,    -1,   184,    -1,
01799      280,    -1,   298,    -1,   290,    -1,    16,    -1,    11,    -1,
01800       13,    -1,    12,    -1,    15,    -1,   183,    -1,    -1,   189,
01801      186,   185,    -1,    -1,   183,   190,   187,   185,    -1,    -1,
01802      135,   188,   185,   136,    -1,   144,    -1,   145,    -1,   146,
01803       -1,   144,    -1,   145,    -1,   147,    -1,   148,    -1,   149,
01804       -1,   150,    -1,   151,    -1,   152,    -1,    71,    -1,    72,
01805       -1,   197,   192,    -1,     4,   280,   193,    -1,     3,   280,
01806      193,    -1,     3,   193,    -1,    40,   280,   193,    -1,    40,
01807      193,    -1,   134,    -1,   137,   346,   138,   347,   134,    -1,
01808      141,   347,   134,    -1,   195,   285,   262,   134,    -1,   195,
01809      164,   248,   134,    -1,   195,   178,   248,   134,    -1,   195,
01810       60,   134,    -1,    54,    -1,    56,    55,   297,   134,    -1,
01811       56,    53,   297,   134,    -1,    56,   297,   134,    -1,    52,
01812      139,   140,    -1,    -1,    52,   139,   198,   199,   140,    -1,
01813      201,    -1,    -1,   201,   142,   200,   199,    -1,   304,   204,
01814       -1,   203,   204,    -1,    -1,   202,   197,   204,    -1,     4,
01815       -1,    53,    -1,    -1,    -1,   280,   205,   249,    -1,    61,
01816      135,   208,   136,    -1,    61,   135,   211,   136,    -1,   283,
01817      223,    -1,   283,   210,   223,    -1,   299,    94,   146,   238,
01818       -1,    50,   299,    94,   146,   238,    -1,   299,    94,   231,
01819       -1,    50,   299,    94,   231,    -1,   299,    94,   299,    94,
01820      146,   238,    -1,    50,   299,    94,   299,    94,   146,   238,
01821       -1,   299,    94,   299,    94,   231,    -1,    50,   299,    94,
01822      299,    94,   231,    -1,   299,    94,    -1,   210,   299,    94,
01823       -1,   146,   238,    -1,    50,   146,   238,    -1,     8,   146,
01824      238,    -1,   231,    -1,    50,   231,    -1,   212,   231,    -1,
01825      283,   223,    -1,     8,   283,   223,    -1,    64,    -1,    50,
01826       64,    -1,    64,    50,    -1,   299,    94,   215,    -1,   283,
01827      210,   218,    -1,   215,    -1,   283,   218,    -1,     8,   285,
01828      218,    -1,    -1,    -1,    46,   283,   135,   216,   241,   136,
01829      217,   225,    -1,    -1,   220,   219,   225,    -1,    -1,    -1,
01830       46,   344,   221,   135,   222,   241,   136,    -1,    -1,   227,
01831      224,   225,    -1,    -1,   143,    16,    -1,    45,    16,    -1,
01832       43,    -1,   134,    -1,   137,   346,   138,    -1,    -1,   280,
01833      135,   228,   241,   136,    -1,    -1,    -1,   280,   139,   229,
01834      294,   140,   135,   230,   241,   136,    -1,    -1,   233,   232,
01835      235,    -1,    -1,   280,   135,   234,   241,   136,    -1,    -1,
01836      141,   237,   236,    -1,    -1,   142,   237,   236,    -1,   297,
01837      135,   346,   136,    -1,   239,    -1,    -1,   280,   135,   240,
01838      241,   136,    -1,    -1,    -1,   242,   243,    -1,    93,    -1,
01839      245,    -1,    -1,   245,   142,   244,   243,    -1,    -1,    -1,
01840      246,   285,   260,   247,   249,    -1,    60,    -1,   280,    -1,
01841      300,   280,    -1,    -1,   250,    -1,    -1,   143,   251,   307,
01842       -1,   283,   253,   255,   134,    -1,    58,    60,   255,   134,
01843       -1,    60,   255,   134,    -1,   262,   249,    -1,    -1,   257,
01844      255,    -1,    -1,    -1,   255,   142,   256,   257,    -1,    -1,
01845      258,   253,    -1,    -1,   300,   259,   253,    -1,   271,   273,
01846       -1,    -1,   264,   269,   136,   261,   267,    -1,   272,   273,
01847       -1,    -1,   265,   270,   136,   263,   267,    -1,   135,    -1,
01848       95,    -1,    96,    -1,    95,    -1,    96,    -1,    -1,    43,
01849       -1,    -1,    -1,   135,   268,   241,   136,   266,    -1,   274,
01850       -1,   260,    -1,   300,   260,    -1,   262,    -1,   300,   262,
01851       -1,    -1,   272,    -1,   280,    -1,    -1,   274,    -1,    -1,
01852      275,   276,    -1,    -1,   278,   153,   277,   279,   154,    -1,
01853       -1,   276,    -1,    -1,   185,    -1,    57,    -1,    97,    -1,
01854        9,    -1,    38,    -1,    37,    -1,    98,    -1,    99,    -1,
01855      281,    -1,   282,    -1,   102,    -1,   103,    -1,   104,    -1,
01856      105,    -1,   106,    -1,   107,    -1,   108,    -1,   109,    -1,
01857      110,    -1,   111,    -1,   100,    -1,   101,    -1,   285,    -1,
01858       51,   285,    -1,    59,   285,    -1,    59,    10,   285,    -1,
01859       50,   285,    -1,   284,   285,    -1,    50,   284,   285,    -1,
01860       58,    -1,    58,    50,    -1,   286,    -1,   286,   300,    -1,
01861      288,    -1,   287,   288,    -1,   288,   287,    -1,    43,    -1,
01862      303,    -1,   290,    -1,   298,    -1,    -1,    53,   289,   297,
01863       -1,    -1,    57,   139,   291,   294,   140,    -1,    -1,     9,
01864      139,   292,   294,   140,    -1,    -1,    97,   139,   293,   294,
01865      140,    -1,   296,    -1,    -1,   296,   142,   295,   294,    -1,
01866      285,    -1,   184,    -1,    57,    -1,     9,    -1,    97,    -1,
01867       38,    -1,    37,    -1,    98,    -1,    99,    -1,   290,    -1,
01868      298,    -1,   299,    94,   297,    -1,   290,    94,   297,    -1,
01869        9,    -1,    97,    -1,    57,    -1,    38,    -1,    37,    -1,
01870       98,    -1,    99,    -1,   150,    -1,   301,   150,    -1,   301,
01871       -1,   302,    -1,   301,   302,    -1,   147,    -1,    44,    -1,
01872      304,    -1,     4,   305,    -1,     3,   305,    -1,    40,   305,
01873       -1,    39,   305,    -1,   306,    -1,   305,    -1,    98,    -1,
01874       99,    -1,    37,    -1,    38,    -1,     9,    -1,    57,    -1,
01875       97,    -1,    33,    -1,    34,    -1,    35,    -1,    36,    -1,
01876      102,    -1,   103,    -1,   104,    -1,   105,    -1,   106,    -1,
01877      107,    -1,   108,    -1,   109,    -1,   110,    -1,   111,    -1,
01878      100,    -1,   101,    -1,    17,    -1,    18,    -1,    19,    -1,
01879       30,    -1,    31,    -1,    32,    -1,    20,    -1,    21,    -1,
01880       22,    -1,    23,    -1,    24,    -1,    25,    -1,    26,    -1,
01881       27,    -1,    28,    -1,    29,    -1,    48,    -1,    47,    -1,
01882      312,    -1,    -1,   137,   308,   307,   310,   309,   138,    -1,
01883       -1,   142,    -1,    -1,    -1,   310,   142,   311,   307,    -1,
01884      320,    -1,    -1,   145,   313,   320,    -1,    -1,   144,   314,
01885      320,    -1,   319,    -1,    -1,   135,   315,   312,   136,    -1,
01886       -1,    -1,   318,   139,   316,   286,   140,   135,   317,   312,
01887      136,    -1,    65,    -1,    67,    -1,    66,    -1,    68,    -1,
01888       10,    -1,   319,    10,    -1,    16,    -1,    11,    -1,    13,
01889       -1,    12,    -1,    14,    -1,    15,    -1,   297,    -1,    -1,
01890      112,   135,   280,   142,   322,   285,   136,    -1,    -1,    -1,
01891       -1,   113,   135,   323,   280,   142,   324,   285,   325,   136,
01892       -1,    -1,   114,   135,   326,   280,   136,    -1,    -1,   115,
01893      135,   327,   280,   136,    -1,    -1,    -1,   116,   135,   280,
01894      142,   328,   303,   329,   142,   347,   136,    -1,    -1,   117,
01895      135,   280,   142,   330,   303,   136,    -1,    -1,    -1,    -1,
01896      118,   135,   331,   280,   142,   332,   303,   333,   136,    -1,
01897      119,   135,   280,   142,   303,   136,    -1,    -1,   120,   135,
01898      280,   142,   334,   303,   136,    -1,    -1,   124,   135,   280,
01899      142,   335,   303,   136,    -1,    -1,   121,   135,   280,   142,
01900      336,   303,   136,    -1,    -1,   125,   135,   280,   142,   337,
01901      303,   136,    -1,    -1,   122,   135,   280,   142,   338,   303,
01902      136,    -1,    -1,   126,   135,   280,   142,   339,   303,   136,
01903       -1,    -1,   123,   135,   280,   142,   340,   303,   136,    -1,
01904       -1,   127,   135,   280,   142,   341,   303,   136,    -1,    -1,
01905      128,   135,   280,   142,   342,   303,   142,    11,   136,    -1,
01906       -1,   129,   135,   280,   142,   343,   303,   142,    11,   136,
01907       -1,   130,   135,   280,   136,    -1,   131,   135,   280,   136,
01908       -1,   132,   135,   280,   142,   280,   309,   136,    -1,   135,
01909      136,    -1,   153,   154,    -1,    62,   153,   154,    -1,    63,
01910      153,   154,    -1,   345,    -1,   143,    -1,   147,    -1,   148,
01911       -1,   144,    -1,   145,    -1,   155,    -1,   146,    -1,   142,
01912       -1,   139,    -1,   140,    -1,   150,    -1,   151,    -1,   152,
01913       -1,   149,    -1,    62,    -1,    63,    -1,    69,    -1,    70,
01914       -1,    71,    -1,    72,    -1,    73,    -1,    74,    -1,    77,
01915       -1,    78,    -1,    79,    -1,    80,    -1,    81,    -1,    75,
01916       -1,    76,    -1,    82,    -1,    83,    -1,    84,    -1,    85,
01917       -1,    86,    -1,    87,    -1,    88,    -1,    89,    -1,    90,
01918       -1,    91,    -1,    92,    -1,    -1,   346,   348,    -1,    -1,
01919      347,   349,    -1,   134,    -1,   349,    -1,    42,    -1,   350,
01920       -1,   352,    -1,   351,    -1,    54,    -1,   345,    -1,   141,
01921       -1,   156,    -1,    94,    -1,     4,    -1,    52,    -1,    38,
01922       -1,    37,    -1,    98,    -1,    99,    -1,   306,    -1,    13,
01923       -1,    11,    -1,    12,    -1,    14,    -1,    15,    -1,    10,
01924       -1,    41,    -1,    43,    -1,    44,    -1,    45,    -1,     3,
01925       -1,    46,    -1,    58,    -1,    50,    -1,     8,    -1,    39,
01926       -1,    40,    -1,    53,    -1,    16,    -1,    60,    -1,    93,
01927       -1,     5,    -1,     7,    -1,     6,    -1,    55,    -1,    56,
01928       -1,    59,    -1,     9,    -1,    57,    -1,    97,    -1,    67,
01929       -1,    66,    -1,    65,    -1,    68,    -1,   137,   346,   138,
01930       -1,   153,   346,   154,    -1,   135,   346,   136,    -1,    95,
01931      346,   136,    -1,    96,   346,   136,    -1
01932 };
01933 
01934 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
01935 static const yytype_uint16 yyrline[] =
01936 {
01937        0,  1332,  1332,  1333,  1332,  1337,  1338,  1339,  1340,  1341,
01938     1342,  1343,  1344,  1345,  1346,  1347,  1348,  1349,  1350,  1351,
01939     1352,  1353,  1354,  1355,  1356,  1357,  1358,  1364,  1370,  1370,
01940     1372,  1378,  1378,  1380,  1380,  1382,  1382,  1384,  1384,  1386,
01941     1387,  1387,  1389,  1389,  1391,  1393,  1395,  1394,  1397,  1400,
01942     1401,  1402,  1403,  1404,  1405,  1406,  1407,  1408,  1409,  1410,
01943     1412,  1413,  1414,  1416,  1417,  1418,  1419,  1420,  1422,  1422,
01944     1424,  1424,  1426,  1427,  1428,  1429,  1436,  1437,  1438,  1448,
01945     1448,  1450,  1450,  1453,  1453,  1453,  1455,  1456,  1458,  1459,
01946     1460,  1460,  1462,  1462,  1462,  1462,  1462,  1464,  1465,  1465,
01947     1469,  1469,  1473,  1473,  1478,  1478,  1479,  1481,  1481,  1482,
01948     1482,  1483,  1483,  1484,  1484,  1485,  1486,  1492,  1494,  1495,
01949     1496,  1497,  1498,  1500,  1501,  1502,  1508,  1531,  1532,  1533,
01950     1535,  1542,  1543,  1544,  1551,  1552,  1552,  1558,  1559,  1559,
01951     1562,  1572,  1580,  1580,  1592,  1593,  1595,  1595,  1595,  1602,
01952     1604,  1610,  1612,  1613,  1614,  1615,  1616,  1617,  1618,  1619,
01953     1620,  1622,  1623,  1625,  1626,  1627,  1632,  1633,  1634,  1641,
01954     1642,  1650,  1650,  1650,  1652,  1653,  1656,  1657,  1658,  1668,
01955     1672,  1667,  1684,  1684,  1693,  1694,  1693,  1701,  1701,  1710,
01956     1711,  1720,  1730,  1736,  1736,  1739,  1738,  1743,  1744,  1743,
01957     1751,  1751,  1758,  1758,  1760,  1760,  1762,  1762,  1764,  1766,
01958     1775,  1775,  1781,  1781,  1781,  1784,  1785,  1786,  1786,  1789,
01959     1791,  1789,  1820,  1844,  1844,  1846,  1846,  1848,  1848,  1855,
01960     1856,  1857,  1859,  1910,  1911,  1913,  1914,  1914,  1917,  1917,
01961     1918,  1918,  1922,  1923,  1923,  1937,  1938,  1938,  1951,  1952,
01962     1954,  1957,  1959,  1962,  1962,  1964,  1965,  1965,  1967,  1970,
01963     1971,  1975,  1976,  1979,  1979,  1981,  1983,  1983,  1985,  1985,
01964     1987,  1987,  1989,  1989,  1991,  1992,  1998,  1999,  2000,  2001,
01965     2002,  2003,  2004,  2005,  2006,  2009,  2010,  2011,  2012,  2013,
01966     2014,  2015,  2016,  2017,  2018,  2021,  2022,  2029,  2030,  2031,
01967     2032,  2034,  2035,  2037,  2041,  2042,  2044,  2045,  2047,  2048,
01968     2049,  2051,  2053,  2054,  2056,  2058,  2058,  2062,  2062,  2065,
01969     2065,  2068,  2068,  2072,  2073,  2073,  2076,  2076,  2078,  2079,
01970     2080,  2081,  2082,  2083,  2084,  2085,  2086,  2088,  2093,  2099,
01971     2099,  2099,  2099,  2099,  2100,  2100,  2116,  2117,  2118,  2123,
01972     2124,  2136,  2137,  2140,  2141,  2142,  2143,  2144,  2147,  2148,
01973     2151,  2152,  2153,  2154,  2155,  2156,  2157,  2160,  2161,  2162,
01974     2163,  2164,  2165,  2166,  2167,  2168,  2169,  2170,  2171,  2172,
01975     2173,  2174,  2175,  2176,  2177,  2178,  2179,  2180,  2181,  2183,
01976     2184,  2186,  2187,  2189,  2190,  2192,  2193,  2195,  2196,  2198,
01977     2199,  2205,  2206,  2206,  2212,  2212,  2214,  2215,  2215,  2220,
01978     2221,  2221,  2222,  2222,  2226,  2227,  2227,  2228,  2230,  2228,
01979     2250,  2251,  2252,  2253,  2255,  2256,  2259,  2260,  2261,  2262,
01980     2263,  2264,  2265,  2275,  2275,  2285,  2286,  2286,  2285,  2295,
01981     2295,  2305,  2305,  2314,  2314,  2314,  2347,  2346,  2357,  2358,
01982     2358,  2357,  2367,  2385,  2385,  2390,  2390,  2395,  2395,  2400,
01983     2400,  2405,  2405,  2410,  2410,  2415,  2415,  2420,  2420,  2425,
01984     2425,  2442,  2442,  2456,  2493,  2531,  2588,  2589,  2590,  2591,
01985     2592,  2594,  2595,  2595,  2596,  2596,  2597,  2597,  2598,  2598,
01986     2599,  2599,  2600,  2600,  2601,  2602,  2603,  2604,  2605,  2606,
01987     2607,  2608,  2609,  2610,  2611,  2612,  2613,  2614,  2615,  2616,
01988     2617,  2618,  2619,  2620,  2621,  2622,  2623,  2624,  2625,  2626,
01989     2627,  2633,  2633,  2634,  2634,  2636,  2636,  2638,  2638,  2638,
01990     2638,  2638,  2639,  2639,  2639,  2639,  2639,  2639,  2640,  2640,
01991     2640,  2640,  2640,  2641,  2641,  2641,  2641,  2641,  2642,  2642,
01992     2642,  2642,  2642,  2642,  2643,  2643,  2643,  2643,  2643,  2643,
01993     2643,  2644,  2644,  2644,  2644,  2644,  2644,  2645,  2645,  2645,
01994     2645,  2645,  2645,  2646,  2646,  2646,  2646,  2648,  2649,  2650,
01995     2650,  2650
01996 };
01997 #endif
01998 
01999 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
02000 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
02001    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
02002 static const char *const yytname[] =
02003 {
02004   "$end", "error", "$undefined", "STRUCT", "CLASS", "PUBLIC", "PRIVATE",
02005   "PROTECTED", "VIRTUAL", "ID", "STRING_LITERAL", "INT_LITERAL",
02006   "HEX_LITERAL", "OCT_LITERAL", "FLOAT_LITERAL", "CHAR_LITERAL", "ZERO",
02007   "FLOAT", "DOUBLE", "LONG_DOUBLE", "INT", "UNSIGNED_INT", "SHORT",
02008   "UNSIGNED_SHORT", "LONG", "UNSIGNED_LONG", "LONG_LONG",
02009   "UNSIGNED_LONG_LONG", "INT64__", "UNSIGNED_INT64__", "CHAR",
02010   "SIGNED_CHAR", "UNSIGNED_CHAR", "VOID", "BOOL", "SSIZE_T", "SIZE_T",
02011   "OSTREAM", "ISTREAM", "ENUM", "UNION", "CLASS_REF", "OTHER", "CONST",
02012   "CONST_PTR", "CONST_EQUAL", "OPERATOR", "UNSIGNED", "SIGNED", "FRIEND",
02013   "INLINE", "MUTABLE", "TEMPLATE", "TYPENAME", "TYPEDEF", "NAMESPACE",
02014   "USING", "VTK_ID", "STATIC", "EXTERN", "VAR_FUNCTION", "VTK_LEGACY",
02015   "NEW", "DELETE", "EXPLICIT", "STATIC_CAST", "DYNAMIC_CAST", "CONST_CAST",
02016   "REINTERPRET_CAST", "OP_LSHIFT_EQ", "OP_RSHIFT_EQ", "OP_LSHIFT",
02017   "OP_RSHIFT", "OP_ARROW_POINTER", "OP_ARROW", "OP_INCR", "OP_DECR",
02018   "OP_PLUS_EQ", "OP_MINUS_EQ", "OP_TIMES_EQ", "OP_DIVIDE_EQ",
02019   "OP_REMAINDER_EQ", "OP_AND_EQ", "OP_OR_EQ", "OP_XOR_EQ",
02020   "OP_LOGIC_AND_EQ", "OP_LOGIC_OR_EQ", "OP_LOGIC_AND", "OP_LOGIC_OR",
02021   "OP_LOGIC_EQ", "OP_LOGIC_NEQ", "OP_LOGIC_LEQ", "OP_LOGIC_GEQ",
02022   "ELLIPSIS", "DOUBLE_COLON", "LP", "LA", "QT_ID", "StdString",
02023   "UnicodeString", "IdType", "FloatType", "TypeInt8", "TypeUInt8",
02024   "TypeInt16", "TypeUInt16", "TypeInt32", "TypeUInt32", "TypeInt64",
02025   "TypeUInt64", "TypeFloat32", "TypeFloat64", "SetMacro", "GetMacro",
02026   "SetStringMacro", "GetStringMacro", "SetClampMacro", "SetObjectMacro",
02027   "GetObjectMacro", "BooleanMacro", "SetVector2Macro", "SetVector3Macro",
02028   "SetVector4Macro", "SetVector6Macro", "GetVector2Macro",
02029   "GetVector3Macro", "GetVector4Macro", "GetVector6Macro",
02030   "SetVectorMacro", "GetVectorMacro", "ViewportCoordinateMacro",
02031   "WorldCoordinateMacro", "TypeMacro", "VTK_BYTE_SWAP_DECL", "';'", "'('",
02032   "')'", "'{'", "'}'", "'<'", "'>'", "':'", "','", "'='", "'-'", "'+'",
02033   "'~'", "'*'", "'/'", "'%'", "'&'", "'|'", "'^'", "'['", "']'", "'!'",
02034   "'.'", "$accept", "strt", "$@1", "file_item", "extern", "namespace",
02035   "$@2", "class_def", "$@3", "$@4", "$@5", "$@6", "$@7", "$@8",
02036   "class_def_body", "$@9", "class_def_item", "optional_scope",
02037   "scope_list", "scope_list_item", "scope_type", "enum_def", "$@10",
02038   "$@11", "enum_list", "enum_item", "integer_value", "integer_literal",
02039   "integer_expression", "$@12", "$@13", "$@14", "math_unary_op",
02040   "math_binary_op", "template_internal_class", "internal_class",
02041   "internal_class_body", "type_def", "typedef_start", "using", "template",
02042   "$@15", "template_args", "$@16", "template_arg", "$@17",
02043   "class_or_typename", "maybe_template_id", "$@18", "legacy_function",
02044   "legacy_method", "function", "scoped_method", "scope", "method",
02045   "explicit_mod", "scoped_operator", "operator", "typecast_op_func",
02046   "$@19", "$@20", "op_func", "$@21", "op_sig", "$@22", "$@23", "func",
02047   "$@24", "func_trailer", "func_body", "func_sig", "$@25", "$@26", "@27",
02048   "constructor", "$@28", "constructor_sig", "$@29", "maybe_initializers",
02049   "more_initializers", "initializer", "destructor", "destructor_sig",
02050   "$@30", "args_list", "$@31", "more_args", "$@32", "arg", "$@33", "$@34",
02051   "maybe_indirect_id", "maybe_var_assign", "var_assign", "$@35", "var",
02052   "var_id_maybe_assign", "maybe_vars", "maybe_other_vars", "$@36",
02053   "other_var", "$@37", "$@38", "maybe_complex_var_id", "$@39",
02054   "complex_var_id", "$@40", "p_or_lp_or_la", "lp_or_la",
02055   "maybe_func_const", "maybe_array_or_args", "$@41",
02056   "maybe_indirect_maybe_var_id", "maybe_indirect_var_id", "maybe_var_id",
02057   "var_id", "maybe_var_array", "var_array", "$@42", "array", "$@43",
02058   "more_array", "array_size", "any_id", "sized_type_id", "special_type_id",
02059   "storage_type", "static_mod", "type", "type_red", "const_mod",
02060   "type_red1", "$@44", "templated_id", "$@45", "$@46", "$@47",
02061   "template_params", "$@48", "template_param", "maybe_scoped_id",
02062   "scoped_id", "class_id", "type_indirection", "pointers",
02063   "pointer_or_const_pointer", "type_red2", "type_simple", "type_id",
02064   "type_primitive", "value", "$@49", "maybe_comma", "more_values", "$@50",
02065   "literal", "$@51", "$@52", "$@53", "$@54", "$@55", "any_cast",
02066   "string_literal", "literal2", "macro", "$@56", "$@57", "$@58", "$@59",
02067   "$@60", "$@61", "$@62", "$@63", "$@64", "$@65", "$@66", "$@67", "$@68",
02068   "$@69", "$@70", "$@71", "$@72", "$@73", "$@74", "$@75", "$@76", "$@77",
02069   "op_token", "op_token_no_delim", "maybe_other", "maybe_other_no_semi",
02070   "other_stuff", "other_stuff_no_semi", "braces", "brackets", "parens", 0
02071 };
02072 #endif
02073 
02074 # ifdef YYPRINT
02075 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
02076    token YYLEX-NUM.  */
02077 static const yytype_uint16 yytoknum[] =
02078 {
02079        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
02080      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
02081      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
02082      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
02083      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
02084      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
02085      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
02086      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
02087      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
02088      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
02089      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
02090      365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
02091      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
02092      385,   386,   387,   388,    59,    40,    41,   123,   125,    60,
02093       62,    58,    44,    61,    45,    43,   126,    42,    47,    37,
02094       38,   124,    94,    91,    93,    33,    46
02095 };
02096 # endif
02097 
02098 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
02099 static const yytype_uint16 yyr1[] =
02100 {
02101        0,   157,   158,   159,   158,   160,   160,   160,   160,   160,
02102      160,   160,   160,   160,   160,   160,   160,   160,   160,   160,
02103      160,   160,   160,   160,   160,   160,   160,   161,   163,   162,
02104      162,   165,   164,   166,   164,   167,   164,   168,   164,   164,
02105      169,   164,   170,   164,   164,   171,   172,   171,   171,   173,
02106      173,   173,   173,   173,   173,   173,   173,   173,   173,   173,
02107      173,   173,   173,   173,   173,   173,   173,   173,   174,   174,
02108      175,   175,   176,   176,   176,   176,   177,   177,   177,   179,
02109      178,   180,   178,   181,   181,   181,   182,   182,   183,   183,
02110      183,   183,   184,   184,   184,   184,   184,   185,   186,   185,
02111      187,   185,   188,   185,   189,   189,   189,   190,   190,   190,
02112      190,   190,   190,   190,   190,   190,   190,   191,   192,   192,
02113      192,   192,   192,   193,   193,   193,   194,   194,   194,   194,
02114      195,   196,   196,   196,   197,   198,   197,   199,   200,   199,
02115      201,   201,   202,   201,   203,   203,   204,   205,   204,   206,
02116      207,   208,   209,   209,   209,   209,   209,   209,   209,   209,
02117      209,   210,   210,   211,   211,   211,   211,   211,   211,   211,
02118      211,   212,   212,   212,   213,   213,   214,   214,   214,   216,
02119      217,   215,   219,   218,   221,   222,   220,   224,   223,   225,
02120      225,   225,   225,   226,   226,   228,   227,   229,   230,   227,
02121      232,   231,   234,   233,   235,   235,   236,   236,   237,   238,
02122      240,   239,   241,   242,   241,   243,   243,   244,   243,   246,
02123      247,   245,   245,   248,   248,   249,   249,   251,   250,   252,
02124      252,   252,   253,   254,   254,   255,   256,   255,   258,   257,
02125      259,   257,   260,   261,   260,   262,   263,   262,   264,   264,
02126      264,   265,   265,   266,   266,   267,   268,   267,   267,   269,
02127      269,   270,   270,   271,   271,   272,   273,   273,   275,   274,
02128      277,   276,   278,   278,   279,   279,   280,   280,   280,   280,
02129      280,   280,   280,   280,   280,   281,   281,   281,   281,   281,
02130      281,   281,   281,   281,   281,   282,   282,   283,   283,   283,
02131      283,   283,   283,   283,   284,   284,   285,   285,   286,   286,
02132      286,   287,   288,   288,   288,   289,   288,   291,   290,   292,
02133      290,   293,   290,   294,   295,   294,   296,   296,   297,   297,
02134      297,   297,   297,   297,   297,   297,   297,   298,   298,   299,
02135      299,   299,   299,   299,   299,   299,   300,   300,   300,   301,
02136      301,   302,   302,   303,   303,   303,   303,   303,   304,   304,
02137      305,   305,   305,   305,   305,   305,   305,   306,   306,   306,
02138      306,   306,   306,   306,   306,   306,   306,   306,   306,   306,
02139      306,   306,   306,   306,   306,   306,   306,   306,   306,   306,
02140      306,   306,   306,   306,   306,   306,   306,   306,   306,   306,
02141      306,   307,   308,   307,   309,   309,   310,   311,   310,   312,
02142      313,   312,   314,   312,   312,   315,   312,   316,   317,   312,
02143      318,   318,   318,   318,   319,   319,   320,   320,   320,   320,
02144      320,   320,   320,   322,   321,   323,   324,   325,   321,   326,
02145      321,   327,   321,   328,   329,   321,   330,   321,   331,   332,
02146      333,   321,   321,   334,   321,   335,   321,   336,   321,   337,
02147      321,   338,   321,   339,   321,   340,   321,   341,   321,   342,
02148      321,   343,   321,   321,   321,   321,   344,   344,   344,   344,
02149      344,   345,   345,   345,   345,   345,   345,   345,   345,   345,
02150      345,   345,   345,   345,   345,   345,   345,   345,   345,   345,
02151      345,   345,   345,   345,   345,   345,   345,   345,   345,   345,
02152      345,   345,   345,   345,   345,   345,   345,   345,   345,   345,
02153      345,   346,   346,   347,   347,   348,   348,   349,   349,   349,
02154      349,   349,   349,   349,   349,   349,   349,   349,   349,   349,
02155      349,   349,   349,   349,   349,   349,   349,   349,   349,   349,
02156      349,   349,   349,   349,   349,   349,   349,   349,   349,   349,
02157      349,   349,   349,   349,   349,   349,   349,   349,   349,   349,
02158      349,   349,   349,   349,   349,   349,   349,   350,   351,   352,
02159      352,   352
02160 };
02161 
02162 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
02163 static const yytype_uint8 yyr2[] =
02164 {
02165        0,     2,     0,     0,     3,     1,     3,     1,     1,     1,
02166        1,     3,     4,     1,     2,     3,     2,     2,     2,     3,
02167        2,     1,     2,     4,     4,     4,     1,     5,     0,     6,
02168        4,     0,     7,     0,    10,     0,     7,     0,    10,     4,
02169        0,     7,     0,    10,     4,     0,     0,     3,     3,     1,
02170        3,     1,     1,     3,     4,     2,     2,     1,     2,     3,
02171        3,     2,     3,     3,     2,     5,     1,     1,     0,     2,
02172        1,     3,     1,     2,     2,     2,     1,     1,     1,     0,
02173        6,     0,     5,     0,     1,     3,     1,     3,     1,     1,
02174        1,     1,     1,     1,     1,     1,     1,     1,     0,     3,
02175        0,     4,     0,     4,     1,     1,     1,     1,     1,     1,
02176        1,     1,     1,     1,     1,     1,     1,     2,     3,     3,
02177        2,     3,     2,     1,     5,     3,     4,     4,     4,     3,
02178        1,     4,     4,     3,     3,     0,     5,     1,     0,     4,
02179        2,     2,     0,     3,     1,     1,     0,     0,     3,     4,
02180        4,     2,     3,     4,     5,     3,     4,     6,     7,     5,
02181        6,     2,     3,     2,     3,     3,     1,     2,     2,     2,
02182        3,     1,     2,     2,     3,     3,     1,     2,     3,     0,
02183        0,     8,     0,     3,     0,     0,     7,     0,     3,     0,
02184        2,     2,     1,     1,     3,     0,     5,     0,     0,     9,
02185        0,     3,     0,     5,     0,     3,     0,     3,     4,     1,
02186        0,     5,     0,     0,     2,     1,     1,     0,     4,     0,
02187        0,     5,     1,     1,     2,     0,     1,     0,     3,     4,
02188        4,     3,     2,     0,     2,     0,     0,     4,     0,     2,
02189        0,     3,     2,     0,     5,     2,     0,     5,     1,     1,
02190        1,     1,     1,     0,     1,     0,     0,     5,     1,     1,
02191        2,     1,     2,     0,     1,     1,     0,     1,     0,     2,
02192        0,     5,     0,     1,     0,     1,     1,     1,     1,     1,
02193        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02194        1,     1,     1,     1,     1,     1,     1,     1,     2,     2,
02195        3,     2,     2,     3,     1,     2,     1,     2,     1,     2,
02196        2,     1,     1,     1,     1,     0,     3,     0,     5,     0,
02197        5,     0,     5,     1,     0,     4,     1,     1,     1,     1,
02198        1,     1,     1,     1,     1,     1,     1,     3,     3,     1,
02199        1,     1,     1,     1,     1,     1,     1,     2,     1,     1,
02200        2,     1,     1,     1,     2,     2,     2,     2,     1,     1,
02201        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02202        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02203        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02204        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02205        1,     1,     0,     6,     0,     1,     0,     0,     4,     1,
02206        0,     3,     0,     3,     1,     0,     4,     0,     0,     9,
02207        1,     1,     1,     1,     1,     2,     1,     1,     1,     1,
02208        1,     1,     1,     0,     7,     0,     0,     0,     9,     0,
02209        5,     0,     5,     0,     0,    10,     0,     7,     0,     0,
02210        0,     9,     6,     0,     7,     0,     7,     0,     7,     0,
02211        7,     0,     7,     0,     7,     0,     7,     0,     7,     0,
02212        9,     0,     9,     4,     4,     7,     2,     2,     3,     3,
02213        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02214        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02215        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02216        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02217        1,     0,     2,     0,     2,     1,     1,     1,     1,     1,
02218        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02219        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02220        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02221        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
02222        1,     1,     1,     1,     1,     1,     1,     3,     3,     3,
02223        3,     3
02224 };
02225 
02226 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
02227    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
02228    means the default is an error.  */
02229 static const yytype_uint16 yydefact[] =
02230 {
02231        2,     3,     1,     0,     0,     0,     0,   364,   383,   384,
02232      385,   389,   390,   391,   392,   393,   394,   395,   396,   397,
02233      398,   386,   387,   388,   367,   368,   369,   370,   362,   363,
02234       81,     0,    13,   311,     0,   400,   399,     0,     0,     0,
02235      315,   130,     0,     0,   365,   304,     0,   235,     0,   366,
02236      360,   361,   381,   382,   371,   372,   373,   374,   375,   376,
02237      377,   378,   379,   380,     0,     0,     0,     0,     0,     0,
02238        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02239        0,     0,     0,     0,     0,    26,     4,     9,     8,   238,
02240      238,    10,     0,     7,     0,     0,     0,     0,     0,     0,
02241      176,     5,     0,     0,   297,   306,     0,   308,   313,   314,
02242        0,   312,   353,   359,   358,    21,   364,   362,   363,   365,
02243      366,   360,   361,   295,   296,   285,   286,   287,   288,   289,
02244      290,   291,   292,   293,   294,   521,    35,   283,   284,   355,
02245       31,   354,     0,     0,   364,     0,     0,   365,   366,     0,
02246        0,   521,   319,     0,    79,   357,   521,    40,   356,     0,
02247      304,     0,     0,     0,   301,     0,   298,   135,     0,   339,
02248      343,   342,   341,   340,   344,   345,   521,    28,   329,   332,
02249      331,     0,     0,   328,   330,   333,   334,   335,     0,   336,
02250      521,   317,   305,   235,     0,   299,     0,     0,   521,   321,
02251        0,   435,   439,   441,     0,     0,   448,     0,     0,     0,
02252        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02253        0,   352,   351,   346,     0,   235,     0,   240,   348,   349,
02254        0,     0,     0,     0,     0,   238,     0,     0,     0,   193,
02255      521,    20,    17,    18,    16,    14,   278,   280,   279,     0,
02256      276,   251,   252,   277,   281,   282,     0,   177,   182,   151,
02257      187,   235,   225,     0,   266,   265,     0,   302,   307,   309,
02258      310,     0,     0,    22,     0,     0,    68,     0,    68,   364,
02259      362,   363,   365,   366,   360,   361,   178,     0,     0,     0,
02260       83,     0,     0,     0,    68,     0,   179,   303,     0,   134,
02261      142,   316,     0,     0,     0,     0,   133,     0,     0,     0,
02262        2,   300,   231,   236,     0,     0,     0,     0,   278,   280,
02263      279,   276,   277,   281,   282,     0,     0,     0,     0,     0,
02264        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02265        0,     0,     0,     0,     0,     0,    11,   234,   239,   265,
02266        0,   347,   350,     6,   129,     0,   223,     0,     0,     0,
02267        0,    19,    15,     0,     0,   495,   496,   497,   498,   499,
02268      500,   501,   502,   508,   509,   503,   504,   505,   506,   507,
02269      510,   511,   512,   513,   514,   515,   516,   517,   518,   519,
02270      520,     0,   489,   490,   488,   481,   484,   485,   487,   482,
02271      483,   494,   491,   492,   493,     0,   486,   184,   480,   175,
02272      152,     0,   189,   189,     0,   227,   232,   226,   261,     0,
02273        0,   245,   267,   272,   195,   197,   161,   338,   329,   332,
02274      331,   328,   330,   333,   334,     0,   174,   155,   200,     0,
02275      337,     0,   553,   536,   564,   566,   565,   557,   570,   548,
02276      544,   545,   543,   546,   547,   561,   539,   538,   558,   559,
02277      549,   527,   550,   551,   552,   554,   556,   537,   560,   531,
02278      567,   568,   571,   555,   569,   562,   495,   496,   575,   574,
02279      573,   576,   563,   535,   521,   521,   572,   540,   541,   525,
02280      521,   521,    39,   533,   521,   534,   542,   532,   522,   526,
02281      528,   530,   529,    93,    95,    94,    96,    92,   327,   326,
02282        0,   323,     0,     0,     0,     0,    23,     0,     0,    84,
02283       86,    83,    44,     0,     0,   213,     0,   156,     0,   144,
02284      145,     0,   137,     0,   146,   146,    30,     2,   132,   131,
02285       24,     0,   230,     3,   238,   149,    25,     0,   433,     0,
02286        0,     0,   443,   446,     0,     0,   453,   457,   461,   465,
02287      455,   459,   463,   467,   469,   471,   473,   474,     0,   241,
02288      127,   224,   128,   126,    12,   194,     0,     0,   476,   477,
02289        0,   162,   192,     0,     0,   183,   188,   229,     0,   246,
02290      262,   269,     0,   213,     0,   153,   209,     0,   204,   202,
02291        0,     0,     0,     0,     0,     0,    37,   324,     0,     0,
02292        0,    69,    70,    72,    45,    33,    45,   320,    82,    83,
02293        0,     0,    42,    45,     0,   219,   154,     0,   136,   138,
02294      146,   141,   147,   140,     3,   318,    27,   237,   322,     0,
02295      436,   440,   442,     0,     0,   449,     0,     0,     0,     0,
02296        0,     0,     0,     0,     0,     0,     0,   404,   478,   479,
02297      185,   191,   190,   424,   427,   429,   428,   430,   431,   426,
02298      420,   422,   421,   423,   415,   402,   412,   410,   432,   228,
02299      401,     0,   414,   409,   255,   270,     0,     0,   210,     0,
02300      201,   213,     0,   159,   580,   581,   579,   577,   578,    68,
02301        0,    75,    73,    74,     0,    46,    68,    46,    85,   278,
02302      276,   277,   102,   104,   105,   106,    97,    88,    87,    98,
02303       89,    91,    90,    80,    68,    46,   180,   222,   215,   214,
02304      216,     0,     0,   160,   142,   143,   225,    29,     0,     0,
02305      444,     0,     0,   452,     0,     0,     0,     0,     0,     0,
02306        0,     0,     0,     0,   405,     0,   213,     0,     0,     0,
02307        0,   417,   425,   256,   247,   258,   274,   196,     0,   213,
02308      206,     0,     0,   157,     0,   325,    71,    76,    77,    78,
02309       36,     0,     0,     0,    32,     0,   115,   116,   107,   108,
02310      109,   110,   111,   112,   113,   114,   100,     0,     0,    41,
02311      189,   217,   263,   158,   139,   148,   434,   437,     0,   447,
02312      450,   454,   458,   462,   466,   456,   460,   464,   468,     0,
02313        0,   475,     0,     0,   406,   413,   411,     0,   213,   275,
02314        0,   198,     0,     0,   205,   521,   203,    45,     0,   364,
02315      362,   363,    57,     0,     0,   365,     0,   171,   366,   360,
02316      361,   381,   382,   371,   372,   373,   374,   375,   376,   377,
02317      378,   379,   380,     0,    67,     0,   238,    47,   238,    52,
02318       51,     0,     0,     0,     0,     0,   166,    49,     0,    66,
02319       48,    45,     0,     0,    99,    45,   181,   219,   249,   250,
02320      248,   220,   263,   266,   264,     0,   523,     0,     0,     0,
02321      186,   416,   404,     0,     0,   271,   213,   211,   206,     0,
02322       46,     0,     0,   297,     0,     0,     0,    56,    55,     0,
02323        0,     0,     0,   172,     0,   167,     0,   173,   521,   163,
02324        0,     0,   238,     0,     0,    64,    61,   168,    58,   169,
02325       46,   103,   101,    46,   218,   225,   259,     0,   263,   242,
02326      438,     0,   451,   470,   472,   407,     0,     0,   253,     0,
02327      207,   208,    38,   165,   170,   123,   521,   523,   120,     0,
02328        0,   122,     0,     0,     0,     0,   117,    62,    59,   164,
02329        0,     0,     0,     0,    53,    50,     0,    63,    60,    34,
02330       43,   221,   243,   260,   445,   524,     0,   403,   418,   254,
02331      257,   199,     0,     0,   119,   118,   121,   150,     0,    54,
02332      255,   408,     0,   523,   125,    65,   244,     0,     0,   419,
02333      124
02334 };
02335 
02336 /* YYDEFGOTO[NTERM-NUM].  */
02337 static const yytype_int16 yydefgoto[] =
02338 {
02339       -1,     1,     3,    86,    87,    88,   303,    89,   278,   706,
02340      276,   699,   294,   724,   705,   781,   867,   513,   611,   612,
02341      782,    90,   291,   153,   518,   519,   716,   508,   718,   797,
02342      883,   785,   719,   796,   917,   918,   968,    91,    92,    93,
02343       94,   300,   531,   734,   532,   533,   534,   631,   736,    95,
02344      872,    96,    97,   256,   873,   874,    98,    99,   100,   525,
02345      800,   257,   412,   258,   580,   756,   259,   413,   585,   241,
02346      260,   593,   594,   906,   876,   598,   438,   691,   690,   834,
02347      770,   595,   596,   769,   624,   625,   729,   887,   730,   731,
02348      945,   355,   416,   417,   588,   101,   261,   224,   196,   544,
02349      225,   226,   350,   891,  1010,   262,   684,   892,   263,  1000,
02350      764,   828,   947,   419,   893,   264,   421,   422,   423,   591,
02351      766,   592,   830,   439,   137,   138,   912,   103,   104,   105,
02352      106,   107,   168,   108,   308,   289,   317,   510,   700,   511,
02353      678,   109,   150,   227,   228,   229,   111,   112,   113,   114,
02354      679,   758,   755,   902,   996,   680,   760,   759,   757,   827,
02355     1012,   681,   682,   683,   115,   639,   326,   739,   895,   327,
02356      328,   643,   808,   644,   331,   742,   897,   647,   651,   648,
02357      652,   649,   653,   650,   654,   655,   656,   407,   497,   274,
02358      951,   498,   499,   500,   501,   502
02359 };
02360 
02361 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
02362    STATE-NUM.  */
02363 #define YYPACT_NINF -917
02364 static const yytype_int16 yypact[] =
02365 {
02366     -917,    52,  -917,  5135,  5259,  6825,  6259,    51,  -917,  -917,
02367     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02368     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,   -14,    98,
02369     6825,  5274,  -917,  -917,  5714,  -917,  -917,  5823,  6259,   -63,
02370     -917,  -917,    81,   264,   170,    55,  5932,  -917,   -44,   181,
02371      108,   132,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02372     -917,  -917,  -917,  -917,    38,    49,    53,    54,    64,    86,
02373      113,   122,   156,   158,   171,   172,   196,   198,   201,   209,
02374      215,   216,   219,   220,   224,  -917,  -917,  -917,  -917,    10,
02375       10,  -917,  6041,  -917,  5496,   134,   134,   134,   134,   134,
02376     -917,  -917,  6615,  6259,  -917,    15,  6368,   151,   188,  -917,
02377      147,  -917,  -917,  -917,  -917,  -917,   191,   206,   272,   387,
02378      395,   412,   413,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02379     -917,  -917,  -917,  -917,  -917,  -917,    36,  -917,  -917,  -917,
02380      229,  -917,   343,   343,   -22,   343,   343,     0,    22,   289,
02381      282,  -917,  -917,   240,  -917,  -917,  -917,   239,  -917,  5823,
02382      332,  6150,   249,  6259,  -917,   296,  -917,   251,   408,  -917,
02383     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,   -22,   300,
02384      301,   408,   408,     0,    22,   303,   310,   188,   271,  -917,
02385     -917,  -917,  -917,  -917,  4932,  -917,   138,  5714,  -917,  -917,
02386     6850,  -917,  -917,  -917,  6850,  6850,  -917,  6850,  6850,  6850,
02387     6850,  6850,  6850,  6850,  6850,  6850,  6850,  6850,  6850,  6850,
02388     6850,  -917,  -917,  -917,   278,  -917,  4819,  -917,    19,  -917,
02389      280,   281,   848,   848,  4819,    10,   134,   134,  6720,  -917,
02390     -917,  -917,  -917,  -917,  -917,  -917,   325,   300,   301,  6900,
02391      326,  -917,  -917,   327,   303,   310,  6795,  -917,  -917,  -917,
02392     -917,  -917,   279,  4456,   277,   -58,   330,  -917,  -917,  -917,
02393     -917,   408,  4606,  -917,  1000,  5605,   284,  5605,   284,  -917,
02394     -917,  -917,  -917,  -917,  -917,  -917,  -917,   408,  1154,  5605,
02395     6850,   295,  1308,  5605,   284,  6259,  -917,  -917,  4588,  -917,
02396     6585,  -917,  1462,   302,   304,   318,  -917,  1616,  5605,   166,
02397     -917,  -917,  -917,  -917,   308,  6850,  1770,  5605,  -917,  -917,
02398     -917,  -917,  -917,  -917,  -917,   311,  6850,  6850,  6850,   314,
02399      324,  6850,   335,   336,   338,   339,   340,   362,   368,   376,
02400      377,   378,   381,   391,   397,   393,  -917,   396,  -917,  -917,
02401     4819,  -917,  -917,  -917,  -917,   405,  -917,  6850,   407,   414,
02402      422,  -917,  -917,   -58,  1924,   389,   404,  -917,  -917,  -917,
02403     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02404     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02405     -917,   423,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02406     -917,  -917,  -917,  -917,  -917,   283,  -917,  -917,  -917,  -917,
02407     -917,   464,    40,    40,   184,  -917,  -917,  -917,  -917,   424,
02408     4819,  -917,  -917,  -917,  -917,  -917,  -917,  -917,    28,   -12,
02409        5,   139,   175,   123,   125,  6850,  -917,  -917,  -917,   426,
02410     -917,   469,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02411     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02412     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02413     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02414     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02415     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02416     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02417      425,   427,   351,   429,   428,   433,  -917,   431,   434,   432,
02418      430,  6850,  -917,   439,   443,   445,  6850,  -917,   488,  -917,
02419     -917,   444,   447,   533,  6850,  6850,  -917,  -917,  -917,  -917,
02420     -917,   448,  -917,   453,    15,  -917,  -917,   452,  -917,   451,
02421      450,   459,  -917,  -917,   454,  6477,  -917,  -917,  -917,  -917,
02422     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  6850,  -917,
02423     -917,  -917,  -917,  -917,  -917,  -917,   449,   455,  -917,  -917,
02424      462,  -917,  -917,   585,   586,  -917,  -917,  -917,  4768,  -917,
02425     -917,   458,   461,   445,  5605,  -917,  -917,   470,   463,  -917,
02426     4663,  2078,  2232,  2386,  2540,  2694,  -917,  -917,   408,   408,
02427      408,  -917,   465,  -917,  -917,  -917,  -917,  -917,  -917,  6850,
02428     4531,   468,  -917,  -917,   472,    41,  -917,  4693,  -917,  -917,
02429     6850,  -917,  -917,  -917,   474,  -917,  -917,  -917,  -917,  6259,
02430     -917,  -917,  -917,  6477,  6477,  -917,   482,  6477,  6477,  6477,
02431     6477,  6477,  6477,  6477,  6477,  6477,  6477,   477,  -917,  -917,
02432     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02433     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02434     -917,   481,   611,  -917,   144,  -917,   486,   483,  -917,   408,
02435     -917,   445,  6850,  -917,  -917,  -917,  -917,  -917,  -917,   284,
02436     5605,  -917,  -917,  -917,   351,    43,   284,    59,  -917,   -22,
02437        0,    22,  -917,  -917,  -917,  -917,   364,  -917,  -917,  -917,
02438     -917,   188,  -917,  -917,   284,    82,  -917,  -917,  -917,  -917,
02439      485,  6259,  6850,  -917,  6585,  -917,   279,  -917,   489,  6259,
02440     -917,   493,  6477,  -917,   494,   495,   496,   497,   498,   499,
02441      500,   501,   502,   503,  -917,   504,   445,  4803,  4768,   446,
02442      446,  -917,  -917,  -917,  -917,  -917,  4531,  -917,   506,   445,
02443      505,   507,   510,  -917,   487,  -917,  -917,  -917,  -917,  -917,
02444     -917,  3772,   508,   511,  -917,  4531,  -917,  -917,  -917,  -917,
02445     -917,  -917,  -917,  -917,  -917,  -917,  -917,  4531,   513,  -917,
02446       40,  -917,  5377,  -917,  -917,  -917,  -917,  -917,   509,  -917,
02447     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,   627,
02448      628,  -917,   516,   517,  -917,  -917,  -917,  6259,   445,  -917,
02449      512,  -917,   518,   408,  -917,  -917,  -917,  -917,  4294,    28,
02450      -12,     5,  -917,  3904,  4424,   139,   520,   607,   175,   123,
02451      125,   523,   524,   525,   526,   528,   529,   530,   532,   534,
02452      535,   538,   539,   540,  -917,  6850,    10,  -917,    10,  -917,
02453     -917,  4034,   134,   134,  6850,   134,  -917,  -917,  6690,  -917,
02454     -917,  -917,   542,  4531,  -917,  -917,  -917,    41,  -917,  -917,
02455     -917,  -917,   390,   277,  -917,   544,  -917,   545,   546,   547,
02456     -917,  -917,   543,   536,   550,  -917,   445,  -917,   505,  2848,
02457       97,  6850,  6850,   289,  4987,  6825,  4987,  -917,  -917,   243,
02458      134,   134,  6720,  -917,  6850,  -917,  4164,  -917,  -917,  -917,
02459      553,   555,    10,   134,   134,  -917,  -917,  -917,  -917,  -917,
02460      102,  -917,  -917,   107,  -917,   279,  -917,   554,  5377,  -917,
02461     -917,  3310,  -917,  -917,  -917,   557,   558,   556,   625,   562,
02462     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,   200,
02463      200,  -917,   200,  5008,  6850,  5008,  -917,  -917,  -917,  -917,
02464     4294,   563,  6850,  3002,  -917,  -917,   559,  -917,  -917,  -917,
02465     -917,  -917,  -917,  -917,  -917,  -917,  4768,  -917,  -917,  -917,
02466     -917,  -917,  3156,  3464,  -917,  -917,  -917,  -917,   566,  -917,
02467      144,  -917,  4803,  -917,  -917,  -917,  -917,   565,  3618,  -917,
02468     -917
02469 };
02470 
02471 /* YYPGOTO[NTERM-NUM].  */
02472 static const yytype_int16 yypgoto[] =
02473 {
02474     -917,  -270,  -917,  -917,  -917,  -917,  -917,   -72,  -917,  -917,
02475     -917,  -917,  -917,  -917,  -587,  -917,  -917,  -273,    -2,  -917,
02476     -917,   -84,  -917,  -917,  -476,  -917,  -917,  -541,  -660,  -917,
02477     -917,  -917,  -917,  -917,  -917,  -227,  -680,   -78,  -917,   -77,
02478     -505,  -917,   -29,  -917,  -917,  -917,  -917,  -466,  -917,  -917,
02479     -917,   -27,  -917,  -917,  -750,  -917,  -917,   -70,   435,  -917,
02480     -917,  -146,  -917,  -917,  -917,  -917,  -250,  -917,  -399,   -81,
02481     -917,  -917,  -917,  -917,  -261,  -917,  -917,  -917,  -917,  -202,
02482     -125,  -501,  -917,  -917,  -532,  -917,  -175,  -917,  -917,  -917,
02483     -917,   480,  -690,  -917,  -917,   -71,  -182,   -83,     2,  -917,
02484      173,  -917,  -917,  -837,  -917,  -177,  -917,  -917,  -917,  -917,
02485     -296,  -917,  -917,  -917,  -917,  -761,  -178,  -661,  -917,  -917,
02486     -917,  -917,  -917,    -4,  -917,  -917,     1,   -35,    90,  -111,
02487      613,   612,  -917,   -33,  -917,  -917,  -917,  -246,  -917,  -917,
02488      131,   -10,    31,   -86,  -917,   514,  -180,  -291,     8,  -232,
02489     -726,  -917,  -181,  -917,  -917,  -727,  -917,  -917,  -917,  -917,
02490     -917,  -917,  -917,  -630,   -59,  -917,  -917,  -917,  -917,  -917,
02491     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,
02492     -917,  -917,  -917,  -917,  -917,  -917,  -917,  -917,   519,   -98,
02493     -916,  -917,  -877,  -917,  -917,  -917
02494 };
02495 
02496 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
02497    positive, shift that token.  If negative, reduce the rule which
02498    number is the opposite.  If zero, do what YYDEFACT says.
02499    If YYTABLE_NINF, syntax error.  */
02500 #define YYTABLE_NINF -406
02501 static const yytype_int16 yytable[] =
02502 {
02503      136,   140,   163,   286,   102,   515,   410,   230,   233,   535,
02504      187,   437,   139,   141,   586,   242,   243,   244,   245,   268,
02505      232,   524,   235,   765,   237,   626,   154,   157,   630,   707,
02506      823,   514,   824,   189,   110,   162,   725,   527,   155,   158,
02507      543,   894,   496,   517,   348,   621,   805,   523,   777,   778,
02508      779,  1003,     2,   288,   221,   946,   496,   359,   292,   221,
02509      496,   686,   541,   221,   777,   778,   779,   236,   165,   633,
02510      496,   547,  -339,   177,   995,   496,   167,   424,   302,   717,
02511     -343,   425,  -343,   582,   496,   583,   418,   777,   778,   779,
02512      169,   197,   307,   920,  -341,   238,   149,  1018,   265,  -342,
02513      316,   727,   777,   778,   779,   192,   829,   777,   778,   779,
02514      409,   993,   777,   778,   779,   193,  -340,   152,   170,   171,
02515     -343,   933,  -339,  -280,   163,   882,   995,   164,   166,   825,
02516      826,   894,   496,   266,   728,   187,   195,   884,   172,   191,
02517     -279,   995,   364,   708,  -233,  -339,   357,   357,   187,   187,
02518      139,   141,   360,   155,   158,   361,   362,   222,   189,   772,
02519      223,   199,   222,  -278,   735,   223,   222,   152,   569,   351,
02520      314,   189,   189,   200,   188,   275,   981,   420,   173,   174,
02521      175,   780,   234,   584,   201,  -339,   151,   894,   202,   203,
02522      152,   773,  -342,   267,    33,   309,   325,   784,   315,   204,
02523      329,   330,  -344,   332,   333,   334,   335,   336,   337,   338,
02524      339,   340,   341,   342,   343,   344,   345,  -344,   176,  -345,
02525      799,   205,   349,   942,   822,   717,  -345,   347,   356,   356,
02526      349,   803,  -342,  -341,   363,   962,   971,   832,   187,   187,
02527      989,   272,  -344,   590,   717,   990,   973,   974,   206,   164,
02528      910,   195,   363,   297,   187,   991,   717,   207,  -281,   349,
02529     -282,   189,   189,   414,  -341,   187,  -345,   634,   239,  -340,
02530     1011,   240,   312,   178,  -276,  -340,   871,   189,   191,   763,
02531      313,   273,   271,   975,   311,  1017,   520,   411,   189,  1004,
02532     1005,   208,  1006,   209,   940,   971,   904,  -268,   943,   301,
02533      542,   179,   180,   441,  -341,   190,   210,   211,   313,   191,
02534     -277,   363,   304,   305,   199,  -340,   198,   181,   587,   182,
02535      199,   183,   549,   550,   551,  -278,   313,   554,  -278,   528,
02536     -278,   212,  -278,   213,   965,   249,   214,   966,   919,   693,
02537     -280,   967,   717,  -280,   215,  -280,   349,  -280,   687,   765,
02538      216,   217,   279,   571,   218,   219,   608,   609,   610,   220,
02539      178,   184,   185,   186,   929,   509,   733,   509,   277,   496,
02540      496,   496,   496,   496,   959,   646,   287,   290,   293,   509,
02541      280,   281,   192,   509,   296,   311,   601,   602,   179,   180,
02542      298,   299,   603,   604,  -343,  -342,   605,  -344,   509,   318,
02543      282,   886,   427,   440,  -345,   306,  -279,   509,   183,  -279,
02544      963,  -279,   346,  -279,   353,   354,   349,   178,   440,  -339,
02545     -341,  -340,   415,   979,   426,   512,   774,   319,   320,   440,
02546     -268,   597,   521,   783,   221,   786,   787,   579,   538,   537,
02547      283,   284,   285,   535,   545,   179,   180,   321,   184,   185,
02548      186,   798,   539,   548,   775,   178,   552,   664,   665,   666,
02549      667,   668,   669,   740,   741,   183,   553,   744,   745,   746,
02550      747,   748,   749,   750,   751,   752,   753,   555,   556,   187,
02551      557,   558,   559,   179,   180,   888,   889,   322,   323,   324,
02552      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
02553      133,   134,   189,   183,   560,   184,   185,   186,   788,   789,
02554      561,   790,   791,   792,   793,   794,   795,   520,   562,   563,
02555      564,  -276,   597,   565,  -276,   890,  -276,   566,  -276,  -277,
02556      632,   632,  -277,   567,  -277,   568,  -277,   222,   313,   570,
02557      223,   572,   576,   184,   185,   186,  -281,  -282,   573,  -281,
02558     -282,  -281,  -282,  -281,  -282,   187,   574,   577,   581,   578,
02559      589,   599,   810,   600,   657,   606,   614,   187,   615,   607,
02560      616,   617,   618,   620,   619,   187,   187,   187,   189,   622,
02561      623,  -212,   627,   925,   628,    39,   641,   721,   635,   629,
02562      189,   636,   638,   640,   187,   642,   645,   660,   189,   189,
02563      189,   661,   662,   658,   689,   688,   723,   704,   726,   659,
02564      722,  -273,   737,   937,   685,   520,   720,   189,   743,   754,
02565      761,   762,   767,   768,   837,   806,   632,   801,   939,   809,
02566      811,   812,   813,   814,   815,   816,   817,   818,   898,   899,
02567      821,   831,   835,   613,   819,   820,   836,   833,   881,   880,
02568      885,   896,   900,   901,   907,   926,   187,   927,  -295,  -296,
02569     -285,  -286,   964,  -287,  -288,  -289,   905,  -290,   999,  -291,
02570     -292,   187,   939,  -293,  -294,   928,   957,   496,   941,   189,
02571      950,   952,   953,   954,   509,   955,   958,   984,   597,   985,
02572      992,   998,   976,  1009,   189,  -405,   997,   868,  1001,  1007,
02573     1015,  1019,   776,   869,   870,   804,   960,   436,   908,   866,
02574      877,   875,   944,   358,  1016,   949,   903,   637,   269,   496,
02575      270,   956,   879,     0,   187,   187,   187,   187,   597,   738,
02576        0,   440,   939,   721,     0,     0,     0,   909,     0,   701,
02577      702,   703,   352,     0,     0,     0,     0,   189,   189,   189,
02578      189,   496,   721,     0,     0,     0,   722,     0,   440,     0,
02579        0,     0,   720,     0,   721,     0,     0,   286,   408,     0,
02580      496,   496,     0,   921,     0,   722,     0,     0,     0,     0,
02581        0,   720,   878,   930,     0,   931,   496,   722,     0,     0,
02582      509,   935,   936,   720,   938,     0,     0,     0,   349,   932,
02583      187,   934,     0,     0,     0,     0,   948,     0,     0,   163,
02584        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02585      771,   802,     0,   189,     0,     0,     0,     0,     0,   807,
02586      983,     0,     0,     0,     0,   613,     0,     0,     0,   977,
02587      978,     0,     0,     0,   922,     0,     0,     0,     0,   986,
02588      721,     0,   987,   988,     0,     0,     0,   318,     0,     0,
02589        0,   597,     0,     0,     0,     0,     0,     0,  1002,     0,
02590        0,     0,   922,   722,   265,     0,     0,     0,     0,   720,
02591        0,     0,     0,     0,     0,   319,   320,     0,   349,     0,
02592        0,     0,   221,     0,     0,     0,     0,     0,     0,     0,
02593        0,     0,     0,     0,     0,   321,     0,   597,   363,     0,
02594      969,   970,   972,     0,     0,     0,     0,     0,   363,     0,
02595      597,     0,   139,   141,   158,     0,     0,   982,   913,     0,
02596        0,     0,     0,     0,   164,     0,     0,     0,     0,     0,
02597        0,     0,     0,     0,   349,   322,   323,   324,   123,   124,
02598      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
02599        0,     0,     0,   187,   771,     0,     0,     0,     0,   969,
02600      970,   972,     0,     0,     0,     0,     0,     0,   363,   187,
02601        0,     0,     0,     0,     0,     0,   189,     0,     0,     0,
02602        0,     0,     0,     0,     0,   222,     0,     0,   223,     0,
02603        0,     0,   189,   442,   443,   444,   445,   446,   447,   448,
02604      449,   450,   451,   452,   453,   454,   455,     8,     9,    10,
02605       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
02606       21,    22,    23,    24,    25,    26,    27,   456,   457,   458,
02607      459,   460,   461,   462,   463,   464,   465,    35,    36,     0,
02608      466,     0,   467,   468,   469,   470,   471,   472,   473,   474,
02609      475,     0,   476,   477,     0,   478,   479,   480,   481,   367,
02610      368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
02611      378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
02612      388,   389,   390,   482,   483,   484,   485,   486,   487,   488,
02613       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
02614       62,    63,     0,     0,     0,     0,     0,     0,     0,     0,
02615        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02616        0,     0,     0,     0,   489,   490,     0,   491,   492,   392,
02617      393,   493,   394,   395,   396,   397,   398,   399,   400,   401,
02618      402,   403,   404,   494,     0,   406,   495,   442,   443,   444,
02619      445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
02620      455,     8,     9,    10,    11,    12,    13,    14,    15,    16,
02621       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
02622       27,   456,   457,   458,   459,   460,   461,   462,   463,   464,
02623      465,    35,    36,     0,   466,     0,   467,   468,   469,   470,
02624      471,   472,   473,   474,   475,     0,   476,   477,     0,   478,
02625      479,   480,   481,   367,   368,   369,   370,   371,   372,   373,
02626      374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
02627      384,   385,   386,   387,   388,   389,   390,   482,   483,   484,
02628      485,   486,   487,   488,    52,    53,    54,    55,    56,    57,
02629       58,    59,    60,    61,    62,    63,     0,     0,     0,     0,
02630        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02631        0,     0,     0,     0,     0,     0,     0,     0,   489,   490,
02632      516,   491,     0,   392,   393,   493,   394,   395,   396,   397,
02633      398,   399,   400,   401,   402,   403,   404,   494,     0,   406,
02634      495,   442,   443,   444,   445,   446,   447,   448,   449,   450,
02635      451,   452,   453,   454,   455,     8,     9,    10,    11,    12,
02636       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
02637       23,    24,    25,    26,    27,   456,   457,   458,   459,   460,
02638      461,   462,   463,   464,   465,    35,    36,     0,   466,     0,
02639      467,   468,   469,   470,   471,   472,   473,   474,   475,     0,
02640      476,   477,     0,   478,   479,   480,   481,   367,   368,   369,
02641      370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
02642      380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
02643      390,   482,   483,   484,   485,   486,   487,   488,    52,    53,
02644       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
02645        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02646        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02647        0,     0,   489,   490,     0,   491,   522,   392,   393,   493,
02648      394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
02649      404,   494,     0,   406,   495,   442,   443,   444,   445,   446,
02650      447,   448,   449,   450,   451,   452,   453,   454,   455,     8,
02651        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
02652       19,    20,    21,    22,    23,    24,    25,    26,    27,   456,
02653      457,   458,   459,   460,   461,   462,   463,   464,   465,    35,
02654       36,     0,   466,     0,   467,   468,   469,   470,   471,   472,
02655      473,   474,   475,     0,   476,   477,     0,   478,   479,   480,
02656      481,   367,   368,   369,   370,   371,   372,   373,   374,   375,
02657      376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
02658      386,   387,   388,   389,   390,   482,   483,   484,   485,   486,
02659      487,   488,    52,    53,    54,    55,    56,    57,    58,    59,
02660       60,    61,    62,    63,     0,     0,     0,     0,     0,     0,
02661        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02662        0,     0,     0,     0,     0,     0,   489,   490,     0,   491,
02663      536,   392,   393,   493,   394,   395,   396,   397,   398,   399,
02664      400,   401,   402,   403,   404,   494,     0,   406,   495,   442,
02665      443,   444,   445,   446,   447,   448,   449,   450,   451,   452,
02666      453,   454,   455,     8,     9,    10,    11,    12,    13,    14,
02667       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
02668       25,    26,    27,   456,   457,   458,   459,   460,   461,   462,
02669      463,   464,   465,    35,    36,     0,   466,     0,   467,   468,
02670      469,   470,   471,   472,   473,   474,   475,     0,   476,   477,
02671        0,   478,   479,   480,   481,   367,   368,   369,   370,   371,
02672      372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
02673      382,   383,   384,   385,   386,   387,   388,   389,   390,   482,
02674      483,   484,   485,   486,   487,   488,    52,    53,    54,    55,
02675       56,    57,    58,    59,    60,    61,    62,    63,     0,     0,
02676        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02677        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02678      489,   490,   540,   491,     0,   392,   393,   493,   394,   395,
02679      396,   397,   398,   399,   400,   401,   402,   403,   404,   494,
02680        0,   406,   495,   442,   443,   444,   445,   446,   447,   448,
02681      449,   450,   451,   452,   453,   454,   455,     8,     9,    10,
02682       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
02683       21,    22,    23,    24,    25,    26,    27,   456,   457,   458,
02684      459,   460,   461,   462,   463,   464,   465,    35,    36,     0,
02685      466,     0,   467,   468,   469,   470,   471,   472,   473,   474,
02686      475,     0,   476,   477,     0,   478,   479,   480,   481,   367,
02687      368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
02688      378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
02689      388,   389,   390,   482,   483,   484,   485,   486,   487,   488,
02690       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
02691       62,    63,     0,     0,     0,     0,     0,     0,     0,     0,
02692        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02693        0,     0,     0,     0,   489,   490,   546,   491,     0,   392,
02694      393,   493,   394,   395,   396,   397,   398,   399,   400,   401,
02695      402,   403,   404,   494,     0,   406,   495,   442,   443,   444,
02696      445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
02697      455,     8,     9,    10,    11,    12,    13,    14,    15,    16,
02698       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
02699       27,   456,   457,   458,   459,   460,   461,   462,   463,   464,
02700      465,    35,    36,     0,   466,     0,   467,   468,   469,   470,
02701      471,   472,   473,   474,   475,     0,   476,   477,     0,   478,
02702      479,   480,   481,   367,   368,   369,   370,   371,   372,   373,
02703      374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
02704      384,   385,   386,   387,   388,   389,   390,   482,   483,   484,
02705      485,   486,   487,   488,    52,    53,    54,    55,    56,    57,
02706       58,    59,    60,    61,    62,    63,     0,     0,     0,     0,
02707        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02708        0,     0,     0,     0,     0,     0,     0,     0,   489,   490,
02709        0,   491,   575,   392,   393,   493,   394,   395,   396,   397,
02710      398,   399,   400,   401,   402,   403,   404,   494,     0,   406,
02711      495,   442,   443,   444,   445,   446,   447,   448,   449,   450,
02712      451,   452,   453,   454,   455,     8,     9,    10,    11,    12,
02713       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
02714       23,    24,    25,    26,    27,   456,   457,   458,   459,   460,
02715      461,   462,   463,   464,   465,    35,    36,     0,   466,     0,
02716      467,   468,   469,   470,   471,   472,   473,   474,   475,     0,
02717      476,   477,     0,   478,   479,   480,   481,   367,   368,   369,
02718      370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
02719      380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
02720      390,   482,   483,   484,   485,   486,   487,   488,    52,    53,
02721       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
02722        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02723        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02724        0,     0,   489,   490,   694,   491,     0,   392,   393,   493,
02725      394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
02726      404,   494,     0,   406,   495,   442,   443,   444,   445,   446,
02727      447,   448,   449,   450,   451,   452,   453,   454,   455,     8,
02728        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
02729       19,    20,    21,    22,    23,    24,    25,    26,    27,   456,
02730      457,   458,   459,   460,   461,   462,   463,   464,   465,    35,
02731       36,     0,   466,     0,   467,   468,   469,   470,   471,   472,
02732      473,   474,   475,     0,   476,   477,     0,   478,   479,   480,
02733      481,   367,   368,   369,   370,   371,   372,   373,   374,   375,
02734      376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
02735      386,   387,   388,   389,   390,   482,   483,   484,   485,   486,
02736      487,   488,    52,    53,    54,    55,    56,    57,    58,    59,
02737       60,    61,    62,    63,     0,     0,     0,     0,     0,     0,
02738        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02739        0,     0,     0,     0,     0,     0,   489,   490,   695,   491,
02740        0,   392,   393,   493,   394,   395,   396,   397,   398,   399,
02741      400,   401,   402,   403,   404,   494,     0,   406,   495,   442,
02742      443,   444,   445,   446,   447,   448,   449,   450,   451,   452,
02743      453,   454,   455,     8,     9,    10,    11,    12,    13,    14,
02744       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
02745       25,    26,    27,   456,   457,   458,   459,   460,   461,   462,
02746      463,   464,   465,    35,    36,     0,   466,     0,   467,   468,
02747      469,   470,   471,   472,   473,   474,   475,     0,   476,   477,
02748        0,   478,   479,   480,   481,   367,   368,   369,   370,   371,
02749      372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
02750      382,   383,   384,   385,   386,   387,   388,   389,   390,   482,
02751      483,   484,   485,   486,   487,   488,    52,    53,    54,    55,
02752       56,    57,    58,    59,    60,    61,    62,    63,     0,     0,
02753        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02754        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02755      489,   490,   696,   491,     0,   392,   393,   493,   394,   395,
02756      396,   397,   398,   399,   400,   401,   402,   403,   404,   494,
02757        0,   406,   495,   442,   443,   444,   445,   446,   447,   448,
02758      449,   450,   451,   452,   453,   454,   455,     8,     9,    10,
02759       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
02760       21,    22,    23,    24,    25,    26,    27,   456,   457,   458,
02761      459,   460,   461,   462,   463,   464,   465,    35,    36,     0,
02762      466,     0,   467,   468,   469,   470,   471,   472,   473,   474,
02763      475,     0,   476,   477,     0,   478,   479,   480,   481,   367,
02764      368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
02765      378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
02766      388,   389,   390,   482,   483,   484,   485,   486,   487,   488,
02767       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
02768       62,    63,     0,     0,     0,     0,     0,     0,     0,     0,
02769        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02770        0,     0,     0,     0,   489,   490,     0,   491,   697,   392,
02771      393,   493,   394,   395,   396,   397,   398,   399,   400,   401,
02772      402,   403,   404,   494,     0,   406,   495,   442,   443,   444,
02773      445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
02774      455,     8,     9,    10,    11,    12,    13,    14,    15,    16,
02775       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
02776       27,   456,   457,   458,   459,   460,   461,   462,   463,   464,
02777      465,    35,    36,     0,   466,     0,   467,   468,   469,   470,
02778      471,   472,   473,   474,   475,     0,   476,   477,     0,   478,
02779      479,   480,   481,   367,   368,   369,   370,   371,   372,   373,
02780      374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
02781      384,   385,   386,   387,   388,   389,   390,   482,   483,   484,
02782      485,   486,   487,   488,    52,    53,    54,    55,    56,    57,
02783       58,    59,    60,    61,    62,    63,     0,     0,     0,     0,
02784        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02785        0,     0,     0,     0,     0,     0,     0,     0,   489,   490,
02786        0,   491,     0,   392,   393,   493,   394,   395,   396,   397,
02787      398,   399,   400,   401,   402,   403,   404,   494,   698,   406,
02788      495,   442,   443,   444,   445,   446,   447,   448,   449,   450,
02789      451,   452,   453,   454,   455,     8,     9,    10,    11,    12,
02790       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
02791       23,    24,    25,    26,    27,   456,   457,   458,   459,   460,
02792      461,   462,   463,   464,   465,    35,    36,     0,   466,     0,
02793      467,   468,   469,   470,   471,   472,   473,   474,   475,     0,
02794      476,   477,     0,   478,   479,   480,   481,   367,   368,   369,
02795      370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
02796      380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
02797      390,   482,   483,   484,   485,   486,   487,   488,    52,    53,
02798       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
02799        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02800        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02801        0,     0,   489,   490,   961,   491,     0,   392,   393,   493,
02802      394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
02803      404,   494,     0,   406,   495,   442,   443,   444,   445,   446,
02804      447,   448,   449,   450,   451,   452,   453,   454,   455,     8,
02805        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
02806       19,    20,    21,    22,    23,    24,    25,    26,    27,   456,
02807      457,   458,   459,   460,   461,   462,   463,   464,   465,    35,
02808       36,     0,   466,     0,   467,   468,   469,   470,   471,   472,
02809      473,   474,   475,     0,   476,   477,     0,   478,   479,   480,
02810      481,   367,   368,   369,   370,   371,   372,   373,   374,   375,
02811      376,   377,   378,   379,   380,   381,   382,   383,   384,   385,
02812      386,   387,   388,   389,   390,   482,   483,   484,   485,   486,
02813      487,   488,    52,    53,    54,    55,    56,    57,    58,    59,
02814       60,    61,    62,    63,     0,     0,     0,     0,     0,     0,
02815        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02816        0,     0,     0,     0,     0,     0,   489,   490,  1008,   491,
02817        0,   392,   393,   493,   394,   395,   396,   397,   398,   399,
02818      400,   401,   402,   403,   404,   494,     0,   406,   495,   442,
02819      443,   444,   445,   446,   447,   448,   449,   450,   451,   452,
02820      453,   454,   455,     8,     9,    10,    11,    12,    13,    14,
02821       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
02822       25,    26,    27,   456,   457,   458,   459,   460,   461,   462,
02823      463,   464,   465,    35,    36,     0,   466,     0,   467,   468,
02824      469,   470,   471,   472,   473,   474,   475,     0,   476,   477,
02825        0,   478,   479,   480,   481,   367,   368,   369,   370,   371,
02826      372,   373,   374,   375,   376,   377,   378,   379,   380,   381,
02827      382,   383,   384,   385,   386,   387,   388,   389,   390,   482,
02828      483,   484,   485,   486,   487,   488,    52,    53,    54,    55,
02829       56,    57,    58,    59,    60,    61,    62,    63,     0,     0,
02830        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02831        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02832      489,   490,     0,   491,  1013,   392,   393,   493,   394,   395,
02833      396,   397,   398,   399,   400,   401,   402,   403,   404,   494,
02834        0,   406,   495,   442,   443,   444,   445,   446,   447,   448,
02835      449,   450,   451,   452,   453,   454,   455,     8,     9,    10,
02836       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
02837       21,    22,    23,    24,    25,    26,    27,   456,   457,   458,
02838      459,   460,   461,   462,   463,   464,   465,    35,    36,     0,
02839      466,     0,   467,   468,   469,   470,   471,   472,   473,   474,
02840      475,     0,   476,   477,     0,   478,   479,   480,   481,   367,
02841      368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
02842      378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
02843      388,   389,   390,   482,   483,   484,   485,   486,   487,   488,
02844       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
02845       62,    63,     0,     0,     0,     0,     0,     0,     0,     0,
02846        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02847        0,     0,     0,     0,     0,   490,   994,   491,     0,   392,
02848      393,   493,   394,   395,   396,   397,   398,   399,   400,   401,
02849      402,   403,   404,   494,     0,   406,   495,   442,   443,   444,
02850      445,   446,   447,   448,   449,   450,   451,   452,   453,   454,
02851      455,     8,     9,    10,    11,    12,    13,    14,    15,    16,
02852       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
02853       27,   456,   457,   458,   459,   460,   461,   462,   463,   464,
02854      465,    35,    36,     0,   466,     0,   467,   468,   469,   470,
02855      471,   472,   473,   474,   475,     0,   476,   477,     0,   478,
02856      479,   480,   481,   367,   368,   369,   370,   371,   372,   373,
02857      374,   375,   376,   377,   378,   379,   380,   381,   382,   383,
02858      384,   385,   386,   387,   388,   389,   390,   482,   483,   484,
02859      485,   486,   487,   488,    52,    53,    54,    55,    56,    57,
02860       58,    59,    60,    61,    62,    63,     0,     0,     0,     0,
02861        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02862        0,     0,     0,     0,     0,     0,     0,     0,  1014,   490,
02863        0,   491,     0,   392,   393,   493,   394,   395,   396,   397,
02864      398,   399,   400,   401,   402,   403,   404,   494,     0,   406,
02865      495,   442,   443,   444,   445,   446,   447,   448,   449,   450,
02866      451,   452,   453,   454,   455,     8,     9,    10,    11,    12,
02867       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
02868       23,    24,    25,    26,    27,   456,   457,   458,   459,   460,
02869      461,   462,   463,   464,   465,    35,    36,     0,   466,     0,
02870      467,   468,   469,   470,   471,   472,   473,   474,   475,     0,
02871      476,   477,     0,   478,   479,   480,   481,   367,   368,   369,
02872      370,   371,   372,   373,   374,   375,   376,   377,   378,   379,
02873      380,   381,   382,   383,   384,   385,   386,   387,   388,   389,
02874      390,   482,   483,   484,   485,   486,   487,   488,    52,    53,
02875       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
02876        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02877        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02878        0,     0,  1020,   490,     0,   491,     0,   392,   393,   493,
02879      394,   395,   396,   397,   398,   399,   400,   401,   402,   403,
02880      404,   494,     0,   406,   495,     4,     5,     0,     0,     0,
02881      838,   839,     0,     0,     0,     0,     0,     0,     0,     8,
02882        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
02883       19,    20,    21,    22,    23,    24,    25,    26,    27,   840,
02884      841,    30,    31,   842,     0,    33,     0,     0,    34,    35,
02885       36,   843,   844,    38,    39,    40,    41,     0,    43,   845,
02886       45,   161,    47,   846,     0,     0,   847,     0,     0,     0,
02887        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02888        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02889        0,     0,     0,     0,     0,     0,     0,     0,     0,   848,
02890      849,   850,   851,   852,   853,   854,   855,   856,   857,   858,
02891      859,   860,   861,   862,    64,    65,    66,    67,    68,    69,
02892       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
02893       80,    81,    82,    83,    84,   863,   864,   914,   915,     0,
02894        0,     0,   838,   839,     0,     0,     0,     0,   865,     0,
02895        0,     8,     9,    10,    11,    12,    13,    14,    15,    16,
02896       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
02897       27,   840,   841,   145,   916,     0,     0,    33,     0,     0,
02898       34,    35,    36,     0,   844,    38,    39,    40,     0,     0,
02899        0,   845,   160,   161,     0,     0,     0,     0,   847,     0,
02900        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02901        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02902        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02903        0,   848,   849,   850,   851,   852,   853,   854,   855,   856,
02904      857,   858,   859,   860,   861,   862,     0,     0,     0,     0,
02905        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02906        0,     0,     0,     0,     0,     0,     0,     4,     5,     0,
02907        0,     0,   838,   839,     0,     0,     0,     0,     0,     0,
02908      865,     8,     9,    10,    11,    12,    13,    14,    15,    16,
02909       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
02910       27,   840,   841,   145,    31,     0,     0,    33,     0,     0,
02911       34,    35,    36,     0,   844,    38,     0,    40,     0,     0,
02912        0,   845,   160,   161,     0,     0,     0,     0,   847,     0,
02913        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02914        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02915        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02916        0,   848,   849,   850,   851,   852,   853,   854,   855,   856,
02917      857,   858,   859,   860,   861,   862,     0,     0,     0,     0,
02918        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02919        0,     0,     0,     0,     0,     0,     0,   142,   143,     0,
02920        0,     0,   980,   839,     0,     0,     0,     0,     0,     0,
02921      865,     8,     9,    10,    11,    12,    13,    14,    15,    16,
02922       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
02923       27,   840,   841,   145,   146,     0,     0,    33,     0,     0,
02924        0,    35,    36,     0,   844,    38,     0,    40,     0,     0,
02925        0,   845,   160,   161,     0,     0,     0,     0,   847,     0,
02926        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02927        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02928        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02929        0,   848,   849,   850,   851,   852,   853,   854,   855,   856,
02930      857,   858,   859,   860,   861,   862,     0,     0,     0,     0,
02931        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02932        0,     0,     0,     0,     0,     0,     0,   142,   143,     0,
02933        0,     0,     0,   144,     0,     0,     0,     0,     0,     0,
02934      865,     8,     9,    10,    11,    12,    13,    14,    15,    16,
02935       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
02936       27,    28,    29,   145,   146,     0,     0,    33,     0,     0,
02937        0,    35,    36,     0,   159,    38,     0,    40,     0,     0,
02938        0,   147,   160,   161,     0,     0,     0,     0,     0,     0,
02939        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02940        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02941        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02942        0,   148,    50,    51,    52,    53,    54,    55,    56,    57,
02943       58,    59,    60,    61,    62,    63,     0,     0,     0,     0,
02944        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02945        0,     0,     0,     0,     0,     0,     0,   142,   143,     0,
02946        0,     0,     0,   839,     0,     0,     0,     0,     0,     0,
02947      911,     8,     9,    10,    11,    12,    13,    14,    15,    16,
02948       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
02949       27,   840,   841,   145,   146,   318,     0,    33,     0,     0,
02950        0,    35,    36,     0,     0,     0,     0,    40,     0,     0,
02951        0,   845,   160,     0,     0,     0,     0,     0,   923,     0,
02952        0,     0,     0,   319,   320,     0,     0,     0,     0,     0,
02953      221,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02954        0,     0,     0,   321,     0,     0,     0,     0,     0,     0,
02955        0,   848,   849,   850,   851,   852,   853,   854,   855,   856,
02956      857,   858,   859,   860,   861,   862,     0,     0,     0,     0,
02957      709,     0,   503,   504,   505,     0,   506,   507,     0,     0,
02958        0,   251,   252,   322,   323,   324,   123,   124,   125,   126,
02959      127,   128,   129,   130,   131,   132,   133,   134,   247,   248,
02960      924,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02961        0,     0,     0,     0,     0,     0,     0,     0,   710,     0,
02962        0,     0,     0,     0,     0,     0,     0,   428,     0,     0,
02963        0,     0,     0,   222,     0,     0,   223,     0,     0,     0,
02964        0,     0,     0,     0,     0,   428,     0,     0,     0,     0,
02965        0,     0,     0,     0,     0,   429,   430,     0,   711,   254,
02966      255,   123,   124,   125,   126,   127,   128,   129,   130,   131,
02967      132,   133,   134,   429,   430,   431,     0,     0,     0,     0,
02968        0,     0,    34,     0,     0,     0,     0,     0,     0,     0,
02969        0,     0,     0,   431,     0,     0,   712,     0,     0,     0,
02970        0,     0,   428,     0,     0,   713,   714,   715,     0,     0,
02971        0,     0,     0,     0,     0,   432,   433,   434,   123,   124,
02972      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
02973      429,   430,   428,   432,   433,   434,   123,   124,   125,   126,
02974      127,   128,   129,   130,   131,   132,   133,   134,     0,     0,
02975      431,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02976      429,   430,     0,     0,   526,     0,     0,     0,     0,     0,
02977        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02978      431,     0,   435,     0,     0,     0,     0,     0,     0,     0,
02979      432,   433,   434,   123,   124,   125,   126,   127,   128,   129,
02980      130,   131,   132,   133,   134,     0,     0,   178,   663,   664,
02981      665,   666,   667,   668,   669,     0,     0,     0,     0,     0,
02982      432,   433,   434,   123,   124,   125,   126,   127,   128,   129,
02983      130,   131,   132,   133,   134,   179,   180,     0,     0,   692,
02984        0,     0,   178,   663,   664,   665,   666,   667,   668,   669,
02985        0,     0,     0,     0,     0,   183,     0,     0,   318,     0,
02986        0,     0,     0,   670,   671,   672,   673,     0,     0,   732,
02987      179,   180,     0,     0,     0,     0,     0,     0,     0,     0,
02988        0,     0,     0,     0,     0,     0,   319,   320,     0,     0,
02989      183,     0,     0,     0,     0,   184,   185,   186,   670,   671,
02990      672,   673,     0,     0,     0,     0,   321,     0,     0,     0,
02991        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02992        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
02993      184,   185,   186,   674,     0,   675,     0,     0,     0,     0,
02994        0,     0,   676,   677,   251,   252,   322,   323,   324,   123,
02995      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
02996      134,     0,     0,     0,     0,   142,   143,     0,   674,     0,
02997        0,   144,     0,     0,     0,     0,     0,   676,   677,     8,
02998        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
02999       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
03000       29,   145,   146,     0,     0,    33,     0,     0,     0,    35,
03001       36,     0,     0,     0,     0,    40,     0,     0,     0,   147,
03002        0,     0,     0,     0,     0,     0,   116,     0,     0,     0,
03003        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03004        0,     0,     0,     0,     0,     0,     0,   318,     0,     0,
03005        0,     0,     0,     0,   117,   118,     0,     0,     0,   148,
03006       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
03007       60,    61,    62,    63,   119,   319,   320,     0,     0,     0,
03008        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03009        0,     0,     0,     0,     0,   321,     0,     0,     0,   310,
03010        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03011        0,     0,     0,     0,   120,   121,   122,   123,   124,   125,
03012      126,   127,   128,   129,   130,   131,   132,   133,   134,     0,
03013        0,     0,     0,     0,     0,   322,   323,   324,   123,   124,
03014      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
03015        0,   965,     0,     0,   966,     0,     0,     0,   967,     0,
03016        0,     0,     0,     0,     0,     0,     0,     0,     4,     5,
03017        0,     0,   965,     6,     7,   966,     0,     0,     0,   967,
03018        0,     0,     8,     9,    10,    11,    12,    13,    14,    15,
03019       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03020       26,    27,    28,    29,    30,    31,    32,     0,    33,     0,
03021        0,    34,    35,    36,     0,    37,    38,    39,    40,    41,
03022       42,    43,    44,    45,    46,    47,    48,     0,     0,     0,
03023        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03024        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03025        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03026        0,     0,    49,    50,    51,    52,    53,    54,    55,    56,
03027       57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
03028       67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
03029       77,    78,    79,    80,    81,    82,    83,    84,   116,    85,
03030        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03031        0,     0,     0,   116,     0,     0,     0,     0,     0,     0,
03032        0,     0,     0,     0,     0,     0,   117,   118,     0,     0,
03033        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03034        0,   117,   118,     0,     0,     0,   119,     0,     0,     0,
03035        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03036        0,   119,     0,     0,     0,     0,     0,     0,     0,     0,
03037        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03038        0,     0,     0,     0,     0,     0,   120,   121,   122,   123,
03039      124,   125,   126,   127,   128,   129,   130,   131,   132,   133,
03040      134,   120,   121,   122,   123,   124,   125,   126,   127,   128,
03041      129,   130,   131,   132,   133,   134,   318,     0,     0,     0,
03042        0,     0,     0,     0,     0,     0,   135,     0,     0,     0,
03043        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03044        0,   156,     0,     0,   319,   320,     0,     0,     0,     0,
03045        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03046        0,     0,     0,     0,   321,     0,     0,     0,     0,     0,
03047        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03048        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03049        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03050        0,     0,   888,   889,   322,   323,   324,   123,   124,   125,
03051      126,   127,   128,   129,   130,   131,   132,   133,   134,     0,
03052        0,     0,     0,     0,     0,     0,     0,     0,     0,     4,
03053        5,     0,     0,     0,     6,   144,     0,     0,     0,     0,
03054        0,     0,   890,     8,     9,    10,    11,    12,    13,    14,
03055       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
03056       25,    26,    27,    28,    29,   145,    31,     0,     0,    33,
03057        0,     0,    34,    35,    36,     0,   159,    38,     0,    40,
03058        0,     0,     0,   147,   160,   161,     0,     0,     0,     0,
03059        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03060        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03061        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03062        0,     0,     0,   148,    50,    51,    52,    53,    54,    55,
03063       56,    57,    58,    59,    60,    61,    62,    63,   142,   143,
03064        0,     0,     0,     0,   144,     0,   503,   504,   505,     0,
03065      506,   507,     8,     9,    10,    11,    12,    13,    14,    15,
03066       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03067       26,    27,    28,    29,   145,   146,     0,     0,    33,     0,
03068        0,     0,    35,    36,     0,     0,     0,     0,    40,     0,
03069        0,     0,   147,     0,     0,     0,     0,     0,     0,     0,
03070        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03071        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03072        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03073        0,     0,   148,    50,    51,    52,    53,    54,    55,    56,
03074       57,    58,    59,    60,    61,    62,    63,   142,   143,     0,
03075        0,     0,     0,   144,     0,     0,     0,     0,     0,     0,
03076        0,     8,     9,    10,    11,    12,    13,    14,    15,    16,
03077       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
03078       27,    28,    29,   145,   146,     0,     0,    33,     0,     0,
03079        0,    35,    36,     0,   159,    38,     0,    40,     0,     0,
03080        0,   147,   160,   161,     0,     0,     0,     0,     0,     0,
03081        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03082        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03083        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03084        0,   148,    50,    51,    52,    53,    54,    55,    56,    57,
03085       58,    59,    60,    61,    62,    63,   142,   143,     0,     0,
03086        0,     0,   144,     0,     0,     0,     0,     0,     0,     0,
03087        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
03088       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
03089       28,    29,   145,   146,     0,     0,    33,     0,     0,     0,
03090       35,    36,     0,     0,     0,     0,    40,     0,     0,     0,
03091      147,   160,     0,     0,     0,     0,     0,     0,     0,     0,
03092        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03093        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03094        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03095      148,    50,    51,    52,    53,    54,    55,    56,    57,    58,
03096       59,    60,    61,    62,    63,   142,   143,     0,     0,     0,
03097        0,   144,   194,     0,     0,     0,     0,     0,     0,     8,
03098        9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
03099       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
03100       29,   145,   146,     0,     0,    33,     0,     0,     0,    35,
03101       36,     0,     0,     0,     0,    40,     0,     0,     0,   147,
03102        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03103        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03104        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03105        0,     0,     0,     0,     0,     0,     0,     0,     0,   148,
03106       50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
03107       60,    61,    62,    63,     4,     5,     0,     0,     0,     0,
03108      144,     0,     0,     0,     0,     0,     0,     0,     8,     9,
03109       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
03110       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
03111       30,    31,     0,     0,    33,     0,     0,     0,    35,    36,
03112        0,     0,     0,     0,    40,     0,     0,     0,   147,     0,
03113        0,   231,     0,     0,     0,     0,     0,     0,     0,     0,
03114        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03115        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03116        0,     0,     0,     0,     0,     0,     0,     0,   148,    50,
03117       51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
03118       61,    62,    63,   142,   143,     0,     0,     0,     0,   144,
03119      295,     0,     0,     0,     0,     0,     0,     8,     9,    10,
03120       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
03121       21,    22,    23,    24,    25,    26,    27,    28,    29,   145,
03122      146,     0,     0,    33,     0,     0,     0,    35,    36,     0,
03123        0,     0,     0,    40,     0,     0,     0,   147,     0,     0,
03124        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03125        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03126        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03127        0,     0,     0,     0,     0,     0,     0,   148,    50,    51,
03128       52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
03129       62,    63,   142,   143,     0,     0,     0,     0,   144,     0,
03130        0,     0,     0,     0,     0,     0,     8,     9,    10,    11,
03131       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03132       22,    23,    24,    25,    26,    27,    28,    29,   145,   146,
03133        0,     0,    33,     0,     0,     0,    35,    36,     0,     0,
03134        0,     0,    40,     0,     0,     0,   147,     0,     0,     0,
03135        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03136        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03137        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03138        0,     0,     0,     0,     0,     0,   148,    50,    51,    52,
03139       53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
03140       63,   142,   143,     0,     0,     0,     0,   144,     0,     0,
03141        0,     0,     0,     0,     0,     8,     9,    10,    11,    12,
03142       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
03143       23,    24,    25,    26,    27,    28,    29,   145,   146,     0,
03144        0,     0,     0,     0,     0,    35,    36,     0,     0,     0,
03145        0,    40,     0,     0,     0,   147,     0,     0,     0,     0,
03146        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03147        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03148        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03149        0,     0,     0,     0,     0,   148,    50,    51,    52,    53,
03150       54,    55,    56,    57,    58,    59,    60,    61,    62,    63,
03151      142,   143,     0,     0,     0,     0,   279,     0,     0,     0,
03152        0,     0,     0,     0,     8,     9,    10,    11,    12,    13,
03153       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
03154       24,    25,    26,    27,   280,   281,   145,   146,     0,     0,
03155        0,     0,     0,     0,    35,    36,     0,     0,     0,     0,
03156        0,     0,     0,     0,   282,     0,     0,     0,     0,     0,
03157        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03158        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03159        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03160        0,     0,     0,     0,   283,   284,   285,    52,    53,    54,
03161       55,    56,    57,    58,    59,    60,    61,    62,    63,   529,
03162        0,     0,     0,     0,   279,     0,     0,     0,     0,     0,
03163        0,     0,     8,     9,    10,    11,    12,    13,    14,    15,
03164       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03165       26,    27,   280,   281,   246,     0,     0,     0,     0,     0,
03166        0,     0,    35,    36,     0,     0,     0,     0,   530,     0,
03167        0,     0,   282,     0,     0,     0,     0,     0,     0,     0,
03168        0,     0,   247,   248,     0,     0,     0,     0,     0,     0,
03169        0,   249,     0,     0,     0,     0,     0,     0,     0,     0,
03170        0,     0,   250,     0,     0,     0,     0,     0,     0,     0,
03171        0,     0,   283,   284,   285,    52,    53,    54,    55,    56,
03172       57,    58,    59,    60,    61,    62,    63,     0,     0,   318,
03173        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03174      251,   252,   253,   254,   255,   123,   124,   125,   126,   127,
03175      128,   129,   130,   131,   132,   133,   134,   319,   320,   318,
03176        0,     0,     0,     0,     0,     0,   249,     0,     0,     0,
03177        0,     0,     0,     0,     0,     0,     0,   321,     0,     0,
03178        0,     0,     0,     0,     0,     0,     0,   319,   320,     0,
03179        0,     0,     0,     0,     0,     0,   249,     0,     0,     0,
03180        0,     0,     0,     0,     0,     0,     0,   321,     0,     0,
03181        0,     0,     0,     0,     0,   251,   252,   322,   323,   324,
03182      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
03183      133,   134,     0,     0,   246,     0,     0,     0,     0,     0,
03184        0,     0,     0,     0,     0,     0,     0,   322,   323,   324,
03185      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
03186      133,   134,   247,   248,   116,     0,     0,     0,     0,     0,
03187        0,   249,     0,     0,     0,     0,     0,     0,     0,     0,
03188        0,     0,   250,     0,     0,     0,     0,     0,     0,   318,
03189        0,     0,   117,   118,     0,     0,     0,     0,     0,     0,
03190        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03191        0,     0,   119,     0,     0,     0,     0,   319,   320,     0,
03192        0,     0,   253,   254,   255,   123,   124,   125,   126,   127,
03193      128,   129,   130,   131,   132,   133,   134,   321,     0,     0,
03194        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03195        0,     0,   120,   121,   122,   123,   124,   125,   126,   127,
03196      128,   129,   130,   131,   132,   133,   134,     0,     0,     0,
03197        0,     0,     0,     0,     0,     0,     0,   322,   323,   324,
03198      123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
03199      133,   134,   365,   366,     0,     0,     0,     0,     0,   367,
03200      368,   369,   370,   371,   372,   373,   374,   375,   376,   377,
03201      378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
03202      388,   389,   390,     0,     0,     0,     0,     0,     0,     0,
03203        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03204        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03205        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
03206        0,     0,     0,     0,     0,   391,     0,     0,     0,   392,
03207      393,     0,   394,   395,   396,   397,   398,   399,   400,   401,
03208      402,   403,   404,   405,     0,   406
03209 };
03210 
03211 static const yytype_int16 yycheck[] =
03212 {
03213        4,     5,    37,   149,     3,   278,   256,    90,    92,   300,
03214       43,   272,     4,     5,   413,    96,    97,    98,    99,   105,
03215       92,   294,    94,   684,    94,   526,    30,    31,   533,   616,
03216      757,   277,   758,    43,     3,    34,   623,   298,    30,    31,
03217      310,   802,   274,   289,   226,   521,   736,   293,     5,     6,
03218        7,   967,     0,   151,    44,   892,   288,   234,   156,    44,
03219      292,   593,   308,    44,     5,     6,     7,    94,    37,   535,
03220      302,   317,    94,    42,   951,   307,   139,   135,   176,   620,
03221       94,   139,    94,    43,   316,    45,   263,     5,     6,     7,
03222        9,   135,   190,   843,    94,    94,     6,  1013,   102,    94,
03223      198,    60,     5,     6,     7,    50,   766,     5,     6,     7,
03224      256,   948,     5,     6,     7,    60,    94,   139,    37,    38,
03225      134,   871,    94,   135,   159,   785,  1003,    37,    38,   759,
03226      760,   892,   364,   102,    93,   168,    46,   797,    57,   139,
03227      135,  1018,   240,   619,   134,    94,   232,   233,   181,   182,
03228      142,   143,   235,   145,   146,   236,   237,   147,   168,   691,
03229      150,   139,   147,   135,   630,   150,   147,   139,   350,   150,
03230      197,   181,   182,   135,    43,   139,   926,   263,    97,    98,
03231       99,   138,    92,   143,   135,   134,   135,   948,   135,   135,
03232      139,   692,    94,   103,    43,   193,   200,   138,   197,   135,
03233      204,   205,    94,   207,   208,   209,   210,   211,   212,   213,
03234      214,   215,   216,   217,   218,   219,   220,    94,   137,    94,
03235      138,   135,   226,   883,   756,   766,    94,   225,   232,   233,
03236      234,   732,   134,    94,   238,   138,   916,   769,   271,   272,
03237      138,    94,   134,   420,   785,   138,     3,     4,   135,   159,
03238      837,   161,   256,   163,   287,   945,   797,   135,   135,   263,
03239      135,   271,   272,   261,    94,   298,   134,   537,   134,    94,
03240      996,   137,   134,     9,   135,    94,   781,   287,   139,   135,
03241      142,   134,    94,    40,   194,  1012,   290,   256,   298,   969,
03242      970,   135,   972,   135,   881,   975,   828,   153,   885,   168,
03243      134,    37,    38,   272,   134,   135,   135,   135,   142,   139,
03244      135,   315,   181,   182,   139,   134,   135,    53,   134,    55,
03245      139,    57,   326,   327,   328,   134,   142,   331,   137,   298,
03246      139,   135,   141,   135,   134,    46,   135,   137,   843,   600,
03247      134,   141,   883,   137,   135,   139,   350,   141,   594,  1010,
03248      135,   135,     9,   357,   135,   135,     5,     6,     7,   135,
03249        9,    97,    98,    99,   865,   275,   627,   277,   139,   601,
03250      602,   603,   604,   605,   906,   555,    94,   137,   139,   289,
03251       37,    38,    50,   293,   135,   295,   484,   485,    37,    38,
03252       94,   140,   490,   491,    94,    94,   494,    94,   308,     9,
03253       57,   800,   271,   272,    94,   134,   134,   317,    57,   137,
03254      911,   139,   134,   141,   134,   134,   420,     9,   287,    94,
03255       94,    94,   143,   924,    94,   141,   699,    37,    38,   298,
03256      153,   435,   137,   706,    44,    71,    72,   154,   134,   137,
03257       97,    98,    99,   734,   136,    37,    38,    57,    97,    98,
03258       99,   724,   134,   142,   700,     9,   142,    11,    12,    13,
03259       14,    15,    16,   643,   644,    57,   142,   647,   648,   649,
03260      650,   651,   652,   653,   654,   655,   656,   142,   142,   512,
03261      142,   142,   142,    37,    38,    95,    96,    97,    98,    99,
03262      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
03263      110,   111,   512,    57,   142,    97,    98,    99,   144,   145,
03264      142,   147,   148,   149,   150,   151,   152,   521,   142,   142,
03265      142,   134,   526,   142,   137,   135,   139,   136,   141,   134,
03266      534,   535,   137,   136,   139,   142,   141,   147,   142,   134,
03267      150,   134,   153,    97,    98,    99,   134,   134,   134,   137,
03268      137,   139,   139,   141,   141,   588,   134,   153,    94,   136,
03269      136,   135,   742,    94,   568,   140,   137,   600,   140,   142,
03270      137,   140,   138,   143,   142,   608,   609,   610,   588,   140,
03271      137,   136,    94,   844,   140,    52,   136,   620,   140,   142,
03272      600,   138,   140,   142,   627,   136,   142,   135,   608,   609,
03273      610,    16,    16,   154,   141,   135,   138,   142,   136,   154,
03274      620,   153,   138,   874,   153,   619,   620,   627,   136,   142,
03275      139,    10,   136,   140,   137,   136,   630,   142,   878,   136,
03276      136,   136,   136,   136,   136,   136,   136,   136,    11,    11,
03277      136,   135,   135,   512,   142,   142,   136,   142,   137,   141,
03278      137,   142,   136,   136,   136,   135,   689,    50,   135,   135,
03279      135,   135,   912,   135,   135,   135,   154,   135,    43,   135,
03280      135,   704,   922,   135,   135,   135,   140,   909,   136,   689,
03281      136,   136,   136,   136,   594,   142,   136,   134,   692,   134,
03282      136,   135,   919,   134,   704,   138,   138,   781,   136,   136,
03283      134,   136,   704,   781,   781,   734,   908,   272,   833,   781,
03284      781,   781,   887,   233,  1010,   893,   827,   544,   106,   951,
03285      107,   902,   781,    -1,   757,   758,   759,   760,   732,   639,
03286       -1,   600,   982,   766,    -1,    -1,    -1,   835,    -1,   608,
03287      609,   610,   228,    -1,    -1,    -1,    -1,   757,   758,   759,
03288      760,   983,   785,    -1,    -1,    -1,   766,    -1,   627,    -1,
03289       -1,    -1,   766,    -1,   797,    -1,    -1,   913,   249,    -1,
03290     1002,  1003,    -1,   843,    -1,   785,    -1,    -1,    -1,    -1,
03291       -1,   785,   781,   866,    -1,   868,  1018,   797,    -1,    -1,
03292      700,   872,   873,   797,   875,    -1,    -1,    -1,   802,   871,
03293      833,   871,    -1,    -1,    -1,    -1,   892,    -1,    -1,   844,
03294       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03295      689,   731,    -1,   833,    -1,    -1,    -1,    -1,    -1,   739,
03296      928,    -1,    -1,    -1,    -1,   704,    -1,    -1,    -1,   920,
03297      921,    -1,    -1,    -1,   843,    -1,    -1,    -1,    -1,   932,
03298      883,    -1,   933,   934,    -1,    -1,    -1,     9,    -1,    -1,
03299       -1,   865,    -1,    -1,    -1,    -1,    -1,    -1,   966,    -1,
03300       -1,    -1,   871,   883,   878,    -1,    -1,    -1,    -1,   883,
03301       -1,    -1,    -1,    -1,    -1,    37,    38,    -1,   892,    -1,
03302       -1,    -1,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03303       -1,    -1,    -1,    -1,    -1,    57,    -1,   911,   912,    -1,
03304      914,   915,   916,    -1,    -1,    -1,    -1,    -1,   922,    -1,
03305      924,    -1,   914,   915,   916,    -1,    -1,   926,   838,    -1,
03306       -1,    -1,    -1,    -1,   844,    -1,    -1,    -1,    -1,    -1,
03307       -1,    -1,    -1,    -1,   948,    97,    98,    99,   100,   101,
03308      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
03309       -1,    -1,    -1,   996,   833,    -1,    -1,    -1,    -1,   973,
03310      974,   975,    -1,    -1,    -1,    -1,    -1,    -1,   982,  1012,
03311       -1,    -1,    -1,    -1,    -1,    -1,   996,    -1,    -1,    -1,
03312       -1,    -1,    -1,    -1,    -1,   147,    -1,    -1,   150,    -1,
03313       -1,    -1,  1012,     3,     4,     5,     6,     7,     8,     9,
03314       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
03315       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
03316       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
03317       40,    41,    42,    43,    44,    45,    46,    47,    48,    -1,
03318       50,    -1,    52,    53,    54,    55,    56,    57,    58,    59,
03319       60,    -1,    62,    63,    -1,    65,    66,    67,    68,    69,
03320       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
03321       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
03322       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
03323      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
03324      110,   111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03325       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03326       -1,    -1,    -1,    -1,   134,   135,    -1,   137,   138,   139,
03327      140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
03328      150,   151,   152,   153,    -1,   155,   156,     3,     4,     5,
03329        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
03330       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03331       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
03332       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
03333       46,    47,    48,    -1,    50,    -1,    52,    53,    54,    55,
03334       56,    57,    58,    59,    60,    -1,    62,    63,    -1,    65,
03335       66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
03336       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
03337       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
03338       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03339      106,   107,   108,   109,   110,   111,    -1,    -1,    -1,    -1,
03340       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03341       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   134,   135,
03342      136,   137,    -1,   139,   140,   141,   142,   143,   144,   145,
03343      146,   147,   148,   149,   150,   151,   152,   153,    -1,   155,
03344      156,     3,     4,     5,     6,     7,     8,     9,    10,    11,
03345       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03346       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
03347       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
03348       42,    43,    44,    45,    46,    47,    48,    -1,    50,    -1,
03349       52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
03350       62,    63,    -1,    65,    66,    67,    68,    69,    70,    71,
03351       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
03352       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
03353       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
03354      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
03355       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03356       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03357       -1,    -1,   134,   135,    -1,   137,   138,   139,   140,   141,
03358      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
03359      152,   153,    -1,   155,   156,     3,     4,     5,     6,     7,
03360        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
03361       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
03362       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
03363       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
03364       48,    -1,    50,    -1,    52,    53,    54,    55,    56,    57,
03365       58,    59,    60,    -1,    62,    63,    -1,    65,    66,    67,
03366       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
03367       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
03368       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
03369       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
03370      108,   109,   110,   111,    -1,    -1,    -1,    -1,    -1,    -1,
03371       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03372       -1,    -1,    -1,    -1,    -1,    -1,   134,   135,    -1,   137,
03373      138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
03374      148,   149,   150,   151,   152,   153,    -1,   155,   156,     3,
03375        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
03376       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
03377       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
03378       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
03379       44,    45,    46,    47,    48,    -1,    50,    -1,    52,    53,
03380       54,    55,    56,    57,    58,    59,    60,    -1,    62,    63,
03381       -1,    65,    66,    67,    68,    69,    70,    71,    72,    73,
03382       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
03383       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
03384       94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
03385      104,   105,   106,   107,   108,   109,   110,   111,    -1,    -1,
03386       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03387       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03388      134,   135,   136,   137,    -1,   139,   140,   141,   142,   143,
03389      144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
03390       -1,   155,   156,     3,     4,     5,     6,     7,     8,     9,
03391       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
03392       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
03393       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
03394       40,    41,    42,    43,    44,    45,    46,    47,    48,    -1,
03395       50,    -1,    52,    53,    54,    55,    56,    57,    58,    59,
03396       60,    -1,    62,    63,    -1,    65,    66,    67,    68,    69,
03397       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
03398       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
03399       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
03400      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
03401      110,   111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03402       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03403       -1,    -1,    -1,    -1,   134,   135,   136,   137,    -1,   139,
03404      140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
03405      150,   151,   152,   153,    -1,   155,   156,     3,     4,     5,
03406        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
03407       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03408       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
03409       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
03410       46,    47,    48,    -1,    50,    -1,    52,    53,    54,    55,
03411       56,    57,    58,    59,    60,    -1,    62,    63,    -1,    65,
03412       66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
03413       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
03414       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
03415       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03416      106,   107,   108,   109,   110,   111,    -1,    -1,    -1,    -1,
03417       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03418       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   134,   135,
03419       -1,   137,   138,   139,   140,   141,   142,   143,   144,   145,
03420      146,   147,   148,   149,   150,   151,   152,   153,    -1,   155,
03421      156,     3,     4,     5,     6,     7,     8,     9,    10,    11,
03422       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03423       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
03424       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
03425       42,    43,    44,    45,    46,    47,    48,    -1,    50,    -1,
03426       52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
03427       62,    63,    -1,    65,    66,    67,    68,    69,    70,    71,
03428       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
03429       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
03430       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
03431      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
03432       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03433       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03434       -1,    -1,   134,   135,   136,   137,    -1,   139,   140,   141,
03435      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
03436      152,   153,    -1,   155,   156,     3,     4,     5,     6,     7,
03437        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
03438       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
03439       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
03440       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
03441       48,    -1,    50,    -1,    52,    53,    54,    55,    56,    57,
03442       58,    59,    60,    -1,    62,    63,    -1,    65,    66,    67,
03443       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
03444       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
03445       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
03446       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
03447      108,   109,   110,   111,    -1,    -1,    -1,    -1,    -1,    -1,
03448       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03449       -1,    -1,    -1,    -1,    -1,    -1,   134,   135,   136,   137,
03450       -1,   139,   140,   141,   142,   143,   144,   145,   146,   147,
03451      148,   149,   150,   151,   152,   153,    -1,   155,   156,     3,
03452        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
03453       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
03454       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
03455       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
03456       44,    45,    46,    47,    48,    -1,    50,    -1,    52,    53,
03457       54,    55,    56,    57,    58,    59,    60,    -1,    62,    63,
03458       -1,    65,    66,    67,    68,    69,    70,    71,    72,    73,
03459       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
03460       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
03461       94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
03462      104,   105,   106,   107,   108,   109,   110,   111,    -1,    -1,
03463       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03464       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03465      134,   135,   136,   137,    -1,   139,   140,   141,   142,   143,
03466      144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
03467       -1,   155,   156,     3,     4,     5,     6,     7,     8,     9,
03468       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
03469       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
03470       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
03471       40,    41,    42,    43,    44,    45,    46,    47,    48,    -1,
03472       50,    -1,    52,    53,    54,    55,    56,    57,    58,    59,
03473       60,    -1,    62,    63,    -1,    65,    66,    67,    68,    69,
03474       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
03475       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
03476       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
03477      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
03478      110,   111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03479       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03480       -1,    -1,    -1,    -1,   134,   135,    -1,   137,   138,   139,
03481      140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
03482      150,   151,   152,   153,    -1,   155,   156,     3,     4,     5,
03483        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
03484       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03485       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
03486       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
03487       46,    47,    48,    -1,    50,    -1,    52,    53,    54,    55,
03488       56,    57,    58,    59,    60,    -1,    62,    63,    -1,    65,
03489       66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
03490       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
03491       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
03492       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03493      106,   107,   108,   109,   110,   111,    -1,    -1,    -1,    -1,
03494       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03495       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   134,   135,
03496       -1,   137,    -1,   139,   140,   141,   142,   143,   144,   145,
03497      146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
03498      156,     3,     4,     5,     6,     7,     8,     9,    10,    11,
03499       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03500       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
03501       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
03502       42,    43,    44,    45,    46,    47,    48,    -1,    50,    -1,
03503       52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
03504       62,    63,    -1,    65,    66,    67,    68,    69,    70,    71,
03505       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
03506       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
03507       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
03508      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
03509       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03510       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03511       -1,    -1,   134,   135,   136,   137,    -1,   139,   140,   141,
03512      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
03513      152,   153,    -1,   155,   156,     3,     4,     5,     6,     7,
03514        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
03515       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
03516       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
03517       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
03518       48,    -1,    50,    -1,    52,    53,    54,    55,    56,    57,
03519       58,    59,    60,    -1,    62,    63,    -1,    65,    66,    67,
03520       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
03521       78,    79,    80,    81,    82,    83,    84,    85,    86,    87,
03522       88,    89,    90,    91,    92,    93,    94,    95,    96,    97,
03523       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
03524      108,   109,   110,   111,    -1,    -1,    -1,    -1,    -1,    -1,
03525       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03526       -1,    -1,    -1,    -1,    -1,    -1,   134,   135,   136,   137,
03527       -1,   139,   140,   141,   142,   143,   144,   145,   146,   147,
03528      148,   149,   150,   151,   152,   153,    -1,   155,   156,     3,
03529        4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
03530       14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
03531       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
03532       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
03533       44,    45,    46,    47,    48,    -1,    50,    -1,    52,    53,
03534       54,    55,    56,    57,    58,    59,    60,    -1,    62,    63,
03535       -1,    65,    66,    67,    68,    69,    70,    71,    72,    73,
03536       74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
03537       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
03538       94,    95,    96,    97,    98,    99,   100,   101,   102,   103,
03539      104,   105,   106,   107,   108,   109,   110,   111,    -1,    -1,
03540       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03541       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03542      134,   135,    -1,   137,   138,   139,   140,   141,   142,   143,
03543      144,   145,   146,   147,   148,   149,   150,   151,   152,   153,
03544       -1,   155,   156,     3,     4,     5,     6,     7,     8,     9,
03545       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
03546       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
03547       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
03548       40,    41,    42,    43,    44,    45,    46,    47,    48,    -1,
03549       50,    -1,    52,    53,    54,    55,    56,    57,    58,    59,
03550       60,    -1,    62,    63,    -1,    65,    66,    67,    68,    69,
03551       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
03552       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
03553       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
03554      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
03555      110,   111,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03556       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03557       -1,    -1,    -1,    -1,    -1,   135,   136,   137,    -1,   139,
03558      140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
03559      150,   151,   152,   153,    -1,   155,   156,     3,     4,     5,
03560        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
03561       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03562       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
03563       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
03564       46,    47,    48,    -1,    50,    -1,    52,    53,    54,    55,
03565       56,    57,    58,    59,    60,    -1,    62,    63,    -1,    65,
03566       66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
03567       76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
03568       86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
03569       96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03570      106,   107,   108,   109,   110,   111,    -1,    -1,    -1,    -1,
03571       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03572       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   134,   135,
03573       -1,   137,    -1,   139,   140,   141,   142,   143,   144,   145,
03574      146,   147,   148,   149,   150,   151,   152,   153,    -1,   155,
03575      156,     3,     4,     5,     6,     7,     8,     9,    10,    11,
03576       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
03577       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
03578       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
03579       42,    43,    44,    45,    46,    47,    48,    -1,    50,    -1,
03580       52,    53,    54,    55,    56,    57,    58,    59,    60,    -1,
03581       62,    63,    -1,    65,    66,    67,    68,    69,    70,    71,
03582       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
03583       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
03584       92,    93,    94,    95,    96,    97,    98,    99,   100,   101,
03585      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
03586       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03587       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03588       -1,    -1,   134,   135,    -1,   137,    -1,   139,   140,   141,
03589      142,   143,   144,   145,   146,   147,   148,   149,   150,   151,
03590      152,   153,    -1,   155,   156,     3,     4,    -1,    -1,    -1,
03591        8,     9,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    17,
03592       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
03593       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
03594       38,    39,    40,    41,    -1,    43,    -1,    -1,    46,    47,
03595       48,    49,    50,    51,    52,    53,    54,    -1,    56,    57,
03596       58,    59,    60,    61,    -1,    -1,    64,    -1,    -1,    -1,
03597       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03598       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03599       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,
03600       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
03601      108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
03602      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
03603      128,   129,   130,   131,   132,   133,   134,     3,     4,    -1,
03604       -1,    -1,     8,     9,    -1,    -1,    -1,    -1,   146,    -1,
03605       -1,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03606       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
03607       36,    37,    38,    39,    40,    -1,    -1,    43,    -1,    -1,
03608       46,    47,    48,    -1,    50,    51,    52,    53,    -1,    -1,
03609       -1,    57,    58,    59,    -1,    -1,    -1,    -1,    64,    -1,
03610       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03611       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03612       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03613       -1,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03614      106,   107,   108,   109,   110,   111,    -1,    -1,    -1,    -1,
03615       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03616       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,    -1,
03617       -1,    -1,     8,     9,    -1,    -1,    -1,    -1,    -1,    -1,
03618      146,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03619       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
03620       36,    37,    38,    39,    40,    -1,    -1,    43,    -1,    -1,
03621       46,    47,    48,    -1,    50,    51,    -1,    53,    -1,    -1,
03622       -1,    57,    58,    59,    -1,    -1,    -1,    -1,    64,    -1,
03623       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03624       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03625       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03626       -1,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03627      106,   107,   108,   109,   110,   111,    -1,    -1,    -1,    -1,
03628       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03629       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,    -1,
03630       -1,    -1,     8,     9,    -1,    -1,    -1,    -1,    -1,    -1,
03631      146,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03632       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
03633       36,    37,    38,    39,    40,    -1,    -1,    43,    -1,    -1,
03634       -1,    47,    48,    -1,    50,    51,    -1,    53,    -1,    -1,
03635       -1,    57,    58,    59,    -1,    -1,    -1,    -1,    64,    -1,
03636       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03637       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03638       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03639       -1,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03640      106,   107,   108,   109,   110,   111,    -1,    -1,    -1,    -1,
03641       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03642       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,    -1,
03643       -1,    -1,    -1,     9,    -1,    -1,    -1,    -1,    -1,    -1,
03644      146,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03645       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
03646       36,    37,    38,    39,    40,    -1,    -1,    43,    -1,    -1,
03647       -1,    47,    48,    -1,    50,    51,    -1,    53,    -1,    -1,
03648       -1,    57,    58,    59,    -1,    -1,    -1,    -1,    -1,    -1,
03649       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03650       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03651       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03652       -1,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03653      106,   107,   108,   109,   110,   111,    -1,    -1,    -1,    -1,
03654       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03655       -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,    -1,
03656       -1,    -1,    -1,     9,    -1,    -1,    -1,    -1,    -1,    -1,
03657      146,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03658       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
03659       36,    37,    38,    39,    40,     9,    -1,    43,    -1,    -1,
03660       -1,    47,    48,    -1,    -1,    -1,    -1,    53,    -1,    -1,
03661       -1,    57,    58,    -1,    -1,    -1,    -1,    -1,    64,    -1,
03662       -1,    -1,    -1,    37,    38,    -1,    -1,    -1,    -1,    -1,
03663       44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03664       -1,    -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,    -1,
03665       -1,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03666      106,   107,   108,   109,   110,   111,    -1,    -1,    -1,    -1,
03667        9,    -1,    11,    12,    13,    -1,    15,    16,    -1,    -1,
03668       -1,    95,    96,    97,    98,    99,   100,   101,   102,   103,
03669      104,   105,   106,   107,   108,   109,   110,   111,    37,    38,
03670      146,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03671       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    57,    -1,
03672       -1,    -1,    -1,    -1,    -1,    -1,    -1,     9,    -1,    -1,
03673       -1,    -1,    -1,   147,    -1,    -1,   150,    -1,    -1,    -1,
03674       -1,    -1,    -1,    -1,    -1,     9,    -1,    -1,    -1,    -1,
03675       -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    97,    98,
03676       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03677      109,   110,   111,    37,    38,    57,    -1,    -1,    -1,    -1,
03678       -1,    -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03679       -1,    -1,    -1,    57,    -1,    -1,   135,    -1,    -1,    -1,
03680       -1,    -1,     9,    -1,    -1,   144,   145,   146,    -1,    -1,
03681       -1,    -1,    -1,    -1,    -1,    97,    98,    99,   100,   101,
03682      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
03683       37,    38,     9,    97,    98,    99,   100,   101,   102,   103,
03684      104,   105,   106,   107,   108,   109,   110,   111,    -1,    -1,
03685       57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03686       37,    38,    -1,    -1,   146,    -1,    -1,    -1,    -1,    -1,
03687       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03688       57,    -1,   146,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03689       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03690      107,   108,   109,   110,   111,    -1,    -1,     9,    10,    11,
03691       12,    13,    14,    15,    16,    -1,    -1,    -1,    -1,    -1,
03692       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03693      107,   108,   109,   110,   111,    37,    38,    -1,    -1,   146,
03694       -1,    -1,     9,    10,    11,    12,    13,    14,    15,    16,
03695       -1,    -1,    -1,    -1,    -1,    57,    -1,    -1,     9,    -1,
03696       -1,    -1,    -1,    65,    66,    67,    68,    -1,    -1,   146,
03697       37,    38,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03698       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    -1,
03699       57,    -1,    -1,    -1,    -1,    97,    98,    99,    65,    66,
03700       67,    68,    -1,    -1,    -1,    -1,    57,    -1,    -1,    -1,
03701       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03702       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03703       97,    98,    99,   135,    -1,   137,    -1,    -1,    -1,    -1,
03704       -1,    -1,   144,   145,    95,    96,    97,    98,    99,   100,
03705      101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
03706      111,    -1,    -1,    -1,    -1,     3,     4,    -1,   135,    -1,
03707       -1,     9,    -1,    -1,    -1,    -1,    -1,   144,   145,    17,
03708       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
03709       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
03710       38,    39,    40,    -1,    -1,    43,    -1,    -1,    -1,    47,
03711       48,    -1,    -1,    -1,    -1,    53,    -1,    -1,    -1,    57,
03712       -1,    -1,    -1,    -1,    -1,    -1,     9,    -1,    -1,    -1,
03713       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03714       -1,    -1,    -1,    -1,    -1,    -1,    -1,     9,    -1,    -1,
03715       -1,    -1,    -1,    -1,    37,    38,    -1,    -1,    -1,    97,
03716       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
03717      108,   109,   110,   111,    57,    37,    38,    -1,    -1,    -1,
03718       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03719       -1,    -1,    -1,    -1,    -1,    57,    -1,    -1,    -1,   137,
03720       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03721       -1,    -1,    -1,    -1,    97,    98,    99,   100,   101,   102,
03722      103,   104,   105,   106,   107,   108,   109,   110,   111,    -1,
03723       -1,    -1,    -1,    -1,    -1,    97,    98,    99,   100,   101,
03724      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
03725       -1,   134,    -1,    -1,   137,    -1,    -1,    -1,   141,    -1,
03726       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
03727       -1,    -1,   134,     8,     9,   137,    -1,    -1,    -1,   141,
03728       -1,    -1,    17,    18,    19,    20,    21,    22,    23,    24,
03729       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
03730       35,    36,    37,    38,    39,    40,    41,    -1,    43,    -1,
03731       -1,    46,    47,    48,    -1,    50,    51,    52,    53,    54,
03732       55,    56,    57,    58,    59,    60,    61,    -1,    -1,    -1,
03733       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03734       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03735       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03736       -1,    -1,    97,    98,    99,   100,   101,   102,   103,   104,
03737      105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
03738      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
03739      125,   126,   127,   128,   129,   130,   131,   132,     9,   134,
03740       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03741       -1,    -1,    -1,     9,    -1,    -1,    -1,    -1,    -1,    -1,
03742       -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    -1,
03743       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03744       -1,    37,    38,    -1,    -1,    -1,    57,    -1,    -1,    -1,
03745       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03746       -1,    57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03747       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03748       -1,    -1,    -1,    -1,    -1,    -1,    97,    98,    99,   100,
03749      101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
03750      111,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03751      106,   107,   108,   109,   110,   111,     9,    -1,    -1,    -1,
03752       -1,    -1,    -1,    -1,    -1,    -1,   137,    -1,    -1,    -1,
03753       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03754       -1,   137,    -1,    -1,    37,    38,    -1,    -1,    -1,    -1,
03755       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03756       -1,    -1,    -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,
03757       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03758       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03759       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03760       -1,    -1,    95,    96,    97,    98,    99,   100,   101,   102,
03761      103,   104,   105,   106,   107,   108,   109,   110,   111,    -1,
03762       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     3,
03763        4,    -1,    -1,    -1,     8,     9,    -1,    -1,    -1,    -1,
03764       -1,    -1,   135,    17,    18,    19,    20,    21,    22,    23,
03765       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
03766       34,    35,    36,    37,    38,    39,    40,    -1,    -1,    43,
03767       -1,    -1,    46,    47,    48,    -1,    50,    51,    -1,    53,
03768       -1,    -1,    -1,    57,    58,    59,    -1,    -1,    -1,    -1,
03769       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03770       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03771       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03772       -1,    -1,    -1,    97,    98,    99,   100,   101,   102,   103,
03773      104,   105,   106,   107,   108,   109,   110,   111,     3,     4,
03774       -1,    -1,    -1,    -1,     9,    -1,    11,    12,    13,    -1,
03775       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
03776       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
03777       35,    36,    37,    38,    39,    40,    -1,    -1,    43,    -1,
03778       -1,    -1,    47,    48,    -1,    -1,    -1,    -1,    53,    -1,
03779       -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03780       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03781       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03782       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03783       -1,    -1,    97,    98,    99,   100,   101,   102,   103,   104,
03784      105,   106,   107,   108,   109,   110,   111,     3,     4,    -1,
03785       -1,    -1,    -1,     9,    -1,    -1,    -1,    -1,    -1,    -1,
03786       -1,    17,    18,    19,    20,    21,    22,    23,    24,    25,
03787       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
03788       36,    37,    38,    39,    40,    -1,    -1,    43,    -1,    -1,
03789       -1,    47,    48,    -1,    50,    51,    -1,    53,    -1,    -1,
03790       -1,    57,    58,    59,    -1,    -1,    -1,    -1,    -1,    -1,
03791       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03792       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03793       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03794       -1,    97,    98,    99,   100,   101,   102,   103,   104,   105,
03795      106,   107,   108,   109,   110,   111,     3,     4,    -1,    -1,
03796       -1,    -1,     9,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03797       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
03798       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
03799       37,    38,    39,    40,    -1,    -1,    43,    -1,    -1,    -1,
03800       47,    48,    -1,    -1,    -1,    -1,    53,    -1,    -1,    -1,
03801       57,    58,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03802       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03803       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03804       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03805       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03806      107,   108,   109,   110,   111,     3,     4,    -1,    -1,    -1,
03807       -1,     9,    10,    -1,    -1,    -1,    -1,    -1,    -1,    17,
03808       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
03809       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
03810       38,    39,    40,    -1,    -1,    43,    -1,    -1,    -1,    47,
03811       48,    -1,    -1,    -1,    -1,    53,    -1,    -1,    -1,    57,
03812       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03813       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03814       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03815       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,
03816       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
03817      108,   109,   110,   111,     3,     4,    -1,    -1,    -1,    -1,
03818        9,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    17,    18,
03819       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
03820       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
03821       39,    40,    -1,    -1,    43,    -1,    -1,    -1,    47,    48,
03822       -1,    -1,    -1,    -1,    53,    -1,    -1,    -1,    57,    -1,
03823       -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03824       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03825       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03826       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,
03827       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
03828      109,   110,   111,     3,     4,    -1,    -1,    -1,    -1,     9,
03829       10,    -1,    -1,    -1,    -1,    -1,    -1,    17,    18,    19,
03830       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
03831       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
03832       40,    -1,    -1,    43,    -1,    -1,    -1,    47,    48,    -1,
03833       -1,    -1,    -1,    53,    -1,    -1,    -1,    57,    -1,    -1,
03834       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03835       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03836       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03837       -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,    99,
03838      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
03839      110,   111,     3,     4,    -1,    -1,    -1,    -1,     9,    -1,
03840       -1,    -1,    -1,    -1,    -1,    -1,    17,    18,    19,    20,
03841       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
03842       31,    32,    33,    34,    35,    36,    37,    38,    39,    40,
03843       -1,    -1,    43,    -1,    -1,    -1,    47,    48,    -1,    -1,
03844       -1,    -1,    53,    -1,    -1,    -1,    57,    -1,    -1,    -1,
03845       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03846       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03847       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03848       -1,    -1,    -1,    -1,    -1,    -1,    97,    98,    99,   100,
03849      101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
03850      111,     3,     4,    -1,    -1,    -1,    -1,     9,    -1,    -1,
03851       -1,    -1,    -1,    -1,    -1,    17,    18,    19,    20,    21,
03852       22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
03853       32,    33,    34,    35,    36,    37,    38,    39,    40,    -1,
03854       -1,    -1,    -1,    -1,    -1,    47,    48,    -1,    -1,    -1,
03855       -1,    53,    -1,    -1,    -1,    57,    -1,    -1,    -1,    -1,
03856       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03857       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03858       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03859       -1,    -1,    -1,    -1,    -1,    97,    98,    99,   100,   101,
03860      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
03861        3,     4,    -1,    -1,    -1,    -1,     9,    -1,    -1,    -1,
03862       -1,    -1,    -1,    -1,    17,    18,    19,    20,    21,    22,
03863       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
03864       33,    34,    35,    36,    37,    38,    39,    40,    -1,    -1,
03865       -1,    -1,    -1,    -1,    47,    48,    -1,    -1,    -1,    -1,
03866       -1,    -1,    -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,
03867       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03868       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03869       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03870       -1,    -1,    -1,    -1,    97,    98,    99,   100,   101,   102,
03871      103,   104,   105,   106,   107,   108,   109,   110,   111,     4,
03872       -1,    -1,    -1,    -1,     9,    -1,    -1,    -1,    -1,    -1,
03873       -1,    -1,    17,    18,    19,    20,    21,    22,    23,    24,
03874       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
03875       35,    36,    37,    38,     9,    -1,    -1,    -1,    -1,    -1,
03876       -1,    -1,    47,    48,    -1,    -1,    -1,    -1,    53,    -1,
03877       -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03878       -1,    -1,    37,    38,    -1,    -1,    -1,    -1,    -1,    -1,
03879       -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03880       -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03881       -1,    -1,    97,    98,    99,   100,   101,   102,   103,   104,
03882      105,   106,   107,   108,   109,   110,   111,    -1,    -1,     9,
03883       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03884       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
03885      105,   106,   107,   108,   109,   110,   111,    37,    38,     9,
03886       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    -1,
03887       -1,    -1,    -1,    -1,    -1,    -1,    -1,    57,    -1,    -1,
03888       -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,
03889       -1,    -1,    -1,    -1,    -1,    -1,    46,    -1,    -1,    -1,
03890       -1,    -1,    -1,    -1,    -1,    -1,    -1,    57,    -1,    -1,
03891       -1,    -1,    -1,    -1,    -1,    95,    96,    97,    98,    99,
03892      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
03893      110,   111,    -1,    -1,     9,    -1,    -1,    -1,    -1,    -1,
03894       -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,    99,
03895      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
03896      110,   111,    37,    38,     9,    -1,    -1,    -1,    -1,    -1,
03897       -1,    46,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03898       -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,    -1,     9,
03899       -1,    -1,    37,    38,    -1,    -1,    -1,    -1,    -1,    -1,
03900       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03901       -1,    -1,    57,    -1,    -1,    -1,    -1,    37,    38,    -1,
03902       -1,    -1,    97,    98,    99,   100,   101,   102,   103,   104,
03903      105,   106,   107,   108,   109,   110,   111,    57,    -1,    -1,
03904       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03905       -1,    -1,    97,    98,    99,   100,   101,   102,   103,   104,
03906      105,   106,   107,   108,   109,   110,   111,    -1,    -1,    -1,
03907       -1,    -1,    -1,    -1,    -1,    -1,    -1,    97,    98,    99,
03908      100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
03909      110,   111,    62,    63,    -1,    -1,    -1,    -1,    -1,    69,
03910       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
03911       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
03912       90,    91,    92,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03913       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03914       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03915       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
03916       -1,    -1,    -1,    -1,    -1,   135,    -1,    -1,    -1,   139,
03917      140,    -1,   142,   143,   144,   145,   146,   147,   148,   149,
03918      150,   151,   152,   153,    -1,   155
03919 };
03920 
03921 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
03922    symbol of state STATE-NUM.  */
03923 static const yytype_uint16 yystos[] =
03924 {
03925        0,   158,     0,   159,     3,     4,     8,     9,    17,    18,
03926       19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
03927       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
03928       39,    40,    41,    43,    46,    47,    48,    50,    51,    52,
03929       53,    54,    55,    56,    57,    58,    59,    60,    61,    97,
03930       98,    99,   100,   101,   102,   103,   104,   105,   106,   107,
03931      108,   109,   110,   111,   112,   113,   114,   115,   116,   117,
03932      118,   119,   120,   121,   122,   123,   124,   125,   126,   127,
03933      128,   129,   130,   131,   132,   134,   160,   161,   162,   164,
03934      178,   194,   195,   196,   197,   206,   208,   209,   213,   214,
03935      215,   252,   283,   284,   285,   286,   287,   288,   290,   298,
03936      299,   303,   304,   305,   306,   321,     9,    37,    38,    57,
03937       97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
03938      107,   108,   109,   110,   111,   137,   280,   281,   282,   305,
03939      280,   305,     3,     4,     9,    39,    40,    57,    97,   285,
03940      299,   135,   139,   180,   280,   305,   137,   280,   305,    50,
03941       58,    59,   283,   284,   285,   299,   285,   139,   289,     9,
03942       37,    38,    57,    97,    98,    99,   137,   299,     9,    37,
03943       38,    53,    55,    57,    97,    98,    99,   290,   297,   298,
03944      135,   139,    50,    60,    10,   285,   255,   135,   135,   139,
03945      135,   135,   135,   135,   135,   135,   135,   135,   135,   135,
03946      135,   135,   135,   135,   135,   135,   135,   135,   135,   135,
03947      135,    44,   147,   150,   254,   257,   258,   300,   301,   302,
03948      254,    60,   164,   178,   285,   164,   208,   214,   283,   134,
03949      137,   226,   226,   226,   226,   226,     9,    37,    38,    46,
03950       57,    95,    96,    97,    98,    99,   210,   218,   220,   223,
03951      227,   253,   262,   265,   272,   280,   299,   285,   300,   288,
03952      287,    94,    94,   134,   346,   139,   167,   139,   165,     9,
03953       37,    38,    57,    97,    98,    99,   218,    94,   346,   292,
03954      137,   179,   346,   139,   169,    10,   135,   285,    94,   140,
03955      198,   297,   346,   163,   297,   297,   134,   346,   291,   255,
03956      137,   285,   134,   142,   208,   283,   346,   293,     9,    37,
03957       38,    57,    97,    98,    99,   280,   323,   326,   327,   280,
03958      280,   331,   280,   280,   280,   280,   280,   280,   280,   280,
03959      280,   280,   280,   280,   280,   280,   134,   255,   253,   280,
03960      259,   150,   302,   134,   134,   248,   280,   300,   248,   262,
03961      254,   226,   226,   280,   346,    62,    63,    69,    70,    71,
03962       72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
03963       82,    83,    84,    85,    86,    87,    88,    89,    90,    91,
03964       92,   135,   139,   140,   142,   143,   144,   145,   146,   147,
03965      148,   149,   150,   151,   152,   153,   155,   344,   345,   218,
03966      223,   299,   219,   224,   255,   143,   249,   250,   262,   270,
03967      300,   273,   274,   275,   135,   139,    94,   297,     9,    37,
03968       38,    57,    97,    98,    99,   146,   215,   231,   233,   280,
03969      297,   299,     3,     4,     5,     6,     7,     8,     9,    10,
03970       11,    12,    13,    14,    15,    16,    37,    38,    39,    40,
03971       41,    42,    43,    44,    45,    46,    50,    52,    53,    54,
03972       55,    56,    57,    58,    59,    60,    62,    63,    65,    66,
03973       67,    68,    93,    94,    95,    96,    97,    98,    99,   134,
03974      135,   137,   138,   141,   153,   156,   306,   345,   348,   349,
03975      350,   351,   352,    11,    12,    13,    15,    16,   184,   285,
03976      294,   296,   141,   174,   294,   174,   136,   294,   181,   182,
03977      280,   137,   138,   294,   174,   216,   146,   231,   299,     4,
03978       53,   199,   201,   202,   203,   304,   138,   137,   134,   134,
03979      136,   294,   134,   158,   256,   136,   136,   294,   142,   280,
03980      280,   280,   142,   142,   280,   142,   142,   142,   142,   142,
03981      142,   142,   142,   142,   142,   142,   136,   136,   142,   253,
03982      134,   280,   134,   134,   134,   138,   153,   153,   136,   154,
03983      221,    94,    43,    45,   143,   225,   225,   134,   251,   136,
03984      262,   276,   278,   228,   229,   238,   239,   280,   232,   135,
03985       94,   346,   346,   346,   346,   346,   140,   142,     5,     6,
03986        7,   175,   176,   297,   137,   140,   137,   140,   138,   142,
03987      143,   181,   140,   137,   241,   242,   238,    94,   140,   142,
03988      197,   204,   280,   204,   158,   140,   138,   257,   140,   322,
03989      142,   136,   136,   328,   330,   142,   303,   334,   336,   338,
03990      340,   335,   337,   339,   341,   342,   343,   280,   154,   154,
03991      135,    16,    16,    10,    11,    12,    13,    14,    15,    16,
03992       65,    66,    67,    68,   135,   137,   144,   145,   297,   307,
03993      312,   318,   319,   320,   263,   153,   241,   294,   135,   141,
03994      235,   234,   146,   231,   136,   136,   136,   138,   154,   168,
03995      295,   297,   297,   297,   142,   171,   166,   171,   181,     9,
03996       57,    97,   135,   144,   145,   146,   183,   184,   185,   189,
03997      280,   290,   298,   138,   170,   171,   136,    60,    93,   243,
03998      245,   246,   146,   231,   200,   204,   205,   138,   285,   324,
03999      303,   303,   332,   136,   303,   303,   303,   303,   303,   303,
04000      303,   303,   303,   303,   142,   309,   222,   315,   308,   314,
04001      313,   139,    10,   135,   267,   274,   277,   136,   140,   240,
04002      237,   297,   241,   238,   174,   294,   175,     5,     6,     7,
04003      138,   172,   177,   174,   138,   188,    71,    72,   144,   145,
04004      147,   148,   149,   150,   151,   152,   190,   186,   174,   138,
04005      217,   142,   285,   238,   199,   249,   136,   285,   329,   136,
04006      303,   136,   136,   136,   136,   136,   136,   136,   136,   142,
04007      142,   136,   241,   312,   307,   320,   320,   316,   268,   185,
04008      279,   135,   241,   142,   236,   135,   136,   137,     8,     9,
04009       37,    38,    41,    49,    50,    57,    61,    64,    97,    98,
04010       99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
04011      109,   110,   111,   133,   134,   146,   164,   173,   178,   194,
04012      196,   197,   207,   211,   212,   214,   231,   252,   283,   321,
04013      141,   137,   185,   187,   185,   137,   225,   244,    95,    96,
04014      135,   260,   264,   271,   272,   325,   142,   333,    11,    11,
04015      136,   136,   310,   286,   241,   154,   230,   136,   237,   346,
04016      171,   146,   283,   285,     3,     4,    40,   191,   192,   197,
04017      211,   214,   283,    64,   146,   231,   135,    50,   135,   238,
04018      254,   254,   164,   211,   214,   226,   226,   231,   226,   223,
04019      171,   136,   185,   171,   243,   247,   260,   269,   300,   273,
04020      136,   347,   136,   136,   136,   142,   309,   140,   136,   241,
04021      236,   136,   138,   238,   223,   134,   137,   141,   193,   280,
04022      280,   193,   280,     3,     4,    40,   192,   226,   226,   238,
04023        8,   211,   283,   346,   134,   134,   254,   226,   226,   138,
04024      138,   249,   136,   260,   136,   349,   311,   138,   135,    43,
04025      266,   136,   346,   347,   193,   193,   193,   136,   136,   134,
04026      261,   307,   317,   138,   134,   134,   267,   312,   347,   136,
04027      134
04028 };
04029 
04030 #define yyerrok                (yyerrstatus = 0)
04031 #define yyclearin        (yychar = YYEMPTY)
04032 #define YYEMPTY                (-2)
04033 #define YYEOF                0
04034 
04035 #define YYACCEPT        goto yyacceptlab
04036 #define YYABORT                goto yyabortlab
04037 #define YYERROR                goto yyerrorlab
04038 
04039 
04040 /* Like YYERROR except do call yyerror.  This remains here temporarily
04041    to ease the transition to the new meaning of YYERROR, for GCC.
04042    Once GCC version 2 has supplanted version 1, this can go.  */
04043 
04044 #define YYFAIL                goto yyerrlab
04045 
04046 #define YYRECOVERING()  (!!yyerrstatus)
04047 
04048 #define YYBACKUP(Token, Value)                                        \
04049 do                                                                \
04050   if (yychar == YYEMPTY && yylen == 1)                                \
04051     {                                                                \
04052       yychar = (Token);                                                \
04053       yylval = (Value);                                                \
04054       yytoken = YYTRANSLATE (yychar);                                \
04055       YYPOPSTACK (1);                                                \
04056       goto yybackup;                                                \
04057     }                                                                \
04058   else                                                                \
04059     {                                                                \
04060       yyerror (YY_("syntax error: cannot back up")); \
04061       YYERROR;                                                        \
04062     }                                                                \
04063 while (YYID (0))
04064 
04065 
04066 #define YYTERROR        1
04067 #define YYERRCODE        256
04068 
04069 
04070 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
04071    If N is 0, then set CURRENT to the empty location which ends
04072    the previous symbol: RHS[0] (always defined).  */
04073 
04074 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
04075 #ifndef YYLLOC_DEFAULT
04076 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
04077     do                                                                        \
04078       if (YYID (N))                                                    \
04079         {                                                                \
04080           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
04081           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;        \
04082           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;                \
04083           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;        \
04084         }                                                                \
04085       else                                                                \
04086         {                                                                \
04087           (Current).first_line   = (Current).last_line   =                \
04088             YYRHSLOC (Rhs, 0).last_line;                                \
04089           (Current).first_column = (Current).last_column =                \
04090             YYRHSLOC (Rhs, 0).last_column;                                \
04091         }                                                                \
04092     while (YYID (0))
04093 #endif
04094 
04095 
04096 /* YY_LOCATION_PRINT -- Print the location on the stream.
04097    This macro was not mandated originally: define only if we know
04098    we won't break user code: when these are the locations we know.  */
04099 
04100 #ifndef YY_LOCATION_PRINT
04101 # if YYLTYPE_IS_TRIVIAL
04102 #  define YY_LOCATION_PRINT(File, Loc)                        \
04103      fprintf (File, "%d.%d-%d.%d",                        \
04104               (Loc).first_line, (Loc).first_column,        \
04105               (Loc).last_line,  (Loc).last_column)
04106 # else
04107 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
04108 # endif
04109 #endif
04110 
04111 
04112 /* YYLEX -- calling `yylex' with the right arguments.  */
04113 
04114 #ifdef YYLEX_PARAM
04115 # define YYLEX yylex (YYLEX_PARAM)
04116 #else
04117 # define YYLEX yylex ()
04118 #endif
04119 
04120 /* Enable debugging if requested.  */
04121 #if YYDEBUG
04122 
04123 # ifndef YYFPRINTF
04124 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
04125 #  define YYFPRINTF fprintf
04126 # endif
04127 
04128 # define YYDPRINTF(Args)                        \
04129 do {                                                \
04130   if (yydebug)                                        \
04131     YYFPRINTF Args;                                \
04132 } while (YYID (0))
04133 
04134 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                          \
04135 do {                                                                          \
04136   if (yydebug)                                                                  \
04137     {                                                                          \
04138       YYFPRINTF (stderr, "%s ", Title);                                          \
04139       yy_symbol_print (stderr,                                                  \
04140                   Type, Value); \
04141       YYFPRINTF (stderr, "\n");                                                  \
04142     }                                                                          \
04143 } while (YYID (0))
04144 
04145 
04146 /*--------------------------------.
04147 | Print this symbol on YYOUTPUT.  |
04148 `--------------------------------*/
04149 
04150 /*ARGSUSED*/
04151 #if (defined __STDC__ || defined __C99__FUNC__ \
04152      || defined __cplusplus || defined _MSC_VER)
04153 static void
04154 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
04155 #else
04156 static void
04157 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
04158     FILE *yyoutput;
04159     int yytype;
04160     YYSTYPE const * const yyvaluep;
04161 #endif
04162 {
04163   if (!yyvaluep)
04164     return;
04165 # ifdef YYPRINT
04166   if (yytype < YYNTOKENS)
04167     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
04168 # else
04169   YYUSE (yyoutput);
04170 # endif
04171   switch (yytype)
04172     {
04173       default:
04174         break;
04175     }
04176 }
04177 
04178 
04179 /*--------------------------------.
04180 | Print this symbol on YYOUTPUT.  |
04181 `--------------------------------*/
04182 
04183 #if (defined __STDC__ || defined __C99__FUNC__ \
04184      || defined __cplusplus || defined _MSC_VER)
04185 static void
04186 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
04187 #else
04188 static void
04189 yy_symbol_print (yyoutput, yytype, yyvaluep)
04190     FILE *yyoutput;
04191     int yytype;
04192     YYSTYPE const * const yyvaluep;
04193 #endif
04194 {
04195   if (yytype < YYNTOKENS)
04196     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
04197   else
04198     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
04199 
04200   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
04201   YYFPRINTF (yyoutput, ")");
04202 }
04203 
04204 /*------------------------------------------------------------------.
04205 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
04206 | TOP (included).                                                   |
04207 `------------------------------------------------------------------*/
04208 
04209 #if (defined __STDC__ || defined __C99__FUNC__ \
04210      || defined __cplusplus || defined _MSC_VER)
04211 static void
04212 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
04213 #else
04214 static void
04215 yy_stack_print (yybottom, yytop)
04216     yytype_int16 *yybottom;
04217     yytype_int16 *yytop;
04218 #endif
04219 {
04220   YYFPRINTF (stderr, "Stack now");
04221   for (; yybottom <= yytop; yybottom++)
04222     {
04223       int yybot = *yybottom;
04224       YYFPRINTF (stderr, " %d", yybot);
04225     }
04226   YYFPRINTF (stderr, "\n");
04227 }
04228 
04229 # define YY_STACK_PRINT(Bottom, Top)                                \
04230 do {                                                                \
04231   if (yydebug)                                                        \
04232     yy_stack_print ((Bottom), (Top));                                \
04233 } while (YYID (0))
04234 
04235 
04236 /*------------------------------------------------.
04237 | Report that the YYRULE is going to be reduced.  |
04238 `------------------------------------------------*/
04239 
04240 #if (defined __STDC__ || defined __C99__FUNC__ \
04241      || defined __cplusplus || defined _MSC_VER)
04242 static void
04243 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
04244 #else
04245 static void
04246 yy_reduce_print (yyvsp, yyrule)
04247     YYSTYPE *yyvsp;
04248     int yyrule;
04249 #endif
04250 {
04251   int yynrhs = yyr2[yyrule];
04252   int yyi;
04253   unsigned long int yylno = yyrline[yyrule];
04254   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
04255              yyrule - 1, yylno);
04256   /* The symbols being reduced.  */
04257   for (yyi = 0; yyi < yynrhs; yyi++)
04258     {
04259       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
04260       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
04261                        &(yyvsp[(yyi + 1) - (yynrhs)])
04262                                               );
04263       YYFPRINTF (stderr, "\n");
04264     }
04265 }
04266 
04267 # define YY_REDUCE_PRINT(Rule)                \
04268 do {                                        \
04269   if (yydebug)                                \
04270     yy_reduce_print (yyvsp, Rule); \
04271 } while (YYID (0))
04272 
04273 /* Nonzero means print parse trace.  It is left uninitialized so that
04274    multiple parsers can coexist.  */
04275 int yydebug;
04276 #else /* !YYDEBUG */
04277 # define YYDPRINTF(Args)
04278 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
04279 # define YY_STACK_PRINT(Bottom, Top)
04280 # define YY_REDUCE_PRINT(Rule)
04281 #endif /* !YYDEBUG */
04282 
04283 
04284 /* YYINITDEPTH -- initial size of the parser's stacks.  */
04285 #ifndef        YYINITDEPTH
04286 # define YYINITDEPTH 200
04287 #endif
04288 
04289 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
04290    if the built-in stack extension method is used).
04291 
04292    Do not make this value too large; the results are undefined if
04293    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
04294    evaluated with infinite-precision integer arithmetic.  */
04295 
04296 #ifndef YYMAXDEPTH
04297 # define YYMAXDEPTH 10000
04298 #endif
04299 
04300 
04301 
04302 #if YYERROR_VERBOSE
04303 
04304 # ifndef yystrlen
04305 #  if defined __GLIBC__ && defined _STRING_H
04306 #   define yystrlen strlen
04307 #  else
04308 /* Return the length of YYSTR.  */
04309 #if (defined __STDC__ || defined __C99__FUNC__ \
04310      || defined __cplusplus || defined _MSC_VER)
04311 static YYSIZE_T
04312 yystrlen (const char *yystr)
04313 #else
04314 static YYSIZE_T
04315 yystrlen (yystr)
04316     const char *yystr;
04317 #endif
04318 {
04319   YYSIZE_T yylen;
04320   for (yylen = 0; yystr[yylen]; yylen++)
04321     continue;
04322   return yylen;
04323 }
04324 #  endif
04325 # endif
04326 
04327 # ifndef yystpcpy
04328 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
04329 #   define yystpcpy stpcpy
04330 #  else
04331 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
04332    YYDEST.  */
04333 #if (defined __STDC__ || defined __C99__FUNC__ \
04334      || defined __cplusplus || defined _MSC_VER)
04335 static char *
04336 yystpcpy (char *yydest, const char *yysrc)
04337 #else
04338 static char *
04339 yystpcpy (yydest, yysrc)
04340     char *yydest;
04341     const char *yysrc;
04342 #endif
04343 {
04344   char *yyd = yydest;
04345   const char *yys = yysrc;
04346 
04347   while ((*yyd++ = *yys++) != '\0')
04348     continue;
04349 
04350   return yyd - 1;
04351 }
04352 #  endif
04353 # endif
04354 
04355 # ifndef yytnamerr
04356 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
04357    quotes and backslashes, so that it's suitable for yyerror.  The
04358    heuristic is that double-quoting is unnecessary unless the string
04359    contains an apostrophe, a comma, or backslash (other than
04360    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
04361    null, do not copy; instead, return the length of what the result
04362    would have been.  */
04363 static YYSIZE_T
04364 yytnamerr (char *yyres, const char *yystr)
04365 {
04366   if (*yystr == '"')
04367     {
04368       YYSIZE_T yyn = 0;
04369       char const *yyp = yystr;
04370 
04371       for (;;)
04372         switch (*++yyp)
04373           {
04374           case '\'':
04375           case ',':
04376             goto do_not_strip_quotes;
04377 
04378           case '\\':
04379             if (*++yyp != '\\')
04380               goto do_not_strip_quotes;
04381             /* Fall through.  */
04382           default:
04383             if (yyres)
04384               yyres[yyn] = *yyp;
04385             yyn++;
04386             break;
04387 
04388           case '"':
04389             if (yyres)
04390               yyres[yyn] = '\0';
04391             return yyn;
04392           }
04393     do_not_strip_quotes: ;
04394     }
04395 
04396   if (! yyres)
04397     return yystrlen (yystr);
04398 
04399   return yystpcpy (yyres, yystr) - yyres;
04400 }
04401 # endif
04402 
04403 /* Copy into YYRESULT an error message about the unexpected token
04404    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
04405    including the terminating null byte.  If YYRESULT is null, do not
04406    copy anything; just return the number of bytes that would be
04407    copied.  As a special case, return 0 if an ordinary "syntax error"
04408    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
04409    size calculation.  */
04410 static YYSIZE_T
04411 yysyntax_error (char *yyresult, int yystate, int yychar)
04412 {
04413   int yyn = yypact[yystate];
04414 
04415   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
04416     return 0;
04417   else
04418     {
04419       int yytype = YYTRANSLATE (yychar);
04420       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
04421       YYSIZE_T yysize = yysize0;
04422       YYSIZE_T yysize1;
04423       int yysize_overflow = 0;
04424       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
04425       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
04426       int yyx;
04427 
04428 # if 0
04429       /* This is so xgettext sees the translatable formats that are
04430          constructed on the fly.  */
04431       YY_("syntax error, unexpected %s");
04432       YY_("syntax error, unexpected %s, expecting %s");
04433       YY_("syntax error, unexpected %s, expecting %s or %s");
04434       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
04435       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
04436 # endif
04437       char *yyfmt;
04438       char const *yyf;
04439       static char const yyunexpected[] = "syntax error, unexpected %s";
04440       static char const yyexpecting[] = ", expecting %s";
04441       static char const yyor[] = " or %s";
04442       char yyformat[sizeof yyunexpected
04443                     + sizeof yyexpecting - 1
04444                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
04445                        * (sizeof yyor - 1))];
04446       char const *yyprefix = yyexpecting;
04447 
04448       /* Start YYX at -YYN if negative to avoid negative indexes in
04449          YYCHECK.  */
04450       int yyxbegin = yyn < 0 ? -yyn : 0;
04451 
04452       /* Stay within bounds of both yycheck and yytname.  */
04453       int yychecklim = YYLAST - yyn + 1;
04454       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
04455       int yycount = 1;
04456 
04457       yyarg[0] = yytname[yytype];
04458       yyfmt = yystpcpy (yyformat, yyunexpected);
04459 
04460       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
04461         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
04462           {
04463             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
04464               {
04465                 yycount = 1;
04466                 yysize = yysize0;
04467                 yyformat[sizeof yyunexpected - 1] = '\0';
04468                 break;
04469               }
04470             yyarg[yycount++] = yytname[yyx];
04471             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
04472             yysize_overflow |= (yysize1 < yysize);
04473             yysize = yysize1;
04474             yyfmt = yystpcpy (yyfmt, yyprefix);
04475             yyprefix = yyor;
04476           }
04477 
04478       yyf = YY_(yyformat);
04479       yysize1 = yysize + yystrlen (yyf);
04480       yysize_overflow |= (yysize1 < yysize);
04481       yysize = yysize1;
04482 
04483       if (yysize_overflow)
04484         return YYSIZE_MAXIMUM;
04485 
04486       if (yyresult)
04487         {
04488           /* Avoid sprintf, as that infringes on the user's name space.
04489              Don't have undefined behavior even if the translation
04490              produced a string with the wrong number of "%s"s.  */
04491           char *yyp = yyresult;
04492           int yyi = 0;
04493           while ((*yyp = *yyf) != '\0')
04494             {
04495               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
04496                 {
04497                   yyp += yytnamerr (yyp, yyarg[yyi++]);
04498                   yyf += 2;
04499                 }
04500               else
04501                 {
04502                   yyp++;
04503                   yyf++;
04504                 }
04505             }
04506         }
04507       return yysize;
04508     }
04509 }
04510 #endif /* YYERROR_VERBOSE */
04511 
04512 
04513 /*-----------------------------------------------.
04514 | Release the memory associated to this symbol.  |
04515 `-----------------------------------------------*/
04516 
04517 /*ARGSUSED*/
04518 #if (defined __STDC__ || defined __C99__FUNC__ \
04519      || defined __cplusplus || defined _MSC_VER)
04520 static void
04521 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
04522 #else
04523 static void
04524 yydestruct (yymsg, yytype, yyvaluep)
04525     const char *yymsg;
04526     int yytype;
04527     YYSTYPE *yyvaluep;
04528 #endif
04529 {
04530   YYUSE (yyvaluep);
04531 
04532   if (!yymsg)
04533     yymsg = "Deleting";
04534   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
04535 
04536   switch (yytype)
04537     {
04538 
04539       default:
04540         break;
04541     }
04542 }
04543 
04544 /* Prevent warnings from -Wmissing-prototypes.  */
04545 #ifdef YYPARSE_PARAM
04546 #if defined __STDC__ || defined __cplusplus
04547 int yyparse (void *YYPARSE_PARAM);
04548 #else
04549 int yyparse ();
04550 #endif
04551 #else /* ! YYPARSE_PARAM */
04552 #if defined __STDC__ || defined __cplusplus
04553 int yyparse (void);
04554 #else
04555 int yyparse ();
04556 #endif
04557 #endif /* ! YYPARSE_PARAM */
04558 
04559 
04560 /* The lookahead symbol.  */
04561 int yychar;
04562 
04563 /* The semantic value of the lookahead symbol.  */
04564 YYSTYPE yylval;
04565 
04566 /* Number of syntax errors so far.  */
04567 int yynerrs;
04568 
04569 
04570 
04571 /*-------------------------.
04572 | yyparse or yypush_parse.  |
04573 `-------------------------*/
04574 
04575 #ifdef YYPARSE_PARAM
04576 #if (defined __STDC__ || defined __C99__FUNC__ \
04577      || defined __cplusplus || defined _MSC_VER)
04578 int
04579 yyparse (void *YYPARSE_PARAM)
04580 #else
04581 int
04582 yyparse (YYPARSE_PARAM)
04583     void *YYPARSE_PARAM;
04584 #endif
04585 #else /* ! YYPARSE_PARAM */
04586 #if (defined __STDC__ || defined __C99__FUNC__ \
04587      || defined __cplusplus || defined _MSC_VER)
04588 int
04589 yyparse (void)
04590 #else
04591 int
04592 yyparse ()
04593 
04594 #endif
04595 #endif
04596 {
04597 
04598 
04599     int yystate;
04600     /* Number of tokens to shift before error messages enabled.  */
04601     int yyerrstatus;
04602 
04603     /* The stacks and their tools:
04604        `yyss': related to states.
04605        `yyvs': related to semantic values.
04606 
04607        Refer to the stacks thru separate pointers, to allow yyoverflow
04608        to reallocate them elsewhere.  */
04609 
04610     /* The state stack.  */
04611     yytype_int16 yyssa[YYINITDEPTH];
04612     yytype_int16 *yyss;
04613     yytype_int16 *yyssp;
04614 
04615     /* The semantic value stack.  */
04616     YYSTYPE yyvsa[YYINITDEPTH];
04617     YYSTYPE *yyvs;
04618     YYSTYPE *yyvsp;
04619 
04620     YYSIZE_T yystacksize;
04621 
04622   int yyn;
04623   int yyresult;
04624   /* Lookahead token as an internal (translated) token number.  */
04625   int yytoken;
04626   /* The variables used to return semantic value and location from the
04627      action routines.  */
04628   YYSTYPE yyval;
04629 
04630 #if YYERROR_VERBOSE
04631   /* Buffer for error messages, and its allocated size.  */
04632   char yymsgbuf[128];
04633   char *yymsg = yymsgbuf;
04634   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
04635 #endif
04636 
04637 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
04638 
04639   /* The number of symbols on the RHS of the reduced rule.
04640      Keep to zero when no symbol should be popped.  */
04641   int yylen = 0;
04642 
04643   yytoken = 0;
04644   yyss = yyssa;
04645   yyvs = yyvsa;
04646   yystacksize = YYINITDEPTH;
04647 
04648   YYDPRINTF ((stderr, "Starting parse\n"));
04649 
04650   yystate = 0;
04651   yyerrstatus = 0;
04652   yynerrs = 0;
04653   yychar = YYEMPTY; /* Cause a token to be read.  */
04654 
04655   /* Initialize stack pointers.
04656      Waste one element of value and location stack
04657      so that they stay on the same level as the state stack.
04658      The wasted elements are never initialized.  */
04659   yyssp = yyss;
04660   yyvsp = yyvs;
04661 
04662   goto yysetstate;
04663 
04664 /*------------------------------------------------------------.
04665 | yynewstate -- Push a new state, which is found in yystate.  |
04666 `------------------------------------------------------------*/
04667  yynewstate:
04668   /* In all cases, when you get here, the value and location stacks
04669      have just been pushed.  So pushing a state here evens the stacks.  */
04670   yyssp++;
04671 
04672  yysetstate:
04673   *yyssp = yystate;
04674 
04675   if (yyss + yystacksize - 1 <= yyssp)
04676     {
04677       /* Get the current used size of the three stacks, in elements.  */
04678       YYSIZE_T yysize = yyssp - yyss + 1;
04679 
04680 #ifdef yyoverflow
04681       {
04682         /* Give user a chance to reallocate the stack.  Use copies of
04683            these so that the &'s don't force the real ones into
04684            memory.  */
04685         YYSTYPE *yyvs1 = yyvs;
04686         yytype_int16 *yyss1 = yyss;
04687 
04688         /* Each stack pointer address is followed by the size of the
04689            data in use in that stack, in bytes.  This used to be a
04690            conditional around just the two extra args, but that might
04691            be undefined if yyoverflow is a macro.  */
04692         yyoverflow (YY_("memory exhausted"),
04693                     &yyss1, yysize * sizeof (*yyssp),
04694                     &yyvs1, yysize * sizeof (*yyvsp),
04695                     &yystacksize);
04696 
04697         yyss = yyss1;
04698         yyvs = yyvs1;
04699       }
04700 #else /* no yyoverflow */
04701 # ifndef YYSTACK_RELOCATE
04702       goto yyexhaustedlab;
04703 # else
04704       /* Extend the stack our own way.  */
04705       if (YYMAXDEPTH <= yystacksize)
04706         goto yyexhaustedlab;
04707       yystacksize *= 2;
04708       if (YYMAXDEPTH < yystacksize)
04709         yystacksize = YYMAXDEPTH;
04710 
04711       {
04712         yytype_int16 *yyss1 = yyss;
04713         union yyalloc *yyptr =
04714           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
04715         if (! yyptr)
04716           goto yyexhaustedlab;
04717         YYSTACK_RELOCATE (yyss_alloc, yyss);
04718         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
04719 #  undef YYSTACK_RELOCATE
04720         if (yyss1 != yyssa)
04721           YYSTACK_FREE (yyss1);
04722       }
04723 # endif
04724 #endif /* no yyoverflow */
04725 
04726       yyssp = yyss + yysize - 1;
04727       yyvsp = yyvs + yysize - 1;
04728 
04729       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
04730                   (unsigned long int) yystacksize));
04731 
04732       if (yyss + yystacksize - 1 <= yyssp)
04733         YYABORT;
04734     }
04735 
04736   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
04737 
04738   if (yystate == YYFINAL)
04739     YYACCEPT;
04740 
04741   goto yybackup;
04742 
04743 /*-----------.
04744 | yybackup.  |
04745 `-----------*/
04746 yybackup:
04747 
04748   /* Do appropriate processing given the current state.  Read a
04749      lookahead token if we need one and don't already have one.  */
04750 
04751   /* First try to decide what to do without reference to lookahead token.  */
04752   yyn = yypact[yystate];
04753   if (yyn == YYPACT_NINF)
04754     goto yydefault;
04755 
04756   /* Not known => get a lookahead token if don't already have one.  */
04757 
04758   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
04759   if (yychar == YYEMPTY)
04760     {
04761       YYDPRINTF ((stderr, "Reading a token: "));
04762       yychar = YYLEX;
04763     }
04764 
04765   if (yychar <= YYEOF)
04766     {
04767       yychar = yytoken = YYEOF;
04768       YYDPRINTF ((stderr, "Now at end of input.\n"));
04769     }
04770   else
04771     {
04772       yytoken = YYTRANSLATE (yychar);
04773       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
04774     }
04775 
04776   /* If the proper action on seeing token YYTOKEN is to reduce or to
04777      detect an error, take that action.  */
04778   yyn += yytoken;
04779   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
04780     goto yydefault;
04781   yyn = yytable[yyn];
04782   if (yyn <= 0)
04783     {
04784       if (yyn == 0 || yyn == YYTABLE_NINF)
04785         goto yyerrlab;
04786       yyn = -yyn;
04787       goto yyreduce;
04788     }
04789 
04790   /* Count tokens shifted since error; after three, turn off error
04791      status.  */
04792   if (yyerrstatus)
04793     yyerrstatus--;
04794 
04795   /* Shift the lookahead token.  */
04796   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
04797 
04798   /* Discard the shifted token.  */
04799   yychar = YYEMPTY;
04800 
04801   yystate = yyn;
04802   *++yyvsp = yylval;
04803 
04804   goto yynewstate;
04805 
04806 
04807 /*-----------------------------------------------------------.
04808 | yydefault -- do the default action for the current state.  |
04809 `-----------------------------------------------------------*/
04810 yydefault:
04811   yyn = yydefact[yystate];
04812   if (yyn == 0)
04813     goto yyerrlab;
04814   goto yyreduce;
04815 
04816 
04817 /*-----------------------------.
04818 | yyreduce -- Do a reduction.  |
04819 `-----------------------------*/
04820 yyreduce:
04821   /* yyn is the number of a rule to reduce with.  */
04822   yylen = yyr2[yyn];
04823 
04824   /* If YYLEN is nonzero, implement the default value of the action:
04825      `$$ = $1'.
04826 
04827      Otherwise, the following line sets YYVAL to garbage.
04828      This behavior is undocumented and Bison
04829      users should not rely upon it.  Assigning to YYVAL
04830      unconditionally makes the parser a bit smaller, and it avoids a
04831      GCC warning that YYVAL may be used uninitialized.  */
04832   yyval = yyvsp[1-yylen];
04833 
04834 
04835   YY_REDUCE_PRINT (yyn);
04836   switch (yyn)
04837     {
04838         case 3:
04839 
04840 /* Line 1455 of yacc.c  */
04841 #line 1333 "vtkParse.y"
04842     { startSig(); clearTypeId(); clearTemplate(); closeComment(); }
04843     break;
04844 
04845   case 14:
04846 
04847 /* Line 1455 of yacc.c  */
04848 #line 1346 "vtkParse.y"
04849     { output_function(); }
04850     break;
04851 
04852   case 15:
04853 
04854 /* Line 1455 of yacc.c  */
04855 #line 1347 "vtkParse.y"
04856     { output_function(); }
04857     break;
04858 
04859   case 16:
04860 
04861 /* Line 1455 of yacc.c  */
04862 #line 1348 "vtkParse.y"
04863     { reject_function(); }
04864     break;
04865 
04866   case 17:
04867 
04868 /* Line 1455 of yacc.c  */
04869 #line 1349 "vtkParse.y"
04870     { output_function(); }
04871     break;
04872 
04873   case 18:
04874 
04875 /* Line 1455 of yacc.c  */
04876 #line 1350 "vtkParse.y"
04877     { reject_function(); }
04878     break;
04879 
04880   case 19:
04881 
04882 /* Line 1455 of yacc.c  */
04883 #line 1351 "vtkParse.y"
04884     { output_function(); }
04885     break;
04886 
04887   case 20:
04888 
04889 /* Line 1455 of yacc.c  */
04890 #line 1352 "vtkParse.y"
04891     { legacySig(); output_function(); }
04892     break;
04893 
04894   case 28:
04895 
04896 /* Line 1455 of yacc.c  */
04897 #line 1370 "vtkParse.y"
04898     { pushNamespace((yyvsp[(2) - (2)].str)); }
04899     break;
04900 
04901   case 29:
04902 
04903 /* Line 1455 of yacc.c  */
04904 #line 1371 "vtkParse.y"
04905     { popNamespace(); }
04906     break;
04907 
04908   case 31:
04909 
04910 /* Line 1455 of yacc.c  */
04911 #line 1378 "vtkParse.y"
04912     { start_class((yyvsp[(2) - (2)].str), 0); }
04913     break;
04914 
04915   case 32:
04916 
04917 /* Line 1455 of yacc.c  */
04918 #line 1379 "vtkParse.y"
04919     { end_class(); }
04920     break;
04921 
04922   case 33:
04923 
04924 /* Line 1455 of yacc.c  */
04925 #line 1380 "vtkParse.y"
04926     { reject_class((yyvsp[(2) - (5)].str), 0); }
04927     break;
04928 
04929   case 34:
04930 
04931 /* Line 1455 of yacc.c  */
04932 #line 1381 "vtkParse.y"
04933     { end_class(); }
04934     break;
04935 
04936   case 35:
04937 
04938 /* Line 1455 of yacc.c  */
04939 #line 1382 "vtkParse.y"
04940     { start_class((yyvsp[(2) - (2)].str), 1); }
04941     break;
04942 
04943   case 36:
04944 
04945 /* Line 1455 of yacc.c  */
04946 #line 1383 "vtkParse.y"
04947     { end_class(); }
04948     break;
04949 
04950   case 37:
04951 
04952 /* Line 1455 of yacc.c  */
04953 #line 1384 "vtkParse.y"
04954     { reject_class((yyvsp[(2) - (5)].str), 1); }
04955     break;
04956 
04957   case 38:
04958 
04959 /* Line 1455 of yacc.c  */
04960 #line 1385 "vtkParse.y"
04961     { end_class(); }
04962     break;
04963 
04964   case 40:
04965 
04966 /* Line 1455 of yacc.c  */
04967 #line 1387 "vtkParse.y"
04968     { start_class((yyvsp[(2) - (2)].str), 2); }
04969     break;
04970 
04971   case 41:
04972 
04973 /* Line 1455 of yacc.c  */
04974 #line 1388 "vtkParse.y"
04975     { end_class(); }
04976     break;
04977 
04978   case 42:
04979 
04980 /* Line 1455 of yacc.c  */
04981 #line 1389 "vtkParse.y"
04982     { reject_class((yyvsp[(2) - (5)].str), 2); }
04983     break;
04984 
04985   case 43:
04986 
04987 /* Line 1455 of yacc.c  */
04988 #line 1390 "vtkParse.y"
04989     { end_class(); }
04990     break;
04991 
04992   case 46:
04993 
04994 /* Line 1455 of yacc.c  */
04995 #line 1395 "vtkParse.y"
04996     { startSig(); clearTypeId(); clearTemplate();  closeComment(); }
04997     break;
04998 
04999   case 58:
05000 
05001 /* Line 1455 of yacc.c  */
05002 #line 1409 "vtkParse.y"
05003     { output_function(); }
05004     break;
05005 
05006   case 59:
05007 
05008 /* Line 1455 of yacc.c  */
05009 #line 1410 "vtkParse.y"
05010     { ClassInfo *tmpc = currentClass;
05011      currentClass = NULL; output_function(); currentClass = tmpc; }
05012     break;
05013 
05014   case 60:
05015 
05016 /* Line 1455 of yacc.c  */
05017 #line 1412 "vtkParse.y"
05018     { output_function(); }
05019     break;
05020 
05021   case 61:
05022 
05023 /* Line 1455 of yacc.c  */
05024 #line 1413 "vtkParse.y"
05025     { output_function(); }
05026     break;
05027 
05028   case 62:
05029 
05030 /* Line 1455 of yacc.c  */
05031 #line 1414 "vtkParse.y"
05032     { ClassInfo *tmpc = currentClass;
05033      currentClass = NULL; output_function(); currentClass = tmpc; }
05034     break;
05035 
05036   case 63:
05037 
05038 /* Line 1455 of yacc.c  */
05039 #line 1416 "vtkParse.y"
05040     { output_function(); }
05041     break;
05042 
05043   case 64:
05044 
05045 /* Line 1455 of yacc.c  */
05046 #line 1417 "vtkParse.y"
05047     { legacySig(); output_function(); }
05048     break;
05049 
05050   case 75:
05051 
05052 /* Line 1455 of yacc.c  */
05053 #line 1430 "vtkParse.y"
05054     {
05055       vtkParse_AddStringToArray(&currentClass->SuperClasses,
05056                                 &currentClass->NumberOfSuperClasses,
05057                                 vtkstrdup((yyvsp[(2) - (2)].str)));
05058     }
05059     break;
05060 
05061   case 76:
05062 
05063 /* Line 1455 of yacc.c  */
05064 #line 1436 "vtkParse.y"
05065     {access_level = VTK_ACCESS_PUBLIC;}
05066     break;
05067 
05068   case 77:
05069 
05070 /* Line 1455 of yacc.c  */
05071 #line 1437 "vtkParse.y"
05072     {access_level = VTK_ACCESS_PRIVATE;}
05073     break;
05074 
05075   case 78:
05076 
05077 /* Line 1455 of yacc.c  */
05078 #line 1438 "vtkParse.y"
05079     {access_level = VTK_ACCESS_PROTECTED;}
05080     break;
05081 
05082   case 79:
05083 
05084 /* Line 1455 of yacc.c  */
05085 #line 1448 "vtkParse.y"
05086     {start_enum((yyvsp[(2) - (2)].str));}
05087     break;
05088 
05089   case 80:
05090 
05091 /* Line 1455 of yacc.c  */
05092 #line 1449 "vtkParse.y"
05093     {end_enum();}
05094     break;
05095 
05096   case 81:
05097 
05098 /* Line 1455 of yacc.c  */
05099 #line 1450 "vtkParse.y"
05100     {start_enum(NULL);}
05101     break;
05102 
05103   case 82:
05104 
05105 /* Line 1455 of yacc.c  */
05106 #line 1451 "vtkParse.y"
05107     {end_enum();}
05108     break;
05109 
05110   case 86:
05111 
05112 /* Line 1455 of yacc.c  */
05113 #line 1455 "vtkParse.y"
05114     {add_enum((yyvsp[(1) - (1)].str), NULL);}
05115     break;
05116 
05117   case 87:
05118 
05119 /* Line 1455 of yacc.c  */
05120 #line 1456 "vtkParse.y"
05121     {add_enum((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str));}
05122     break;
05123 
05124   case 88:
05125 
05126 /* Line 1455 of yacc.c  */
05127 #line 1458 "vtkParse.y"
05128     {postSig((yyvsp[(1) - (1)].str));}
05129     break;
05130 
05131   case 89:
05132 
05133 /* Line 1455 of yacc.c  */
05134 #line 1459 "vtkParse.y"
05135     {(yyval.str) = vtkstrdup(add_const_scope((yyvsp[(1) - (1)].str)));}
05136     break;
05137 
05138   case 97:
05139 
05140 /* Line 1455 of yacc.c  */
05141 #line 1464 "vtkParse.y"
05142     { (yyval.str) = (yyvsp[(1) - (1)].str); }
05143     break;
05144 
05145   case 98:
05146 
05147 /* Line 1455 of yacc.c  */
05148 #line 1465 "vtkParse.y"
05149     {postSig((yyvsp[(1) - (1)].str));}
05150     break;
05151 
05152   case 99:
05153 
05154 /* Line 1455 of yacc.c  */
05155 #line 1466 "vtkParse.y"
05156     {
05157          (yyval.str) = vtkstrcat((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str));
05158        }
05159     break;
05160 
05161   case 100:
05162 
05163 /* Line 1455 of yacc.c  */
05164 #line 1469 "vtkParse.y"
05165     {postSig((yyvsp[(2) - (2)].str));}
05166     break;
05167 
05168   case 101:
05169 
05170 /* Line 1455 of yacc.c  */
05171 #line 1470 "vtkParse.y"
05172     {
05173          (yyval.str) = vtkstrcat5((yyvsp[(1) - (4)].str), " ", (yyvsp[(2) - (4)].str), " ", (yyvsp[(4) - (4)].str));
05174        }
05175     break;
05176 
05177   case 102:
05178 
05179 /* Line 1455 of yacc.c  */
05180 #line 1473 "vtkParse.y"
05181     {postSig("(");}
05182     break;
05183 
05184   case 103:
05185 
05186 /* Line 1455 of yacc.c  */
05187 #line 1474 "vtkParse.y"
05188     {
05189          (yyval.str) = vtkstrcat3("(", (yyvsp[(3) - (4)].str), ")");
05190        }
05191     break;
05192 
05193   case 104:
05194 
05195 /* Line 1455 of yacc.c  */
05196 #line 1478 "vtkParse.y"
05197     { (yyval.str) = "-"; }
05198     break;
05199 
05200   case 105:
05201 
05202 /* Line 1455 of yacc.c  */
05203 #line 1478 "vtkParse.y"
05204     { (yyval.str) = "+"; }
05205     break;
05206 
05207   case 106:
05208 
05209 /* Line 1455 of yacc.c  */
05210 #line 1479 "vtkParse.y"
05211     { (yyval.str) = "~"; }
05212     break;
05213 
05214   case 107:
05215 
05216 /* Line 1455 of yacc.c  */
05217 #line 1481 "vtkParse.y"
05218     { (yyval.str) = "-"; }
05219     break;
05220 
05221   case 108:
05222 
05223 /* Line 1455 of yacc.c  */
05224 #line 1481 "vtkParse.y"
05225     { (yyval.str) = "+"; }
05226     break;
05227 
05228   case 109:
05229 
05230 /* Line 1455 of yacc.c  */
05231 #line 1482 "vtkParse.y"
05232     { (yyval.str) = "*"; }
05233     break;
05234 
05235   case 110:
05236 
05237 /* Line 1455 of yacc.c  */
05238 #line 1482 "vtkParse.y"
05239     { (yyval.str) = "/"; }
05240     break;
05241 
05242   case 111:
05243 
05244 /* Line 1455 of yacc.c  */
05245 #line 1483 "vtkParse.y"
05246     { (yyval.str) = "%"; }
05247     break;
05248 
05249   case 112:
05250 
05251 /* Line 1455 of yacc.c  */
05252 #line 1483 "vtkParse.y"
05253     { (yyval.str) = "&"; }
05254     break;
05255 
05256   case 113:
05257 
05258 /* Line 1455 of yacc.c  */
05259 #line 1484 "vtkParse.y"
05260     { (yyval.str) = "|"; }
05261     break;
05262 
05263   case 114:
05264 
05265 /* Line 1455 of yacc.c  */
05266 #line 1484 "vtkParse.y"
05267     { (yyval.str) = "^"; }
05268     break;
05269 
05270   case 115:
05271 
05272 /* Line 1455 of yacc.c  */
05273 #line 1485 "vtkParse.y"
05274     { (yyval.str) = ">>"; }
05275     break;
05276 
05277   case 116:
05278 
05279 /* Line 1455 of yacc.c  */
05280 #line 1486 "vtkParse.y"
05281     { (yyval.str) = "<<"; }
05282     break;
05283 
05284   case 126:
05285 
05286 /* Line 1455 of yacc.c  */
05287 #line 1509 "vtkParse.y"
05288     {
05289       ValueInfo *item = (ValueInfo *)malloc(sizeof(ValueInfo));
05290       vtkParse_InitValue(item);
05291       item->ItemType = VTK_TYPEDEF_INFO;
05292       item->Access = access_level;
05293 
05294       handle_complex_type(item, (yyvsp[(2) - (4)].integer), (yyvsp[(3) - (4)].integer), getSig());
05295 
05296       if (getVarName())
05297         {
05298         item->Name = vtkstrdup(getVarName());
05299         }
05300 
05301       if (currentClass)
05302         {
05303         vtkParse_AddTypedefToClass(currentClass, item);
05304         }
05305       else
05306         {
05307         vtkParse_AddTypedefToNamespace(currentNamespace, item);
05308         }
05309     }
05310     break;
05311 
05312   case 127:
05313 
05314 /* Line 1455 of yacc.c  */
05315 #line 1531 "vtkParse.y"
05316     { }
05317     break;
05318 
05319   case 128:
05320 
05321 /* Line 1455 of yacc.c  */
05322 #line 1532 "vtkParse.y"
05323     { }
05324     break;
05325 
05326   case 129:
05327 
05328 /* Line 1455 of yacc.c  */
05329 #line 1533 "vtkParse.y"
05330     { }
05331     break;
05332 
05333   case 130:
05334 
05335 /* Line 1455 of yacc.c  */
05336 #line 1535 "vtkParse.y"
05337     { }
05338     break;
05339 
05340   case 131:
05341 
05342 /* Line 1455 of yacc.c  */
05343 #line 1542 "vtkParse.y"
05344     { add_using((yyvsp[(3) - (4)].str), 1); }
05345     break;
05346 
05347   case 132:
05348 
05349 /* Line 1455 of yacc.c  */
05350 #line 1543 "vtkParse.y"
05351     { add_using((yyvsp[(3) - (4)].str), 0); }
05352     break;
05353 
05354   case 133:
05355 
05356 /* Line 1455 of yacc.c  */
05357 #line 1544 "vtkParse.y"
05358     { add_using((yyvsp[(2) - (3)].str), 0); }
05359     break;
05360 
05361   case 134:
05362 
05363 /* Line 1455 of yacc.c  */
05364 #line 1551 "vtkParse.y"
05365     { postSig("template<> "); clearTypeId(); }
05366     break;
05367 
05368   case 135:
05369 
05370 /* Line 1455 of yacc.c  */
05371 #line 1552 "vtkParse.y"
05372     { postSig("template<");
05373           clearTypeId(); startTemplate(); }
05374     break;
05375 
05376   case 136:
05377 
05378 /* Line 1455 of yacc.c  */
05379 #line 1554 "vtkParse.y"
05380     { chopSig();
05381             if (getSig()[strlen(getSig())-1] == '>') { postSig(" "); }
05382             postSig("> "); clearTypeId(); }
05383     break;
05384 
05385   case 138:
05386 
05387 /* Line 1455 of yacc.c  */
05388 #line 1559 "vtkParse.y"
05389     { chopSig(); postSig(", "); clearTypeId(); }
05390     break;
05391 
05392   case 140:
05393 
05394 /* Line 1455 of yacc.c  */
05395 #line 1563 "vtkParse.y"
05396     {
05397                TemplateArg *arg = (TemplateArg *)malloc(sizeof(TemplateArg));
05398                vtkParse_InitTemplateArg(arg);
05399                arg->Type = (yyvsp[(1) - (2)].integer);
05400                arg->Class = vtkstrdup(getTypeId());
05401                arg->Name = vtkstrdup(getVarName());
05402                arg->Value = vtkstrdup(getVarValue());
05403                vtkParse_AddArgumentToTemplate(currentTemplate, arg);
05404                }
05405     break;
05406 
05407   case 141:
05408 
05409 /* Line 1455 of yacc.c  */
05410 #line 1573 "vtkParse.y"
05411     {
05412                TemplateArg *arg = (TemplateArg *)malloc(sizeof(TemplateArg));
05413                vtkParse_InitTemplateArg(arg);
05414                arg->Name = vtkstrdup(getVarName());
05415                arg->Value = vtkstrdup(getVarValue());
05416                vtkParse_AddArgumentToTemplate(currentTemplate, arg);
05417                }
05418     break;
05419 
05420   case 142:
05421 
05422 /* Line 1455 of yacc.c  */
05423 #line 1580 "vtkParse.y"
05424     { pushTemplate(); }
05425     break;
05426 
05427   case 143:
05428 
05429 /* Line 1455 of yacc.c  */
05430 #line 1581 "vtkParse.y"
05431     {
05432                TemplateArgs *newTemplate = currentTemplate;
05433                TemplateArg *arg = (TemplateArg *)malloc(sizeof(TemplateArg));
05434                vtkParse_InitTemplateArg(arg);
05435                popTemplate();
05436                arg->Template = newTemplate;
05437                arg->Name = vtkstrdup(getVarName());
05438                arg->Value = vtkstrdup(getVarValue());
05439                vtkParse_AddArgumentToTemplate(currentTemplate, arg);
05440                }
05441     break;
05442 
05443   case 144:
05444 
05445 /* Line 1455 of yacc.c  */
05446 #line 1592 "vtkParse.y"
05447     {postSig("class ");}
05448     break;
05449 
05450   case 145:
05451 
05452 /* Line 1455 of yacc.c  */
05453 #line 1593 "vtkParse.y"
05454     {postSig("typename ");}
05455     break;
05456 
05457   case 147:
05458 
05459 /* Line 1455 of yacc.c  */
05460 #line 1595 "vtkParse.y"
05461     { setVarName((yyvsp[(1) - (1)].str)); }
05462     break;
05463 
05464   case 163:
05465 
05466 /* Line 1455 of yacc.c  */
05467 #line 1625 "vtkParse.y"
05468     {openSig(); preSig("~"); closeSig();}
05469     break;
05470 
05471   case 164:
05472 
05473 /* Line 1455 of yacc.c  */
05474 #line 1626 "vtkParse.y"
05475     {openSig(); preSig("~"); closeSig();}
05476     break;
05477 
05478   case 165:
05479 
05480 /* Line 1455 of yacc.c  */
05481 #line 1628 "vtkParse.y"
05482     {
05483          openSig(); preSig("virtual ~"); closeSig();
05484          currentFunction->IsVirtual = 1;
05485          }
05486     break;
05487 
05488   case 168:
05489 
05490 /* Line 1455 of yacc.c  */
05491 #line 1635 "vtkParse.y"
05492     {
05493          openSig();
05494          preSig("explicit ");
05495          closeSig();
05496          currentFunction->IsExplicit = 1;
05497          }
05498     break;
05499 
05500   case 170:
05501 
05502 /* Line 1455 of yacc.c  */
05503 #line 1643 "vtkParse.y"
05504     {
05505          openSig();
05506          preSig("virtual ");
05507          closeSig();
05508          currentFunction->IsVirtual = 1;
05509          }
05510     break;
05511 
05512   case 178:
05513 
05514 /* Line 1455 of yacc.c  */
05515 #line 1659 "vtkParse.y"
05516     {
05517          openSig();
05518          preSig("virtual ");
05519          closeSig();
05520          currentFunction->IsVirtual = 1;
05521          }
05522     break;
05523 
05524   case 179:
05525 
05526 /* Line 1455 of yacc.c  */
05527 #line 1668 "vtkParse.y"
05528     {
05529       postSig("(");
05530       set_return(currentFunction, getStorageType(), getTypeId(), 0);
05531     }
05532     break;
05533 
05534   case 180:
05535 
05536 /* Line 1455 of yacc.c  */
05537 #line 1672 "vtkParse.y"
05538     { postSig(")"); }
05539     break;
05540 
05541   case 181:
05542 
05543 /* Line 1455 of yacc.c  */
05544 #line 1673 "vtkParse.y"
05545     {
05546       (yyval.integer) = (yyvsp[(2) - (8)].integer);
05547       postSig(";");
05548       preSig("operator ");
05549       closeSig();
05550       currentFunction->IsOperator = 1;
05551       currentFunction->Name = "operator typecast";
05552       currentFunction->Comment = vtkstrdup(getComment());
05553       vtkParseDebug("Parsed operator", "operator typecast");
05554     }
05555     break;
05556 
05557   case 182:
05558 
05559 /* Line 1455 of yacc.c  */
05560 #line 1684 "vtkParse.y"
05561     { postSig(")"); }
05562     break;
05563 
05564   case 183:
05565 
05566 /* Line 1455 of yacc.c  */
05567 #line 1685 "vtkParse.y"
05568     {
05569       postSig(";");
05570       closeSig();
05571       currentFunction->Name = vtkstrdup((yyvsp[(1) - (3)].str));
05572       currentFunction->Comment = vtkstrdup(getComment());
05573       vtkParseDebug("Parsed operator", currentFunction->Name);
05574     }
05575     break;
05576 
05577   case 184:
05578 
05579 /* Line 1455 of yacc.c  */
05580 #line 1693 "vtkParse.y"
05581     {postSig((yyvsp[(2) - (2)].str));}
05582     break;
05583 
05584   case 185:
05585 
05586 /* Line 1455 of yacc.c  */
05587 #line 1694 "vtkParse.y"
05588     {
05589       postSig("(");
05590       currentFunction->IsOperator = 1;
05591       set_return(currentFunction, getStorageType(), getTypeId(), 0);
05592     }
05593     break;
05594 
05595   case 186:
05596 
05597 /* Line 1455 of yacc.c  */
05598 #line 1699 "vtkParse.y"
05599     { (yyval.str) = (yyvsp[(2) - (7)].str); }
05600     break;
05601 
05602   case 187:
05603 
05604 /* Line 1455 of yacc.c  */
05605 #line 1701 "vtkParse.y"
05606     { postSig(")"); }
05607     break;
05608 
05609   case 188:
05610 
05611 /* Line 1455 of yacc.c  */
05612 #line 1702 "vtkParse.y"
05613     {
05614       postSig(";");
05615       closeSig();
05616       currentFunction->Name = vtkstrdup((yyvsp[(1) - (3)].str));
05617       currentFunction->Comment = vtkstrdup(getComment());
05618       vtkParseDebug("Parsed func", currentFunction->Name);
05619     }
05620     break;
05621 
05622   case 190:
05623 
05624 /* Line 1455 of yacc.c  */
05625 #line 1712 "vtkParse.y"
05626     {
05627       postSig(" = 0");
05628       if (currentClass)
05629         {
05630         currentFunction->IsPureVirtual = 1;
05631         currentClass->IsAbstract = 1;
05632         }
05633     }
05634     break;
05635 
05636   case 191:
05637 
05638 /* Line 1455 of yacc.c  */
05639 #line 1721 "vtkParse.y"
05640     {
05641       postSig(" const = 0");
05642       currentFunction->IsConst = 1;
05643       if (currentClass)
05644         {
05645         currentFunction->IsPureVirtual = 1;
05646         currentClass->IsAbstract = 1;
05647         }
05648     }
05649     break;
05650 
05651   case 192:
05652 
05653 /* Line 1455 of yacc.c  */
05654 #line 1731 "vtkParse.y"
05655     {
05656       postSig(" const");
05657       currentFunction->IsConst = 1;
05658     }
05659     break;
05660 
05661   case 195:
05662 
05663 /* Line 1455 of yacc.c  */
05664 #line 1739 "vtkParse.y"
05665     {
05666       postSig("(");
05667       set_return(currentFunction, getStorageType(), getTypeId(), 0);
05668     }
05669     break;
05670 
05671   case 196:
05672 
05673 /* Line 1455 of yacc.c  */
05674 #line 1742 "vtkParse.y"
05675     { (yyval.str) = (yyvsp[(1) - (5)].str); }
05676     break;
05677 
05678   case 197:
05679 
05680 /* Line 1455 of yacc.c  */
05681 #line 1743 "vtkParse.y"
05682     {markSig(); postSig("<");}
05683     break;
05684 
05685   case 198:
05686 
05687 /* Line 1455 of yacc.c  */
05688 #line 1744 "vtkParse.y"
05689     {
05690       if (getSig()[strlen(getSig())-1] == '>') { postSig(" "); }
05691       postSig(">(");
05692       set_return(currentFunction, getStorageType(), getTypeId(), 0);
05693       (yyval.str) = vtkstrcat((yyvsp[(1) - (6)].str), copySig());
05694     }
05695     break;
05696 
05697   case 199:
05698 
05699 /* Line 1455 of yacc.c  */
05700 #line 1749 "vtkParse.y"
05701     { (yyval.str) = (yyvsp[(7) - (9)].str); }
05702     break;
05703 
05704   case 200:
05705 
05706 /* Line 1455 of yacc.c  */
05707 #line 1751 "vtkParse.y"
05708     { postSig(");"); closeSig(); }
05709     break;
05710 
05711   case 201:
05712 
05713 /* Line 1455 of yacc.c  */
05714 #line 1752 "vtkParse.y"
05715     {
05716       currentFunction->Name = vtkstrdup((yyvsp[(1) - (3)].str));
05717       currentFunction->Comment = vtkstrdup(getComment());
05718       vtkParseDebug("Parsed func", currentFunction->Name);
05719     }
05720     break;
05721 
05722   case 202:
05723 
05724 /* Line 1455 of yacc.c  */
05725 #line 1758 "vtkParse.y"
05726     { postSig("("); }
05727     break;
05728 
05729   case 209:
05730 
05731 /* Line 1455 of yacc.c  */
05732 #line 1767 "vtkParse.y"
05733     {
05734       postSig(");");
05735       closeSig();
05736       currentFunction->Name = vtkstrcat("~", (yyvsp[(1) - (1)].str));
05737       currentFunction->Comment = vtkstrdup(getComment());
05738       vtkParseDebug("Parsed func", currentFunction->Name);
05739     }
05740     break;
05741 
05742   case 210:
05743 
05744 /* Line 1455 of yacc.c  */
05745 #line 1775 "vtkParse.y"
05746     { postSig("(");}
05747     break;
05748 
05749   case 213:
05750 
05751 /* Line 1455 of yacc.c  */
05752 #line 1781 "vtkParse.y"
05753     {clearTypeId();}
05754     break;
05755 
05756   case 215:
05757 
05758 /* Line 1455 of yacc.c  */
05759 #line 1784 "vtkParse.y"
05760     { currentFunction->IsVariadic = 1; postSig("..."); }
05761     break;
05762 
05763   case 216:
05764 
05765 /* Line 1455 of yacc.c  */
05766 #line 1785 "vtkParse.y"
05767     { clearTypeId(); }
05768     break;
05769 
05770   case 217:
05771 
05772 /* Line 1455 of yacc.c  */
05773 #line 1786 "vtkParse.y"
05774     { clearTypeId(); postSig(", "); }
05775     break;
05776 
05777   case 219:
05778 
05779 /* Line 1455 of yacc.c  */
05780 #line 1789 "vtkParse.y"
05781     { markSig(); }
05782     break;
05783 
05784   case 220:
05785 
05786 /* Line 1455 of yacc.c  */
05787 #line 1791 "vtkParse.y"
05788     {
05789       int i = currentFunction->NumberOfArguments;
05790       ValueInfo *arg = (ValueInfo *)malloc(sizeof(ValueInfo));
05791       vtkParse_InitValue(arg);
05792 
05793       handle_complex_type(arg, (yyvsp[(2) - (3)].integer), (yyvsp[(3) - (3)].integer), copySig());
05794 
05795       if (i < MAX_ARGS)
05796         {
05797         currentFunction->ArgTypes[i] = arg->Type;
05798         currentFunction->ArgClasses[i] = arg->Class;
05799         currentFunction->ArgCounts[i] = arg->Count;
05800         }
05801 
05802       if (getVarName())
05803         {
05804         arg->Name = vtkstrdup(getVarName());
05805         }
05806 
05807       vtkParse_AddArgumentToFunction(currentFunction, arg);
05808     }
05809     break;
05810 
05811   case 221:
05812 
05813 /* Line 1455 of yacc.c  */
05814 #line 1813 "vtkParse.y"
05815     {
05816       int i = currentFunction->NumberOfArguments-1;
05817       if (getVarValue())
05818         {
05819         currentFunction->Arguments[i]->Value = vtkstrdup(getVarValue());
05820         }
05821     }
05822     break;
05823 
05824   case 222:
05825 
05826 /* Line 1455 of yacc.c  */
05827 #line 1821 "vtkParse.y"
05828     {
05829       int i = currentFunction->NumberOfArguments;
05830       ValueInfo *arg = (ValueInfo *)malloc(sizeof(ValueInfo));
05831 
05832       vtkParse_InitValue(arg);
05833 
05834       markSig();
05835       postSig("void (*");
05836       postSig((yyvsp[(1) - (1)].str));
05837       postSig(")(void *) ");
05838 
05839       handle_function_type(arg, (yyvsp[(1) - (1)].str), copySig());
05840 
05841       if (i < MAX_ARGS)
05842         {
05843         currentFunction->ArgTypes[i] = arg->Type;
05844         currentFunction->ArgClasses[i] = arg->Class;
05845         currentFunction->ArgCounts[i] = arg->Count;
05846         }
05847 
05848       vtkParse_AddArgumentToFunction(currentFunction, arg);
05849     }
05850     break;
05851 
05852   case 225:
05853 
05854 /* Line 1455 of yacc.c  */
05855 #line 1846 "vtkParse.y"
05856     {clearVarValue();}
05857     break;
05858 
05859   case 227:
05860 
05861 /* Line 1455 of yacc.c  */
05862 #line 1848 "vtkParse.y"
05863     { postSig("="); clearVarValue();}
05864     break;
05865 
05866   case 228:
05867 
05868 /* Line 1455 of yacc.c  */
05869 #line 1849 "vtkParse.y"
05870     { setVarValue((yyvsp[(3) - (3)].str)); }
05871     break;
05872 
05873   case 232:
05874 
05875 /* Line 1455 of yacc.c  */
05876 #line 1860 "vtkParse.y"
05877     {
05878        unsigned int type = getStorageType();
05879        ValueInfo *var = (ValueInfo *)malloc(sizeof(ValueInfo));
05880        vtkParse_InitValue(var);
05881        var->ItemType = VTK_VARIABLE_INFO;
05882        var->Access = access_level;
05883 
05884        handle_complex_type(var, type, (yyvsp[(1) - (2)].integer), getSig());
05885 
05886        var->Name = vtkstrdup(getVarName());
05887 
05888        if (getVarValue())
05889          {
05890          var->Value = vtkstrdup(getVarValue());
05891          }
05892 
05893        if ((var->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FUNCTION)
05894          {
05895          var->Type = var->Type;
05896          }
05897 
05898        /* Is this a constant? */
05899        if (((type & VTK_PARSE_CONST) != 0) && var->Value != NULL &&
05900            (((type & VTK_PARSE_INDIRECT) == 0) ||
05901             ((type & VTK_PARSE_INDIRECT) == VTK_PARSE_ARRAY)))
05902          {
05903          var->ItemType = VTK_CONSTANT_INFO;
05904          if (currentClass)
05905            {
05906            vtkParse_AddConstantToClass(currentClass, var);
05907            }
05908          else
05909            {
05910            vtkParse_AddConstantToNamespace(currentNamespace, var);
05911            }
05912          }
05913        /* This is a true variable i.e. not constant */
05914        else
05915          {
05916          if (currentClass)
05917            {
05918            vtkParse_AddVariableToClass(currentClass, var);
05919            }
05920          else
05921            {
05922            vtkParse_AddVariableToNamespace(currentNamespace, var);
05923            }
05924          }
05925      }
05926     break;
05927 
05928   case 236:
05929 
05930 /* Line 1455 of yacc.c  */
05931 #line 1914 "vtkParse.y"
05932     {postSig(", ");}
05933     break;
05934 
05935   case 238:
05936 
05937 /* Line 1455 of yacc.c  */
05938 #line 1917 "vtkParse.y"
05939     { setStorageTypeIndirection(0); }
05940     break;
05941 
05942   case 240:
05943 
05944 /* Line 1455 of yacc.c  */
05945 #line 1918 "vtkParse.y"
05946     { setStorageTypeIndirection((yyvsp[(1) - (1)].integer)); }
05947     break;
05948 
05949   case 242:
05950 
05951 /* Line 1455 of yacc.c  */
05952 #line 1922 "vtkParse.y"
05953     { (yyval.integer) = 0; }
05954     break;
05955 
05956   case 243:
05957 
05958 /* Line 1455 of yacc.c  */
05959 #line 1923 "vtkParse.y"
05960     { postSig(")"); }
05961     break;
05962 
05963   case 244:
05964 
05965 /* Line 1455 of yacc.c  */
05966 #line 1925 "vtkParse.y"
05967     {
05968          const char *scope = getScope();
05969          unsigned int parens = add_indirection((yyvsp[(1) - (5)].integer), (yyvsp[(2) - (5)].integer));
05970          if ((yyvsp[(5) - (5)].integer) == VTK_PARSE_FUNCTION) {
05971            if (scope) { scope = vtkstrndup(scope, strlen(scope) - 2); }
05972            getFunction()->Class = scope;
05973            (yyval.integer) = (parens | VTK_PARSE_FUNCTION); }
05974          else if ((yyvsp[(5) - (5)].integer) == VTK_PARSE_ARRAY) {
05975            (yyval.integer) = add_indirection_to_array(parens); }
05976        }
05977     break;
05978 
05979   case 245:
05980 
05981 /* Line 1455 of yacc.c  */
05982 #line 1937 "vtkParse.y"
05983     { (yyval.integer) = 0; }
05984     break;
05985 
05986   case 246:
05987 
05988 /* Line 1455 of yacc.c  */
05989 #line 1938 "vtkParse.y"
05990     { postSig(")"); }
05991     break;
05992 
05993   case 247:
05994 
05995 /* Line 1455 of yacc.c  */
05996 #line 1940 "vtkParse.y"
05997     {
05998          const char *scope = getScope();
05999          unsigned int parens = add_indirection((yyvsp[(1) - (5)].integer), (yyvsp[(2) - (5)].integer));
06000          if ((yyvsp[(5) - (5)].integer) == VTK_PARSE_FUNCTION) {
06001            if (scope) { scope = vtkstrndup(scope, strlen(scope) - 2); }
06002            getFunction()->Class = scope;
06003            (yyval.integer) = (parens | VTK_PARSE_FUNCTION); }
06004          else if ((yyvsp[(5) - (5)].integer) == VTK_PARSE_ARRAY) {
06005            (yyval.integer) = add_indirection_to_array(parens); }
06006        }
06007     break;
06008 
06009   case 248:
06010 
06011 /* Line 1455 of yacc.c  */
06012 #line 1951 "vtkParse.y"
06013     { postSig("("); scopeSig(""); (yyval.integer) = 0; }
06014     break;
06015 
06016   case 249:
06017 
06018 /* Line 1455 of yacc.c  */
06019 #line 1952 "vtkParse.y"
06020     { postSig("("); scopeSig((yyvsp[(1) - (1)].str)); postSig("*");
06021                (yyval.integer) = VTK_PARSE_POINTER; }
06022     break;
06023 
06024   case 250:
06025 
06026 /* Line 1455 of yacc.c  */
06027 #line 1954 "vtkParse.y"
06028     { postSig("("); scopeSig((yyvsp[(1) - (1)].str)); postSig("&");
06029                (yyval.integer) = VTK_PARSE_REF; }
06030     break;
06031 
06032   case 251:
06033 
06034 /* Line 1455 of yacc.c  */
06035 #line 1957 "vtkParse.y"
06036     { postSig("("); scopeSig((yyvsp[(1) - (1)].str)); postSig("*");
06037                (yyval.integer) = VTK_PARSE_POINTER; }
06038     break;
06039 
06040   case 252:
06041 
06042 /* Line 1455 of yacc.c  */
06043 #line 1959 "vtkParse.y"
06044     { postSig("("); scopeSig((yyvsp[(1) - (1)].str)); postSig("&");
06045                (yyval.integer) = VTK_PARSE_REF; }
06046     break;
06047 
06048   case 254:
06049 
06050 /* Line 1455 of yacc.c  */
06051 #line 1962 "vtkParse.y"
06052     { currentFunction->IsConst = 1; }
06053     break;
06054 
06055   case 255:
06056 
06057 /* Line 1455 of yacc.c  */
06058 #line 1964 "vtkParse.y"
06059     { (yyval.integer) = 0; }
06060     break;
06061 
06062   case 256:
06063 
06064 /* Line 1455 of yacc.c  */
06065 #line 1965 "vtkParse.y"
06066     { pushFunction(); postSig("("); }
06067     break;
06068 
06069   case 257:
06070 
06071 /* Line 1455 of yacc.c  */
06072 #line 1966 "vtkParse.y"
06073     { (yyval.integer) = VTK_PARSE_FUNCTION; postSig(")"); popFunction(); }
06074     break;
06075 
06076   case 258:
06077 
06078 /* Line 1455 of yacc.c  */
06079 #line 1967 "vtkParse.y"
06080     { (yyval.integer) = VTK_PARSE_ARRAY; }
06081     break;
06082 
06083   case 259:
06084 
06085 /* Line 1455 of yacc.c  */
06086 #line 1970 "vtkParse.y"
06087     { (yyval.integer) = (yyvsp[(1) - (1)].integer); }
06088     break;
06089 
06090   case 260:
06091 
06092 /* Line 1455 of yacc.c  */
06093 #line 1972 "vtkParse.y"
06094     { (yyval.integer) = add_indirection((yyvsp[(1) - (2)].integer), (yyvsp[(2) - (2)].integer));}
06095     break;
06096 
06097   case 261:
06098 
06099 /* Line 1455 of yacc.c  */
06100 #line 1975 "vtkParse.y"
06101     { (yyval.integer) = (yyvsp[(1) - (1)].integer); }
06102     break;
06103 
06104   case 262:
06105 
06106 /* Line 1455 of yacc.c  */
06107 #line 1977 "vtkParse.y"
06108     { (yyval.integer) = add_indirection((yyvsp[(1) - (2)].integer), (yyvsp[(2) - (2)].integer));}
06109     break;
06110 
06111   case 263:
06112 
06113 /* Line 1455 of yacc.c  */
06114 #line 1979 "vtkParse.y"
06115     {clearVarName(); chopSig();}
06116     break;
06117 
06118   case 265:
06119 
06120 /* Line 1455 of yacc.c  */
06121 #line 1981 "vtkParse.y"
06122     {setVarName((yyvsp[(1) - (1)].str));}
06123     break;
06124 
06125   case 266:
06126 
06127 /* Line 1455 of yacc.c  */
06128 #line 1983 "vtkParse.y"
06129     {clearArray();}
06130     break;
06131 
06132   case 268:
06133 
06134 /* Line 1455 of yacc.c  */
06135 #line 1985 "vtkParse.y"
06136     {clearArray();}
06137     break;
06138 
06139   case 270:
06140 
06141 /* Line 1455 of yacc.c  */
06142 #line 1987 "vtkParse.y"
06143     {postSig("[");}
06144     break;
06145 
06146   case 271:
06147 
06148 /* Line 1455 of yacc.c  */
06149 #line 1987 "vtkParse.y"
06150     {postSig("]");}
06151     break;
06152 
06153   case 274:
06154 
06155 /* Line 1455 of yacc.c  */
06156 #line 1991 "vtkParse.y"
06157     {pushArraySize("");}
06158     break;
06159 
06160   case 275:
06161 
06162 /* Line 1455 of yacc.c  */
06163 #line 1992 "vtkParse.y"
06164     {pushArraySize((yyvsp[(1) - (1)].str));}
06165     break;
06166 
06167   case 276:
06168 
06169 /* Line 1455 of yacc.c  */
06170 #line 1998 "vtkParse.y"
06171     {postSig((yyvsp[(1) - (1)].str));}
06172     break;
06173 
06174   case 277:
06175 
06176 /* Line 1455 of yacc.c  */
06177 #line 1999 "vtkParse.y"
06178     {postSig((yyvsp[(1) - (1)].str));}
06179     break;
06180 
06181   case 278:
06182 
06183 /* Line 1455 of yacc.c  */
06184 #line 2000 "vtkParse.y"
06185     {postSig((yyvsp[(1) - (1)].str));}
06186     break;
06187 
06188   case 279:
06189 
06190 /* Line 1455 of yacc.c  */
06191 #line 2001 "vtkParse.y"
06192     {postSig((yyvsp[(1) - (1)].str));}
06193     break;
06194 
06195   case 280:
06196 
06197 /* Line 1455 of yacc.c  */
06198 #line 2002 "vtkParse.y"
06199     {postSig((yyvsp[(1) - (1)].str));}
06200     break;
06201 
06202   case 281:
06203 
06204 /* Line 1455 of yacc.c  */
06205 #line 2003 "vtkParse.y"
06206     {postSig((yyvsp[(1) - (1)].str));}
06207     break;
06208 
06209   case 282:
06210 
06211 /* Line 1455 of yacc.c  */
06212 #line 2004 "vtkParse.y"
06213     {postSig((yyvsp[(1) - (1)].str));}
06214     break;
06215 
06216   case 283:
06217 
06218 /* Line 1455 of yacc.c  */
06219 #line 2005 "vtkParse.y"
06220     {postSig((yyvsp[(1) - (1)].str));}
06221     break;
06222 
06223   case 284:
06224 
06225 /* Line 1455 of yacc.c  */
06226 #line 2006 "vtkParse.y"
06227     {postSig((yyvsp[(1) - (1)].str));}
06228     break;
06229 
06230   case 285:
06231 
06232 /* Line 1455 of yacc.c  */
06233 #line 2009 "vtkParse.y"
06234     {(yyval.str) = "vtkTypeInt8";}
06235     break;
06236 
06237   case 286:
06238 
06239 /* Line 1455 of yacc.c  */
06240 #line 2010 "vtkParse.y"
06241     {(yyval.str) = "vtkTypeUInt8";}
06242     break;
06243 
06244   case 287:
06245 
06246 /* Line 1455 of yacc.c  */
06247 #line 2011 "vtkParse.y"
06248     {(yyval.str) = "vtkTypeInt16";}
06249     break;
06250 
06251   case 288:
06252 
06253 /* Line 1455 of yacc.c  */
06254 #line 2012 "vtkParse.y"
06255     {(yyval.str) = "vtkTypeUInt16";}
06256     break;
06257 
06258   case 289:
06259 
06260 /* Line 1455 of yacc.c  */
06261 #line 2013 "vtkParse.y"
06262     {(yyval.str) = "vtkTypeInt32";}
06263     break;
06264 
06265   case 290:
06266 
06267 /* Line 1455 of yacc.c  */
06268 #line 2014 "vtkParse.y"
06269     {(yyval.str) = "vtkTypeUInt32";}
06270     break;
06271 
06272   case 291:
06273 
06274 /* Line 1455 of yacc.c  */
06275 #line 2015 "vtkParse.y"
06276     {(yyval.str) = "vtkTypeInt64";}
06277     break;
06278 
06279   case 292:
06280 
06281 /* Line 1455 of yacc.c  */
06282 #line 2016 "vtkParse.y"
06283     {(yyval.str) = "vtkTypeUInt64";}
06284     break;
06285 
06286   case 293:
06287 
06288 /* Line 1455 of yacc.c  */
06289 #line 2017 "vtkParse.y"
06290     {(yyval.str) = "vtkTypeFloat32";}
06291     break;
06292 
06293   case 294:
06294 
06295 /* Line 1455 of yacc.c  */
06296 #line 2018 "vtkParse.y"
06297     {(yyval.str) = "vtkTypeFloat64";}
06298     break;
06299 
06300   case 295:
06301 
06302 /* Line 1455 of yacc.c  */
06303 #line 2021 "vtkParse.y"
06304     {(yyval.str) = "vtkIdType";}
06305     break;
06306 
06307   case 296:
06308 
06309 /* Line 1455 of yacc.c  */
06310 #line 2022 "vtkParse.y"
06311     {(yyval.str) = "vtkFloatingPointType";}
06312     break;
06313 
06314   case 297:
06315 
06316 /* Line 1455 of yacc.c  */
06317 #line 2029 "vtkParse.y"
06318     {(yyval.integer) = (yyvsp[(1) - (1)].integer); setStorageType((yyval.integer));}
06319     break;
06320 
06321   case 298:
06322 
06323 /* Line 1455 of yacc.c  */
06324 #line 2030 "vtkParse.y"
06325     {(yyval.integer) = (yyvsp[(2) - (2)].integer); setStorageType((yyval.integer));}
06326     break;
06327 
06328   case 299:
06329 
06330 /* Line 1455 of yacc.c  */
06331 #line 2031 "vtkParse.y"
06332     {(yyval.integer) = (yyvsp[(2) - (2)].integer); setStorageType((yyval.integer));}
06333     break;
06334 
06335   case 300:
06336 
06337 /* Line 1455 of yacc.c  */
06338 #line 2033 "vtkParse.y"
06339     {(yyval.integer) = (yyvsp[(3) - (3)].integer); setStorageType((yyval.integer));}
06340     break;
06341 
06342   case 301:
06343 
06344 /* Line 1455 of yacc.c  */
06345 #line 2034 "vtkParse.y"
06346     {(yyval.integer) = (yyvsp[(2) - (2)].integer); setStorageType((yyval.integer));}
06347     break;
06348 
06349   case 302:
06350 
06351 /* Line 1455 of yacc.c  */
06352 #line 2035 "vtkParse.y"
06353     {(yyval.integer) = ((yyvsp[(1) - (2)].integer) | (yyvsp[(2) - (2)].integer));
06354       setStorageType((yyval.integer));}
06355     break;
06356 
06357   case 303:
06358 
06359 /* Line 1455 of yacc.c  */
06360 #line 2037 "vtkParse.y"
06361     {(yyval.integer) = ((yyvsp[(2) - (3)].integer) | (yyvsp[(3) - (3)].integer));
06362       setStorageType((yyval.integer));}
06363     break;
06364 
06365   case 304:
06366 
06367 /* Line 1455 of yacc.c  */
06368 #line 2041 "vtkParse.y"
06369     {postSig("static "); (yyval.integer) = VTK_PARSE_STATIC; }
06370     break;
06371 
06372   case 305:
06373 
06374 /* Line 1455 of yacc.c  */
06375 #line 2042 "vtkParse.y"
06376     {postSig("static "); (yyval.integer) = VTK_PARSE_STATIC; }
06377     break;
06378 
06379   case 306:
06380 
06381 /* Line 1455 of yacc.c  */
06382 #line 2044 "vtkParse.y"
06383     {(yyval.integer) = (yyvsp[(1) - (1)].integer);}
06384     break;
06385 
06386   case 307:
06387 
06388 /* Line 1455 of yacc.c  */
06389 #line 2045 "vtkParse.y"
06390     {(yyval.integer) = ((yyvsp[(1) - (2)].integer) | (yyvsp[(2) - (2)].integer));}
06391     break;
06392 
06393   case 308:
06394 
06395 /* Line 1455 of yacc.c  */
06396 #line 2047 "vtkParse.y"
06397     {(yyval.integer) = (yyvsp[(1) - (1)].integer);}
06398     break;
06399 
06400   case 309:
06401 
06402 /* Line 1455 of yacc.c  */
06403 #line 2048 "vtkParse.y"
06404     {(yyval.integer) = (VTK_PARSE_CONST | (yyvsp[(2) - (2)].integer));}
06405     break;
06406 
06407   case 310:
06408 
06409 /* Line 1455 of yacc.c  */
06410 #line 2049 "vtkParse.y"
06411     {(yyval.integer) = (VTK_PARSE_CONST | (yyvsp[(1) - (2)].integer));}
06412     break;
06413 
06414   case 311:
06415 
06416 /* Line 1455 of yacc.c  */
06417 #line 2051 "vtkParse.y"
06418     {postSig("const ");}
06419     break;
06420 
06421   case 313:
06422 
06423 /* Line 1455 of yacc.c  */
06424 #line 2055 "vtkParse.y"
06425     {postSig(" "); setTypeId((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_UNKNOWN;}
06426     break;
06427 
06428   case 314:
06429 
06430 /* Line 1455 of yacc.c  */
06431 #line 2057 "vtkParse.y"
06432     {postSig(" "); setTypeId((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_UNKNOWN;}
06433     break;
06434 
06435   case 315:
06436 
06437 /* Line 1455 of yacc.c  */
06438 #line 2058 "vtkParse.y"
06439     {postSig("typename ");}
06440     break;
06441 
06442   case 316:
06443 
06444 /* Line 1455 of yacc.c  */
06445 #line 2059 "vtkParse.y"
06446     {postSig(" "); setTypeId((yyvsp[(3) - (3)].str)); (yyval.integer) = VTK_PARSE_UNKNOWN;}
06447     break;
06448 
06449   case 317:
06450 
06451 /* Line 1455 of yacc.c  */
06452 #line 2062 "vtkParse.y"
06453     { markSig(); postSig((yyvsp[(1) - (2)].str)); postSig("<");}
06454     break;
06455 
06456   case 318:
06457 
06458 /* Line 1455 of yacc.c  */
06459 #line 2063 "vtkParse.y"
06460     {chopSig(); if (getSig()[strlen(getSig())-1] == '>') { postSig(" "); }
06461       postSig(">"); (yyval.str) = vtkstrdup(copySig()); clearTypeId();}
06462     break;
06463 
06464   case 319:
06465 
06466 /* Line 1455 of yacc.c  */
06467 #line 2065 "vtkParse.y"
06468     { markSig(); postSig((yyvsp[(1) - (2)].str)); postSig("<");}
06469     break;
06470 
06471   case 320:
06472 
06473 /* Line 1455 of yacc.c  */
06474 #line 2066 "vtkParse.y"
06475     {chopSig(); if (getSig()[strlen(getSig())-1] == '>') { postSig(" "); }
06476       postSig(">"); (yyval.str) = vtkstrdup(copySig()); clearTypeId();}
06477     break;
06478 
06479   case 321:
06480 
06481 /* Line 1455 of yacc.c  */
06482 #line 2068 "vtkParse.y"
06483     { markSig(); postSig((yyvsp[(1) - (2)].str)); postSig("<");}
06484     break;
06485 
06486   case 322:
06487 
06488 /* Line 1455 of yacc.c  */
06489 #line 2069 "vtkParse.y"
06490     {chopSig(); if (getSig()[strlen(getSig())-1] == '>') { postSig(" "); }
06491       postSig(">"); (yyval.str) = vtkstrdup(copySig()); clearTypeId();}
06492     break;
06493 
06494   case 324:
06495 
06496 /* Line 1455 of yacc.c  */
06497 #line 2073 "vtkParse.y"
06498     {chopSig(); postSig(", ");}
06499     break;
06500 
06501   case 327:
06502 
06503 /* Line 1455 of yacc.c  */
06504 #line 2076 "vtkParse.y"
06505     {postSig((yyvsp[(1) - (1)].str));}
06506     break;
06507 
06508   case 328:
06509 
06510 /* Line 1455 of yacc.c  */
06511 #line 2078 "vtkParse.y"
06512     {postSig((yyvsp[(1) - (1)].str));}
06513     break;
06514 
06515   case 329:
06516 
06517 /* Line 1455 of yacc.c  */
06518 #line 2079 "vtkParse.y"
06519     {postSig((yyvsp[(1) - (1)].str));}
06520     break;
06521 
06522   case 330:
06523 
06524 /* Line 1455 of yacc.c  */
06525 #line 2080 "vtkParse.y"
06526     {postSig((yyvsp[(1) - (1)].str));}
06527     break;
06528 
06529   case 331:
06530 
06531 /* Line 1455 of yacc.c  */
06532 #line 2081 "vtkParse.y"
06533     {postSig((yyvsp[(1) - (1)].str));}
06534     break;
06535 
06536   case 332:
06537 
06538 /* Line 1455 of yacc.c  */
06539 #line 2082 "vtkParse.y"
06540     {postSig((yyvsp[(1) - (1)].str));}
06541     break;
06542 
06543   case 333:
06544 
06545 /* Line 1455 of yacc.c  */
06546 #line 2083 "vtkParse.y"
06547     {postSig((yyvsp[(1) - (1)].str));}
06548     break;
06549 
06550   case 334:
06551 
06552 /* Line 1455 of yacc.c  */
06553 #line 2084 "vtkParse.y"
06554     {postSig((yyvsp[(1) - (1)].str));}
06555     break;
06556 
06557   case 337:
06558 
06559 /* Line 1455 of yacc.c  */
06560 #line 2089 "vtkParse.y"
06561     {
06562              (yyval.str) = vtkstrcat3((yyvsp[(1) - (3)].str), "::", (yyvsp[(3) - (3)].str));
06563              preScopeSig((yyvsp[(1) - (3)].str));
06564            }
06565     break;
06566 
06567   case 338:
06568 
06569 /* Line 1455 of yacc.c  */
06570 #line 2094 "vtkParse.y"
06571     {
06572              (yyval.str) = vtkstrcat3((yyvsp[(1) - (3)].str), "::", (yyvsp[(3) - (3)].str));
06573              preScopeSig("");
06574            }
06575     break;
06576 
06577   case 346:
06578 
06579 /* Line 1455 of yacc.c  */
06580 #line 2116 "vtkParse.y"
06581     { postSig("&"); (yyval.integer) = VTK_PARSE_REF;}
06582     break;
06583 
06584   case 347:
06585 
06586 /* Line 1455 of yacc.c  */
06587 #line 2117 "vtkParse.y"
06588     { postSig("&"); (yyval.integer) = ((yyvsp[(1) - (2)].integer) | VTK_PARSE_REF);}
06589     break;
06590 
06591   case 348:
06592 
06593 /* Line 1455 of yacc.c  */
06594 #line 2118 "vtkParse.y"
06595     { (yyval.integer) = (yyvsp[(1) - (1)].integer); }
06596     break;
06597 
06598   case 349:
06599 
06600 /* Line 1455 of yacc.c  */
06601 #line 2123 "vtkParse.y"
06602     { (yyval.integer) = (yyvsp[(1) - (1)].integer); }
06603     break;
06604 
06605   case 350:
06606 
06607 /* Line 1455 of yacc.c  */
06608 #line 2125 "vtkParse.y"
06609     {
06610        unsigned int n;
06611        n = (((yyvsp[(1) - (2)].integer) << 2) | (yyvsp[(2) - (2)].integer));
06612        if ((n & VTK_PARSE_INDIRECT) != n)
06613          {
06614          n = VTK_PARSE_BAD_INDIRECT;
06615          }
06616       (yyval.integer) = n;
06617     }
06618     break;
06619 
06620   case 351:
06621 
06622 /* Line 1455 of yacc.c  */
06623 #line 2136 "vtkParse.y"
06624     { postSig("*"); (yyval.integer) = VTK_PARSE_POINTER; }
06625     break;
06626 
06627   case 352:
06628 
06629 /* Line 1455 of yacc.c  */
06630 #line 2137 "vtkParse.y"
06631     { postSig("*const "); (yyval.integer) = VTK_PARSE_CONST_POINTER; }
06632     break;
06633 
06634   case 353:
06635 
06636 /* Line 1455 of yacc.c  */
06637 #line 2140 "vtkParse.y"
06638     { (yyval.integer) = (yyvsp[(1) - (1)].integer);}
06639     break;
06640 
06641   case 354:
06642 
06643 /* Line 1455 of yacc.c  */
06644 #line 2141 "vtkParse.y"
06645     { (yyval.integer) = (yyvsp[(2) - (2)].integer); }
06646     break;
06647 
06648   case 355:
06649 
06650 /* Line 1455 of yacc.c  */
06651 #line 2142 "vtkParse.y"
06652     { (yyval.integer) = (yyvsp[(2) - (2)].integer); }
06653     break;
06654 
06655   case 356:
06656 
06657 /* Line 1455 of yacc.c  */
06658 #line 2143 "vtkParse.y"
06659     { typeSig((yyvsp[(2) - (2)].str)); (yyval.integer) = VTK_PARSE_UNKNOWN; }
06660     break;
06661 
06662   case 357:
06663 
06664 /* Line 1455 of yacc.c  */
06665 #line 2144 "vtkParse.y"
06666     { typeSig((yyvsp[(2) - (2)].str)); (yyval.integer) = VTK_PARSE_UNKNOWN; }
06667     break;
06668 
06669   case 358:
06670 
06671 /* Line 1455 of yacc.c  */
06672 #line 2147 "vtkParse.y"
06673     { (yyval.integer) = (yyvsp[(1) - (1)].integer);}
06674     break;
06675 
06676   case 359:
06677 
06678 /* Line 1455 of yacc.c  */
06679 #line 2148 "vtkParse.y"
06680     { (yyval.integer) = (yyvsp[(1) - (1)].integer);}
06681     break;
06682 
06683   case 360:
06684 
06685 /* Line 1455 of yacc.c  */
06686 #line 2151 "vtkParse.y"
06687     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_STRING;}
06688     break;
06689 
06690   case 361:
06691 
06692 /* Line 1455 of yacc.c  */
06693 #line 2152 "vtkParse.y"
06694     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_UNICODE_STRING;}
06695     break;
06696 
06697   case 362:
06698 
06699 /* Line 1455 of yacc.c  */
06700 #line 2153 "vtkParse.y"
06701     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_OSTREAM; }
06702     break;
06703 
06704   case 363:
06705 
06706 /* Line 1455 of yacc.c  */
06707 #line 2154 "vtkParse.y"
06708     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_ISTREAM; }
06709     break;
06710 
06711   case 364:
06712 
06713 /* Line 1455 of yacc.c  */
06714 #line 2155 "vtkParse.y"
06715     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_UNKNOWN; }
06716     break;
06717 
06718   case 365:
06719 
06720 /* Line 1455 of yacc.c  */
06721 #line 2156 "vtkParse.y"
06722     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_OBJECT; }
06723     break;
06724 
06725   case 366:
06726 
06727 /* Line 1455 of yacc.c  */
06728 #line 2157 "vtkParse.y"
06729     { typeSig((yyvsp[(1) - (1)].str)); (yyval.integer) = VTK_PARSE_QOBJECT; }
06730     break;
06731 
06732   case 367:
06733 
06734 /* Line 1455 of yacc.c  */
06735 #line 2160 "vtkParse.y"
06736     { typeSig("void"); (yyval.integer) = VTK_PARSE_VOID;}
06737     break;
06738 
06739   case 368:
06740 
06741 /* Line 1455 of yacc.c  */
06742 #line 2161 "vtkParse.y"
06743     { typeSig("bool"); (yyval.integer) = VTK_PARSE_BOOL;}
06744     break;
06745 
06746   case 369:
06747 
06748 /* Line 1455 of yacc.c  */
06749 #line 2162 "vtkParse.y"
06750     { typeSig("ssize_t"); (yyval.integer) = VTK_PARSE_SSIZE_T;}
06751     break;
06752 
06753   case 370:
06754 
06755 /* Line 1455 of yacc.c  */
06756 #line 2163 "vtkParse.y"
06757     { typeSig("size_t"); (yyval.integer) = VTK_PARSE_SIZE_T;}
06758     break;
06759 
06760   case 371:
06761 
06762 /* Line 1455 of yacc.c  */
06763 #line 2164 "vtkParse.y"
06764     { typeSig("vtkTypeInt8"); (yyval.integer) = VTK_PARSE_INT8; }
06765     break;
06766 
06767   case 372:
06768 
06769 /* Line 1455 of yacc.c  */
06770 #line 2165 "vtkParse.y"
06771     { typeSig("vtkTypeUInt8"); (yyval.integer) = VTK_PARSE_UINT8; }
06772     break;
06773 
06774   case 373:
06775 
06776 /* Line 1455 of yacc.c  */
06777 #line 2166 "vtkParse.y"
06778     { typeSig("vtkTypeInt16"); (yyval.integer) = VTK_PARSE_INT16; }
06779     break;
06780 
06781   case 374:
06782 
06783 /* Line 1455 of yacc.c  */
06784 #line 2167 "vtkParse.y"
06785     { typeSig("vtkTypeUInt16"); (yyval.integer) = VTK_PARSE_UINT16; }
06786     break;
06787 
06788   case 375:
06789 
06790 /* Line 1455 of yacc.c  */
06791 #line 2168 "vtkParse.y"
06792     { typeSig("vtkTypeInt32"); (yyval.integer) = VTK_PARSE_INT32; }
06793     break;
06794 
06795   case 376:
06796 
06797 /* Line 1455 of yacc.c  */
06798 #line 2169 "vtkParse.y"
06799     { typeSig("vtkTypeUInt32"); (yyval.integer) = VTK_PARSE_UINT32; }
06800     break;
06801 
06802   case 377:
06803 
06804 /* Line 1455 of yacc.c  */
06805 #line 2170 "vtkParse.y"
06806     { typeSig("vtkTypeInt64"); (yyval.integer) = VTK_PARSE_INT64; }
06807     break;
06808 
06809   case 378:
06810 
06811 /* Line 1455 of yacc.c  */
06812 #line 2171 "vtkParse.y"
06813     { typeSig("vtkTypeUInt64"); (yyval.integer) = VTK_PARSE_UINT64; }
06814     break;
06815 
06816   case 379:
06817 
06818 /* Line 1455 of yacc.c  */
06819 #line 2172 "vtkParse.y"
06820     { typeSig("vtkTypeFloat32"); (yyval.integer) = VTK_PARSE_FLOAT32; }
06821     break;
06822 
06823   case 380:
06824 
06825 /* Line 1455 of yacc.c  */
06826 #line 2173 "vtkParse.y"
06827     { typeSig("vtkTypeFloat64"); (yyval.integer) = VTK_PARSE_FLOAT64; }
06828     break;
06829 
06830   case 381:
06831 
06832 /* Line 1455 of yacc.c  */
06833 #line 2174 "vtkParse.y"
06834     { typeSig("vtkIdType"); (yyval.integer) = VTK_PARSE_ID_TYPE;}
06835     break;
06836 
06837   case 382:
06838 
06839 /* Line 1455 of yacc.c  */
06840 #line 2175 "vtkParse.y"
06841     { typeSig("double"); (yyval.integer) = VTK_PARSE_DOUBLE;}
06842     break;
06843 
06844   case 383:
06845 
06846 /* Line 1455 of yacc.c  */
06847 #line 2176 "vtkParse.y"
06848     { typeSig("float"); (yyval.integer) = VTK_PARSE_FLOAT;}
06849     break;
06850 
06851   case 384:
06852 
06853 /* Line 1455 of yacc.c  */
06854 #line 2177 "vtkParse.y"
06855     { typeSig("double"); (yyval.integer) = VTK_PARSE_DOUBLE;}
06856     break;
06857 
06858   case 385:
06859 
06860 /* Line 1455 of yacc.c  */
06861 #line 2178 "vtkParse.y"
06862     { typeSig("long double"); (yyval.integer) = VTK_PARSE_UNKNOWN;}
06863     break;
06864 
06865   case 386:
06866 
06867 /* Line 1455 of yacc.c  */
06868 #line 2179 "vtkParse.y"
06869     { typeSig("char"); (yyval.integer) = VTK_PARSE_CHAR;}
06870     break;
06871 
06872   case 387:
06873 
06874 /* Line 1455 of yacc.c  */
06875 #line 2180 "vtkParse.y"
06876     { typeSig("signed char"); (yyval.integer) = VTK_PARSE_SIGNED_CHAR;}
06877     break;
06878 
06879   case 388:
06880 
06881 /* Line 1455 of yacc.c  */
06882 #line 2182 "vtkParse.y"
06883     { typeSig("unsigned char"); (yyval.integer) = VTK_PARSE_UNSIGNED_CHAR;}
06884     break;
06885 
06886   case 389:
06887 
06888 /* Line 1455 of yacc.c  */
06889 #line 2183 "vtkParse.y"
06890     { typeSig("int"); (yyval.integer) = VTK_PARSE_INT;}
06891     break;
06892 
06893   case 390:
06894 
06895 /* Line 1455 of yacc.c  */
06896 #line 2185 "vtkParse.y"
06897     { typeSig("unsigned int"); (yyval.integer) = VTK_PARSE_UNSIGNED_INT;}
06898     break;
06899 
06900   case 391:
06901 
06902 /* Line 1455 of yacc.c  */
06903 #line 2186 "vtkParse.y"
06904     { typeSig("short"); (yyval.integer) = VTK_PARSE_SHORT;}
06905     break;
06906 
06907   case 392:
06908 
06909 /* Line 1455 of yacc.c  */
06910 #line 2188 "vtkParse.y"
06911     { typeSig("unsigned short"); (yyval.integer) = VTK_PARSE_UNSIGNED_SHORT;}
06912     break;
06913 
06914   case 393:
06915 
06916 /* Line 1455 of yacc.c  */
06917 #line 2189 "vtkParse.y"
06918     { typeSig("long"); (yyval.integer) = VTK_PARSE_LONG;}
06919     break;
06920 
06921   case 394:
06922 
06923 /* Line 1455 of yacc.c  */
06924 #line 2191 "vtkParse.y"
06925     { typeSig("unsigned long"); (yyval.integer) = VTK_PARSE_UNSIGNED_LONG;}
06926     break;
06927 
06928   case 395:
06929 
06930 /* Line 1455 of yacc.c  */
06931 #line 2192 "vtkParse.y"
06932     { typeSig("long long"); (yyval.integer) = VTK_PARSE_LONG_LONG;}
06933     break;
06934 
06935   case 396:
06936 
06937 /* Line 1455 of yacc.c  */
06938 #line 2194 "vtkParse.y"
06939     {typeSig("unsigned long long");(yyval.integer)=VTK_PARSE_UNSIGNED_LONG_LONG;}
06940     break;
06941 
06942   case 397:
06943 
06944 /* Line 1455 of yacc.c  */
06945 #line 2195 "vtkParse.y"
06946     { typeSig("__int64"); (yyval.integer) = VTK_PARSE___INT64;}
06947     break;
06948 
06949   case 398:
06950 
06951 /* Line 1455 of yacc.c  */
06952 #line 2197 "vtkParse.y"
06953     { typeSig("unsigned __int64"); (yyval.integer) = VTK_PARSE_UNSIGNED___INT64;}
06954     break;
06955 
06956   case 399:
06957 
06958 /* Line 1455 of yacc.c  */
06959 #line 2198 "vtkParse.y"
06960     { typeSig("int"); (yyval.integer) = VTK_PARSE_INT; }
06961     break;
06962 
06963   case 400:
06964 
06965 /* Line 1455 of yacc.c  */
06966 #line 2199 "vtkParse.y"
06967     { typeSig("unsigned int"); (yyval.integer) = VTK_PARSE_UNSIGNED_INT; }
06968     break;
06969 
06970   case 401:
06971 
06972 /* Line 1455 of yacc.c  */
06973 #line 2205 "vtkParse.y"
06974     { (yyval.str) = (yyvsp[(1) - (1)].str); }
06975     break;
06976 
06977   case 402:
06978 
06979 /* Line 1455 of yacc.c  */
06980 #line 2206 "vtkParse.y"
06981     { postSig("{ "); }
06982     break;
06983 
06984   case 403:
06985 
06986 /* Line 1455 of yacc.c  */
06987 #line 2207 "vtkParse.y"
06988     {
06989           postSig("}");
06990           (yyval.str) = vtkstrcat4("{ ", (yyvsp[(3) - (6)].str), (yyvsp[(4) - (6)].str), " }");
06991         }
06992     break;
06993 
06994   case 406:
06995 
06996 /* Line 1455 of yacc.c  */
06997 #line 2214 "vtkParse.y"
06998     {(yyval.str) = "";}
06999     break;
07000 
07001   case 407:
07002 
07003 /* Line 1455 of yacc.c  */
07004 #line 2215 "vtkParse.y"
07005     { postSig(", "); }
07006     break;
07007 
07008   case 408:
07009 
07010 /* Line 1455 of yacc.c  */
07011 #line 2216 "vtkParse.y"
07012     {
07013           (yyval.str) = vtkstrcat3((yyvsp[(1) - (4)].str), ", ", (yyvsp[(4) - (4)].str));
07014         }
07015     break;
07016 
07017   case 409:
07018 
07019 /* Line 1455 of yacc.c  */
07020 #line 2220 "vtkParse.y"
07021     {(yyval.str) = (yyvsp[(1) - (1)].str);}
07022     break;
07023 
07024   case 410:
07025 
07026 /* Line 1455 of yacc.c  */
07027 #line 2221 "vtkParse.y"
07028     {postSig("+");}
07029     break;
07030 
07031   case 411:
07032 
07033 /* Line 1455 of yacc.c  */
07034 #line 2221 "vtkParse.y"
07035     {(yyval.str) = (yyvsp[(3) - (3)].str);}
07036     break;
07037 
07038   case 412:
07039 
07040 /* Line 1455 of yacc.c  */
07041 #line 2222 "vtkParse.y"
07042     {postSig("-");}
07043     break;
07044 
07045   case 413:
07046 
07047 /* Line 1455 of yacc.c  */
07048 #line 2223 "vtkParse.y"
07049     {
07050              (yyval.str) = vtkstrcat("-", (yyvsp[(3) - (3)].str));
07051              }
07052     break;
07053 
07054   case 414:
07055 
07056 /* Line 1455 of yacc.c  */
07057 #line 2226 "vtkParse.y"
07058     {(yyval.str) = (yyvsp[(1) - (1)].str); postSig((yyvsp[(1) - (1)].str));}
07059     break;
07060 
07061   case 415:
07062 
07063 /* Line 1455 of yacc.c  */
07064 #line 2227 "vtkParse.y"
07065     {postSig("(");}
07066     break;
07067 
07068   case 416:
07069 
07070 /* Line 1455 of yacc.c  */
07071 #line 2227 "vtkParse.y"
07072     {postSig(")"); (yyval.str) = (yyvsp[(3) - (4)].str);}
07073     break;
07074 
07075   case 417:
07076 
07077 /* Line 1455 of yacc.c  */
07078 #line 2228 "vtkParse.y"
07079     {postSig((yyvsp[(1) - (2)].str)); postSig("<");}
07080     break;
07081 
07082   case 418:
07083 
07084 /* Line 1455 of yacc.c  */
07085 #line 2230 "vtkParse.y"
07086     {
07087              chopSig();
07088              if (getSig()[strlen(getSig())-1] == '>') { postSig(" "); }
07089              postSig(">(");
07090              }
07091     break;
07092 
07093   case 419:
07094 
07095 /* Line 1455 of yacc.c  */
07096 #line 2236 "vtkParse.y"
07097     {
07098              postSig(")");
07099              if (getTypeId()[strlen(getTypeId())-1] == '>')
07100                {
07101                (yyval.str) = vtkstrcat6(
07102                  (yyvsp[(1) - (9)].str), "<", getTypeId(), " >(", (yyvsp[(8) - (9)].str), ")");
07103                }
07104              else
07105                {
07106                (yyval.str) = vtkstrcat6(
07107                  (yyvsp[(1) - (9)].str), "<", getTypeId(), ">(", (yyvsp[(8) - (9)].str), ")");
07108                }
07109              }
07110     break;
07111 
07112   case 420:
07113 
07114 /* Line 1455 of yacc.c  */
07115 #line 2250 "vtkParse.y"
07116     { (yyval.str) = "static_cast"; }
07117     break;
07118 
07119   case 421:
07120 
07121 /* Line 1455 of yacc.c  */
07122 #line 2251 "vtkParse.y"
07123     { (yyval.str) = "const_cast"; }
07124     break;
07125 
07126   case 422:
07127 
07128 /* Line 1455 of yacc.c  */
07129 #line 2252 "vtkParse.y"
07130     { (yyval.str) = "dynamic_cast"; }
07131     break;
07132 
07133   case 423:
07134 
07135 /* Line 1455 of yacc.c  */
07136 #line 2253 "vtkParse.y"
07137     { (yyval.str) = "reinterpret_cast"; }
07138     break;
07139 
07140   case 424:
07141 
07142 /* Line 1455 of yacc.c  */
07143 #line 2255 "vtkParse.y"
07144     {(yyval.str) = (yyvsp[(1) - (1)].str);}
07145     break;
07146 
07147   case 425:
07148 
07149 /* Line 1455 of yacc.c  */
07150 #line 2257 "vtkParse.y"
07151     { (yyval.str) = vtkstrcat((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)); }
07152     break;
07153 
07154   case 426:
07155 
07156 /* Line 1455 of yacc.c  */
07157 #line 2259 "vtkParse.y"
07158     {(yyval.str) = (yyvsp[(1) - (1)].str); postSig((yyvsp[(1) - (1)].str));}
07159     break;
07160 
07161   case 427:
07162 
07163 /* Line 1455 of yacc.c  */
07164 #line 2260 "vtkParse.y"
07165     {(yyval.str) = (yyvsp[(1) - (1)].str); postSig((yyvsp[(1) - (1)].str));}
07166     break;
07167 
07168   case 428:
07169 
07170 /* Line 1455 of yacc.c  */
07171 #line 2261 "vtkParse.y"
07172     {(yyval.str) = (yyvsp[(1) - (1)].str); postSig((yyvsp[(1) - (1)].str));}
07173     break;
07174 
07175   case 429:
07176 
07177 /* Line 1455 of yacc.c  */
07178 #line 2262 "vtkParse.y"
07179     {(yyval.str) = (yyvsp[(1) - (1)].str); postSig((yyvsp[(1) - (1)].str));}
07180     break;
07181 
07182   case 430:
07183 
07184 /* Line 1455 of yacc.c  */
07185 #line 2263 "vtkParse.y"
07186     {(yyval.str) = (yyvsp[(1) - (1)].str); postSig((yyvsp[(1) - (1)].str));}
07187     break;
07188 
07189   case 431:
07190 
07191 /* Line 1455 of yacc.c  */
07192 #line 2264 "vtkParse.y"
07193     {(yyval.str) = (yyvsp[(1) - (1)].str); postSig((yyvsp[(1) - (1)].str));}
07194     break;
07195 
07196   case 432:
07197 
07198 /* Line 1455 of yacc.c  */
07199 #line 2266 "vtkParse.y"
07200     { (yyval.str) = vtkstrdup(add_const_scope((yyvsp[(1) - (1)].str))); }
07201     break;
07202 
07203   case 433:
07204 
07205 /* Line 1455 of yacc.c  */
07206 #line 2275 "vtkParse.y"
07207     {preSig("void Set"); postSig("(");}
07208     break;
07209 
07210   case 434:
07211 
07212 /* Line 1455 of yacc.c  */
07213 #line 2276 "vtkParse.y"
07214     {
07215    postSig("a);");
07216    currentFunction->Macro = "vtkSetMacro";
07217    currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (7)].str));
07218    currentFunction->Comment = vtkstrdup(getComment());
07219    add_argument(currentFunction, (yyvsp[(6) - (7)].integer), getTypeId(), 0);
07220    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
07221    output_function();
07222    }
07223     break;
07224 
07225   case 435:
07226 
07227 /* Line 1455 of yacc.c  */
07228 #line 2285 "vtkParse.y"
07229     {postSig("Get");}
07230     break;
07231 
07232   case 436:
07233 
07234 /* Line 1455 of yacc.c  */
07235 #line 2286 "vtkParse.y"
07236     {markSig();}
07237     break;
07238 
07239   case 437:
07240 
07241 /* Line 1455 of yacc.c  */
07242 #line 2286 "vtkParse.y"
07243     {swapSig();}
07244     break;
07245 
07246   case 438:
07247 
07248 /* Line 1455 of yacc.c  */
07249 #line 2287 "vtkParse.y"
07250     {
07251    postSig("();");
07252    currentFunction->Macro = "vtkGetMacro";
07253    currentFunction->Name = vtkstrcat("Get", (yyvsp[(4) - (9)].str));
07254    currentFunction->Comment = vtkstrdup(getComment());
07255    set_return(currentFunction, (yyvsp[(7) - (9)].integer), getTypeId(), 0);
07256    output_function();
07257    }
07258     break;
07259 
07260   case 439:
07261 
07262 /* Line 1455 of yacc.c  */
07263 #line 2295 "vtkParse.y"
07264     {preSig("void Set");}
07265     break;
07266 
07267   case 440:
07268 
07269 /* Line 1455 of yacc.c  */
07270 #line 2296 "vtkParse.y"
07271     {
07272    postSig("(char *);");
07273    currentFunction->Macro = "vtkSetStringMacro";
07274    currentFunction->Name = vtkstrcat("Set", (yyvsp[(4) - (5)].str));
07275    currentFunction->Comment = vtkstrdup(getComment());
07276    add_argument(currentFunction, VTK_PARSE_CHAR_PTR, "char", 0);
07277    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
07278    output_function();
07279    }
07280     break;
07281 
07282   case 441:
07283 
07284 /* Line 1455 of yacc.c  */
07285 #line 2305 "vtkParse.y"
07286     {preSig("char *Get");}
07287     break;
07288 
07289   case 442:
07290 
07291 /* Line 1455 of yacc.c  */
07292 #line 2306 "vtkParse.y"
07293     {
07294    postSig("();");
07295    currentFunction->Macro = "vtkGetStringMacro";
07296    currentFunction->Name = vtkstrcat("Get", (yyvsp[(4) - (5)].str));
07297    currentFunction->Comment = vtkstrdup(getComment());
07298    set_return(currentFunction, VTK_PARSE_CHAR_PTR, "char", 0);
07299    output_function();
07300    }
07301     break;
07302 
07303   case 443:
07304 
07305 /* Line 1455 of yacc.c  */
07306 #line 2314 "vtkParse.y"
07307     {startSig(); markSig();}
07308     break;
07309 
07310   case 444:
07311 
07312 /* Line 1455 of yacc.c  */
07313 #line 2314 "vtkParse.y"
07314     {closeSig();}
07315     break;
07316 
07317   case 445:
07318 
07319 /* Line 1455 of yacc.c  */
07320 #line 2316 "vtkParse.y"
07321     {
07322    const char *typeText;
07323    chopSig();
07324    typeText = copySig();
07325 
07326    currentFunction->Macro = "vtkSetClampMacro";
07327    currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (10)].str));
07328    currentFunction->Signature =
07329      vtkstrcat5("void ", currentFunction->Name, "(", typeText, ");");
07330    currentFunction->Comment = vtkstrdup(getComment());
07331    add_argument(currentFunction, (yyvsp[(6) - (10)].integer), getTypeId(), 0);
07332    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
07333    output_function();
07334 
07335    currentFunction->Macro = "vtkSetClampMacro";
07336    currentFunction->Name = vtkstrcat3("Get", (yyvsp[(3) - (10)].str), "MinValue");
07337    currentFunction->Signature =
07338      vtkstrcat4(typeText, " ", currentFunction->Name, "();");
07339    currentFunction->Comment = vtkstrdup(getComment());
07340    set_return(currentFunction, (yyvsp[(6) - (10)].integer), getTypeId(), 0);
07341    output_function();
07342 
07343    currentFunction->Macro = "vtkSetClampMacro";
07344    currentFunction->Name = vtkstrcat3("Get", (yyvsp[(3) - (10)].str), "MaxValue");
07345    currentFunction->Signature =
07346      vtkstrcat4(typeText, " ", currentFunction->Name, "();");
07347    currentFunction->Comment = vtkstrdup(getComment());
07348    set_return(currentFunction, (yyvsp[(6) - (10)].integer), getTypeId(), 0);
07349    output_function();
07350    }
07351     break;
07352 
07353   case 446:
07354 
07355 /* Line 1455 of yacc.c  */
07356 #line 2347 "vtkParse.y"
07357     {preSig("void Set"); postSig("("); }
07358     break;
07359 
07360   case 447:
07361 
07362 /* Line 1455 of yacc.c  */
07363 #line 2348 "vtkParse.y"
07364     {
07365    postSig("*);");
07366    currentFunction->Macro = "vtkSetObjectMacro";
07367    currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (7)].str));
07368    currentFunction->Comment = vtkstrdup(getComment());
07369    add_argument(currentFunction, VTK_PARSE_OBJECT_PTR, getTypeId(), 0);
07370    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
07371    output_function();
07372    }
07373     break;
07374 
07375   case 448:
07376 
07377 /* Line 1455 of yacc.c  */
07378 #line 2357 "vtkParse.y"
07379     {postSig("*Get");}
07380     break;
07381 
07382   case 449:
07383 
07384 /* Line 1455 of yacc.c  */
07385 #line 2358 "vtkParse.y"
07386     {markSig();}
07387     break;
07388 
07389   case 450:
07390 
07391 /* Line 1455 of yacc.c  */
07392 #line 2358 "vtkParse.y"
07393     {swapSig();}
07394     break;
07395 
07396   case 451:
07397 
07398 /* Line 1455 of yacc.c  */
07399 #line 2359 "vtkParse.y"
07400     {
07401    postSig("();");
07402    currentFunction->Macro = "vtkGetObjectMacro";
07403    currentFunction->Name = vtkstrcat("Get", (yyvsp[(4) - (9)].str));
07404    currentFunction->Comment = vtkstrdup(getComment());
07405    set_return(currentFunction, VTK_PARSE_OBJECT_PTR, getTypeId(), 0);
07406    output_function();
07407    }
07408     break;
07409 
07410   case 452:
07411 
07412 /* Line 1455 of yacc.c  */
07413 #line 2368 "vtkParse.y"
07414     {
07415    currentFunction->Macro = "vtkBooleanMacro";
07416    currentFunction->Name = vtkstrcat((yyvsp[(3) - (6)].str), "On");
07417    currentFunction->Comment = vtkstrdup(getComment());
07418    currentFunction->Signature =
07419      vtkstrcat3("void ", currentFunction->Name, "();");
07420    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
07421    output_function();
07422 
07423    currentFunction->Macro = "vtkBooleanMacro";
07424    currentFunction->Name = vtkstrcat((yyvsp[(3) - (6)].str), "Off");
07425    currentFunction->Comment = vtkstrdup(getComment());
07426    currentFunction->Signature =
07427      vtkstrcat3("void ", currentFunction->Name, "();");
07428    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
07429    output_function();
07430    }
07431     break;
07432 
07433   case 453:
07434 
07435 /* Line 1455 of yacc.c  */
07436 #line 2385 "vtkParse.y"
07437     {startSig(); markSig();}
07438     break;
07439 
07440   case 454:
07441 
07442 /* Line 1455 of yacc.c  */
07443 #line 2386 "vtkParse.y"
07444     {
07445    chopSig();
07446    outputSetVectorMacro((yyvsp[(3) - (7)].str), (yyvsp[(6) - (7)].integer), copySig(), 2);
07447    }
07448     break;
07449 
07450   case 455:
07451 
07452 /* Line 1455 of yacc.c  */
07453 #line 2390 "vtkParse.y"
07454     {startSig(); markSig();}
07455     break;
07456 
07457   case 456:
07458 
07459 /* Line 1455 of yacc.c  */
07460 #line 2391 "vtkParse.y"
07461     {
07462    chopSig();
07463    outputGetVectorMacro((yyvsp[(3) - (7)].str), (yyvsp[(6) - (7)].integer), copySig(), 2);
07464    }
07465     break;
07466 
07467   case 457:
07468 
07469 /* Line 1455 of yacc.c  */
07470 #line 2395 "vtkParse.y"
07471     {startSig(); markSig();}
07472     break;
07473 
07474   case 458:
07475 
07476 /* Line 1455 of yacc.c  */
07477 #line 2396 "vtkParse.y"
07478     {
07479    chopSig();
07480    outputSetVectorMacro((yyvsp[(3) - (7)].str), (yyvsp[(6) - (7)].integer), copySig(), 3);
07481    }
07482     break;
07483 
07484   case 459:
07485 
07486 /* Line 1455 of yacc.c  */
07487 #line 2400 "vtkParse.y"
07488     {startSig(); markSig();}
07489     break;
07490 
07491   case 460:
07492 
07493 /* Line 1455 of yacc.c  */
07494 #line 2401 "vtkParse.y"
07495     {
07496    chopSig();
07497    outputGetVectorMacro((yyvsp[(3) - (7)].str), (yyvsp[(6) - (7)].integer), copySig(), 3);
07498    }
07499     break;
07500 
07501   case 461:
07502 
07503 /* Line 1455 of yacc.c  */
07504 #line 2405 "vtkParse.y"
07505     {startSig(); markSig();}
07506     break;
07507 
07508   case 462:
07509 
07510 /* Line 1455 of yacc.c  */
07511 #line 2406 "vtkParse.y"
07512     {
07513    chopSig();
07514    outputSetVectorMacro((yyvsp[(3) - (7)].str), (yyvsp[(6) - (7)].integer), copySig(), 4);
07515    }
07516     break;
07517 
07518   case 463:
07519 
07520 /* Line 1455 of yacc.c  */
07521 #line 2410 "vtkParse.y"
07522     {startSig(); markSig();}
07523     break;
07524 
07525   case 464:
07526 
07527 /* Line 1455 of yacc.c  */
07528 #line 2411 "vtkParse.y"
07529     {
07530    chopSig();
07531    outputGetVectorMacro((yyvsp[(3) - (7)].str), (yyvsp[(6) - (7)].integer), copySig(), 4);
07532    }
07533     break;
07534 
07535   case 465:
07536 
07537 /* Line 1455 of yacc.c  */
07538 #line 2415 "vtkParse.y"
07539     {startSig(); markSig();}
07540     break;
07541 
07542   case 466:
07543 
07544 /* Line 1455 of yacc.c  */
07545 #line 2416 "vtkParse.y"
07546     {
07547    chopSig();
07548    outputSetVectorMacro((yyvsp[(3) - (7)].str), (yyvsp[(6) - (7)].integer), copySig(), 6);
07549    }
07550     break;
07551 
07552   case 467:
07553 
07554 /* Line 1455 of yacc.c  */
07555 #line 2420 "vtkParse.y"
07556     {startSig(); markSig();}
07557     break;
07558 
07559   case 468:
07560 
07561 /* Line 1455 of yacc.c  */
07562 #line 2421 "vtkParse.y"
07563     {
07564    chopSig();
07565    outputGetVectorMacro((yyvsp[(3) - (7)].str), (yyvsp[(6) - (7)].integer), copySig(), 6);
07566    }
07567     break;
07568 
07569   case 469:
07570 
07571 /* Line 1455 of yacc.c  */
07572 #line 2425 "vtkParse.y"
07573     {startSig(); markSig();}
07574     break;
07575 
07576   case 470:
07577 
07578 /* Line 1455 of yacc.c  */
07579 #line 2427 "vtkParse.y"
07580     {
07581    const char *typeText;
07582    chopSig();
07583    typeText = copySig();
07584    currentFunction->Macro = "vtkSetVectorMacro";
07585    currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (9)].str));
07586    currentFunction->Signature =
07587      vtkstrcat7("void ", currentFunction->Name, "(", typeText,
07588                 " a[", (yyvsp[(8) - (9)].str), "]);");
07589    currentFunction->Comment = vtkstrdup(getComment());
07590    add_argument(currentFunction, (VTK_PARSE_POINTER | (yyvsp[(6) - (9)].integer)),
07591                 getTypeId(), (int)strtol((yyvsp[(8) - (9)].str), NULL, 0));
07592    set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
07593    output_function();
07594    }
07595     break;
07596 
07597   case 471:
07598 
07599 /* Line 1455 of yacc.c  */
07600 #line 2442 "vtkParse.y"
07601     {startSig();}
07602     break;
07603 
07604   case 472:
07605 
07606 /* Line 1455 of yacc.c  */
07607 #line 2444 "vtkParse.y"
07608     {
07609    chopSig();
07610    currentFunction->Macro = "vtkGetVectorMacro";
07611    currentFunction->Name = vtkstrcat("Get", (yyvsp[(3) - (9)].str));
07612    postSig(" *");
07613    postSig(currentFunction->Name);
07614    postSig("();");
07615    currentFunction->Comment = vtkstrdup(getComment());
07616    set_return(currentFunction, (VTK_PARSE_POINTER | (yyvsp[(6) - (9)].integer)),
07617               getTypeId(), (int)strtol((yyvsp[(8) - (9)].str), NULL, 0));
07618    output_function();
07619    }
07620     break;
07621 
07622   case 473:
07623 
07624 /* Line 1455 of yacc.c  */
07625 #line 2457 "vtkParse.y"
07626     {
07627      currentFunction->Macro = "vtkViewportCoordinateMacro";
07628      currentFunction->Name = vtkstrcat3("Get", (yyvsp[(3) - (4)].str), "Coordinate");
07629      currentFunction->Signature =
07630        vtkstrcat3("vtkCoordinate *", currentFunction->Name, "();");
07631      currentFunction->Comment = vtkstrdup(getComment());
07632      set_return(currentFunction, VTK_PARSE_OBJECT_PTR, "vtkCoordinate", 0);
07633      output_function();
07634 
07635      currentFunction->Macro = "vtkViewportCoordinateMacro";
07636      currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (4)].str));
07637      currentFunction->Signature =
07638        vtkstrcat3("void ", currentFunction->Name, "(double, double);");
07639      currentFunction->Comment = vtkstrdup(getComment());
07640      add_argument(currentFunction, VTK_PARSE_DOUBLE, "double", 0);
07641      add_argument(currentFunction, VTK_PARSE_DOUBLE, "double", 0);
07642      set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
07643      output_function();
07644 
07645      currentFunction->Macro = "vtkViewportCoordinateMacro";
07646      currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (4)].str));
07647      currentFunction->Signature =
07648        vtkstrcat3("void ", currentFunction->Name, "(double a[2]);");
07649      currentFunction->Comment = vtkstrdup(getComment());
07650      add_argument(currentFunction, VTK_PARSE_DOUBLE_PTR, "double", 2);
07651      set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
07652      output_function();
07653 
07654      currentFunction->Macro = "vtkViewportCoordinateMacro";
07655      currentFunction->Name = vtkstrcat("Get", (yyvsp[(3) - (4)].str));
07656      currentFunction->Signature =
07657        vtkstrcat3("double *", currentFunction->Name, "();");
07658      currentFunction->Comment = vtkstrdup(getComment());
07659      set_return(currentFunction, VTK_PARSE_DOUBLE_PTR, "double", 2);
07660      output_function();
07661    }
07662     break;
07663 
07664   case 474:
07665 
07666 /* Line 1455 of yacc.c  */
07667 #line 2494 "vtkParse.y"
07668     {
07669      currentFunction->Macro = "vtkWorldCoordinateMacro";
07670      currentFunction->Name = vtkstrcat3("Get", (yyvsp[(3) - (4)].str), "Coordinate");
07671      currentFunction->Signature =
07672        vtkstrcat3("vtkCoordinate *", currentFunction->Name, "();");
07673      currentFunction->Comment = vtkstrdup(getComment());
07674      set_return(currentFunction, VTK_PARSE_OBJECT_PTR, "vtkCoordinate", 0);
07675      output_function();
07676 
07677      currentFunction->Macro = "vtkWorldCoordinateMacro";
07678      currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (4)].str));
07679      currentFunction->Signature =
07680        vtkstrcat3("void ", currentFunction->Name, "(double, double, double);");
07681      currentFunction->Comment = vtkstrdup(getComment());
07682      add_argument(currentFunction, VTK_PARSE_DOUBLE, "double", 0);
07683      add_argument(currentFunction, VTK_PARSE_DOUBLE, "double", 0);
07684      add_argument(currentFunction, VTK_PARSE_DOUBLE, "double", 0);
07685      set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
07686      output_function();
07687 
07688      currentFunction->Macro = "vtkWorldCoordinateMacro";
07689      currentFunction->Name = vtkstrcat("Set", (yyvsp[(3) - (4)].str));
07690      currentFunction->Signature =
07691        vtkstrcat3("void ", currentFunction->Name, "(double a[3]);");
07692      currentFunction->Comment = vtkstrdup(getComment());
07693      add_argument(currentFunction, VTK_PARSE_DOUBLE_PTR, "double", 3);
07694      set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
07695      output_function();
07696 
07697      currentFunction->Macro = "vtkWorldCoordinateMacro";
07698      currentFunction->Name = vtkstrcat("Get", (yyvsp[(3) - (4)].str));
07699      currentFunction->Signature =
07700        vtkstrcat3("double *", currentFunction->Name, "();");
07701      currentFunction->Comment = vtkstrdup(getComment());
07702      set_return(currentFunction, VTK_PARSE_DOUBLE_PTR, "double", 3);
07703      output_function();
07704    }
07705     break;
07706 
07707   case 475:
07708 
07709 /* Line 1455 of yacc.c  */
07710 #line 2532 "vtkParse.y"
07711     {
07712    int is_concrete = 0;
07713    int i;
07714 
07715    currentFunction->Macro = "vtkTypeMacro";
07716    currentFunction->Name = vtkstrdup("GetClassName");
07717    currentFunction->Signature = vtkstrdup("const char *GetClassName();");
07718    currentFunction->Comment = vtkstrdup(getComment());
07719    set_return(currentFunction, (VTK_PARSE_CONST | VTK_PARSE_CHAR_PTR),
07720               "char", 0);
07721    output_function();
07722 
07723    currentFunction->Macro = "vtkTypeMacro";
07724    currentFunction->Name = vtkstrdup("IsA");
07725    currentFunction->Signature = vtkstrdup("int IsA(const char *name);");
07726    currentFunction->Comment = vtkstrdup(getComment());
07727    add_argument(currentFunction, (VTK_PARSE_CONST | VTK_PARSE_CHAR_PTR),
07728                 "char", 0);
07729    set_return(currentFunction, VTK_PARSE_INT, "int", 0);
07730    output_function();
07731 
07732    currentFunction->Macro = "vtkTypeMacro";
07733    currentFunction->Name = vtkstrdup("NewInstance");
07734    currentFunction->Signature = vtkstrcat((yyvsp[(3) - (7)].str), " *NewInstance();");
07735    currentFunction->Comment = vtkstrdup(getComment());
07736    set_return(currentFunction, VTK_PARSE_OBJECT_PTR, (yyvsp[(3) - (7)].str), 0);
07737    output_function();
07738 
07739    for (i = 0; i < NumberOfConcreteClasses; i++)
07740      {
07741      if (strcmp(currentClass->Name, ConcreteClasses[i]) == 0)
07742        {
07743        is_concrete = 1;
07744        break;
07745        }
07746      }
07747 
07748    if ( is_concrete )
07749      {
07750      currentFunction->Macro = "vtkTypeMacro";
07751      currentFunction->Name = vtkstrdup("SafeDownCast");
07752      currentFunction->Signature =
07753        vtkstrcat((yyvsp[(3) - (7)].str), " *SafeDownCast(vtkObject* o);");
07754      currentFunction->Comment = vtkstrdup(getComment());
07755      add_argument(currentFunction, VTK_PARSE_OBJECT_PTR, "vtkObject", 0);
07756      set_return(currentFunction, (VTK_PARSE_STATIC | VTK_PARSE_OBJECT_PTR),
07757                 (yyvsp[(3) - (7)].str), 0);
07758      output_function();
07759      }
07760    }
07761     break;
07762 
07763   case 476:
07764 
07765 /* Line 1455 of yacc.c  */
07766 #line 2588 "vtkParse.y"
07767     { (yyval.str) = "operator()"; }
07768     break;
07769 
07770   case 477:
07771 
07772 /* Line 1455 of yacc.c  */
07773 #line 2589 "vtkParse.y"
07774     { (yyval.str) = "operator[]"; }
07775     break;
07776 
07777   case 478:
07778 
07779 /* Line 1455 of yacc.c  */
07780 #line 2590 "vtkParse.y"
07781     { (yyval.str) = "operator new[]"; }
07782     break;
07783 
07784   case 479:
07785 
07786 /* Line 1455 of yacc.c  */
07787 #line 2591 "vtkParse.y"
07788     { (yyval.str) = "operator delete[]"; }
07789     break;
07790 
07791   case 481:
07792 
07793 /* Line 1455 of yacc.c  */
07794 #line 2594 "vtkParse.y"
07795     { (yyval.str) = "operator="; }
07796     break;
07797 
07798   case 482:
07799 
07800 /* Line 1455 of yacc.c  */
07801 #line 2595 "vtkParse.y"
07802     { (yyval.str) = "operator*"; }
07803     break;
07804 
07805   case 483:
07806 
07807 /* Line 1455 of yacc.c  */
07808 #line 2595 "vtkParse.y"
07809     { (yyval.str) = "operator/"; }
07810     break;
07811 
07812   case 484:
07813 
07814 /* Line 1455 of yacc.c  */
07815 #line 2596 "vtkParse.y"
07816     { (yyval.str) = "operator-"; }
07817     break;
07818 
07819   case 485:
07820 
07821 /* Line 1455 of yacc.c  */
07822 #line 2596 "vtkParse.y"
07823     { (yyval.str) = "operator+"; }
07824     break;
07825 
07826   case 486:
07827 
07828 /* Line 1455 of yacc.c  */
07829 #line 2597 "vtkParse.y"
07830     { (yyval.str) = "operator!"; }
07831     break;
07832 
07833   case 487:
07834 
07835 /* Line 1455 of yacc.c  */
07836 #line 2597 "vtkParse.y"
07837     { (yyval.str) = "operator~"; }
07838     break;
07839 
07840   case 488:
07841 
07842 /* Line 1455 of yacc.c  */
07843 #line 2598 "vtkParse.y"
07844     { (yyval.str) = "operator,"; }
07845     break;
07846 
07847   case 489:
07848 
07849 /* Line 1455 of yacc.c  */
07850 #line 2598 "vtkParse.y"
07851     { (yyval.str) = "operator<"; }
07852     break;
07853 
07854   case 490:
07855 
07856 /* Line 1455 of yacc.c  */
07857 #line 2599 "vtkParse.y"
07858     { (yyval.str) = "operator>"; }
07859     break;
07860 
07861   case 491:
07862 
07863 /* Line 1455 of yacc.c  */
07864 #line 2599 "vtkParse.y"
07865     { (yyval.str) = "operator&"; }
07866     break;
07867 
07868   case 492:
07869 
07870 /* Line 1455 of yacc.c  */
07871 #line 2600 "vtkParse.y"
07872     { (yyval.str) = "operator|"; }
07873     break;
07874 
07875   case 493:
07876 
07877 /* Line 1455 of yacc.c  */
07878 #line 2600 "vtkParse.y"
07879     { (yyval.str) = "operator^"; }
07880     break;
07881 
07882   case 494:
07883 
07884 /* Line 1455 of yacc.c  */
07885 #line 2601 "vtkParse.y"
07886     { (yyval.str) = "operator%"; }
07887     break;
07888 
07889   case 495:
07890 
07891 /* Line 1455 of yacc.c  */
07892 #line 2602 "vtkParse.y"
07893     { (yyval.str) = "operator new"; }
07894     break;
07895 
07896   case 496:
07897 
07898 /* Line 1455 of yacc.c  */
07899 #line 2603 "vtkParse.y"
07900     { (yyval.str) = "operator delete"; }
07901     break;
07902 
07903   case 497:
07904 
07905 /* Line 1455 of yacc.c  */
07906 #line 2604 "vtkParse.y"
07907     { (yyval.str) = "operator<<="; }
07908     break;
07909 
07910   case 498:
07911 
07912 /* Line 1455 of yacc.c  */
07913 #line 2605 "vtkParse.y"
07914     { (yyval.str) = "operator>>="; }
07915     break;
07916 
07917   case 499:
07918 
07919 /* Line 1455 of yacc.c  */
07920 #line 2606 "vtkParse.y"
07921     { (yyval.str) = "operator<<"; }
07922     break;
07923 
07924   case 500:
07925 
07926 /* Line 1455 of yacc.c  */
07927 #line 2607 "vtkParse.y"
07928     { (yyval.str) = "operator>>"; }
07929     break;
07930 
07931   case 501:
07932 
07933 /* Line 1455 of yacc.c  */
07934 #line 2608 "vtkParse.y"
07935     { (yyval.str) = "operator->*"; }
07936     break;
07937 
07938   case 502:
07939 
07940 /* Line 1455 of yacc.c  */
07941 #line 2609 "vtkParse.y"
07942     { (yyval.str) = "operator->"; }
07943     break;
07944 
07945   case 503:
07946 
07947 /* Line 1455 of yacc.c  */
07948 #line 2610 "vtkParse.y"
07949     { (yyval.str) = "operator+="; }
07950     break;
07951 
07952   case 504:
07953 
07954 /* Line 1455 of yacc.c  */
07955 #line 2611 "vtkParse.y"
07956     { (yyval.str) = "operator-="; }
07957     break;
07958 
07959   case 505:
07960 
07961 /* Line 1455 of yacc.c  */
07962 #line 2612 "vtkParse.y"
07963     { (yyval.str) = "operator*="; }
07964     break;
07965 
07966   case 506:
07967 
07968 /* Line 1455 of yacc.c  */
07969 #line 2613 "vtkParse.y"
07970     { (yyval.str) = "operator/="; }
07971     break;
07972 
07973   case 507:
07974 
07975 /* Line 1455 of yacc.c  */
07976 #line 2614 "vtkParse.y"
07977     { (yyval.str) = "operator%="; }
07978     break;
07979 
07980   case 508:
07981 
07982 /* Line 1455 of yacc.c  */
07983 #line 2615 "vtkParse.y"
07984     { (yyval.str) = "operator++"; }
07985     break;
07986 
07987   case 509:
07988 
07989 /* Line 1455 of yacc.c  */
07990 #line 2616 "vtkParse.y"
07991     { (yyval.str) = "operator--"; }
07992     break;
07993 
07994   case 510:
07995 
07996 /* Line 1455 of yacc.c  */
07997 #line 2617 "vtkParse.y"
07998     { (yyval.str) = "operator&="; }
07999     break;
08000 
08001   case 511:
08002 
08003 /* Line 1455 of yacc.c  */
08004 #line 2618 "vtkParse.y"
08005     { (yyval.str) = "operator|="; }
08006     break;
08007 
08008   case 512:
08009 
08010 /* Line 1455 of yacc.c  */
08011 #line 2619 "vtkParse.y"
08012     { (yyval.str) = "operator^="; }
08013     break;
08014 
08015   case 513:
08016 
08017 /* Line 1455 of yacc.c  */
08018 #line 2620 "vtkParse.y"
08019     {(yyval.str) = "operator&&=";}
08020     break;
08021 
08022   case 514:
08023 
08024 /* Line 1455 of yacc.c  */
08025 #line 2621 "vtkParse.y"
08026     {(yyval.str) = "operator||=";}
08027     break;
08028 
08029   case 515:
08030 
08031 /* Line 1455 of yacc.c  */
08032 #line 2622 "vtkParse.y"
08033     { (yyval.str) = "operator&&"; }
08034     break;
08035 
08036   case 516:
08037 
08038 /* Line 1455 of yacc.c  */
08039 #line 2623 "vtkParse.y"
08040     { (yyval.str) = "operator||"; }
08041     break;
08042 
08043   case 517:
08044 
08045 /* Line 1455 of yacc.c  */
08046 #line 2624 "vtkParse.y"
08047     { (yyval.str) = "operator=="; }
08048     break;
08049 
08050   case 518:
08051 
08052 /* Line 1455 of yacc.c  */
08053 #line 2625 "vtkParse.y"
08054     { (yyval.str) = "operator!="; }
08055     break;
08056 
08057   case 519:
08058 
08059 /* Line 1455 of yacc.c  */
08060 #line 2626 "vtkParse.y"
08061     { (yyval.str) = "operator<="; }
08062     break;
08063 
08064   case 520:
08065 
08066 /* Line 1455 of yacc.c  */
08067 #line 2627 "vtkParse.y"
08068     { (yyval.str) = "operator>="; }
08069     break;
08070 
08071 
08072 
08073 /* Line 1455 of yacc.c  */
08074 #line 8207 "vtkParse.tab.c"
08075       default: break;
08076     }
08077   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
08078 
08079   YYPOPSTACK (yylen);
08080   yylen = 0;
08081   YY_STACK_PRINT (yyss, yyssp);
08082 
08083   *++yyvsp = yyval;
08084 
08085   /* Now `shift' the result of the reduction.  Determine what state
08086      that goes to, based on the state we popped back to and the rule
08087      number reduced by.  */
08088 
08089   yyn = yyr1[yyn];
08090 
08091   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
08092   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
08093     yystate = yytable[yystate];
08094   else
08095     yystate = yydefgoto[yyn - YYNTOKENS];
08096 
08097   goto yynewstate;
08098 
08099 
08100 /*------------------------------------.
08101 | yyerrlab -- here on detecting error |
08102 `------------------------------------*/
08103 yyerrlab:
08104   /* If not already recovering from an error, report this error.  */
08105   if (!yyerrstatus)
08106     {
08107       ++yynerrs;
08108 #if ! YYERROR_VERBOSE
08109       yyerror (YY_("syntax error"));
08110 #else
08111       {
08112         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
08113         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
08114           {
08115             YYSIZE_T yyalloc = 2 * yysize;
08116             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
08117               yyalloc = YYSTACK_ALLOC_MAXIMUM;
08118             if (yymsg != yymsgbuf)
08119               YYSTACK_FREE (yymsg);
08120             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
08121             if (yymsg)
08122               yymsg_alloc = yyalloc;
08123             else
08124               {
08125                 yymsg = yymsgbuf;
08126                 yymsg_alloc = sizeof yymsgbuf;
08127               }
08128           }
08129 
08130         if (0 < yysize && yysize <= yymsg_alloc)
08131           {
08132             (void) yysyntax_error (yymsg, yystate, yychar);
08133             yyerror (yymsg);
08134           }
08135         else
08136           {
08137             yyerror (YY_("syntax error"));
08138             if (yysize != 0)
08139               goto yyexhaustedlab;
08140           }
08141       }
08142 #endif
08143     }
08144 
08145 
08146 
08147   if (yyerrstatus == 3)
08148     {
08149       /* If just tried and failed to reuse lookahead token after an
08150          error, discard it.  */
08151 
08152       if (yychar <= YYEOF)
08153         {
08154           /* Return failure if at end of input.  */
08155           if (yychar == YYEOF)
08156             YYABORT;
08157         }
08158       else
08159         {
08160           yydestruct ("Error: discarding",
08161                       yytoken, &yylval);
08162           yychar = YYEMPTY;
08163         }
08164     }
08165 
08166   /* Else will try to reuse lookahead token after shifting the error
08167      token.  */
08168   goto yyerrlab1;
08169 
08170 
08171 /*---------------------------------------------------.
08172 | yyerrorlab -- error raised explicitly by YYERROR.  |
08173 `---------------------------------------------------*/
08174 yyerrorlab:
08175 
08176   /* Pacify compilers like GCC when the user code never invokes
08177      YYERROR and the label yyerrorlab therefore never appears in user
08178      code.  */
08179   if (/*CONSTCOND*/ 0)
08180      goto yyerrorlab;
08181 
08182   /* Do not reclaim the symbols of the rule which action triggered
08183      this YYERROR.  */
08184   YYPOPSTACK (yylen);
08185   yylen = 0;
08186   YY_STACK_PRINT (yyss, yyssp);
08187   yystate = *yyssp;
08188 
08189 
08190 /*-------------------------------------------------------------.
08191 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
08192 `-------------------------------------------------------------*/
08193 yyerrlab1:
08194   yyerrstatus = 3;        /* Each real token shifted decrements this.  */
08195 
08196   for (;;)
08197     {
08198       yyn = yypact[yystate];
08199       if (yyn != YYPACT_NINF)
08200         {
08201           yyn += YYTERROR;
08202           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
08203             {
08204               yyn = yytable[yyn];
08205               if (0 < yyn)
08206                 break;
08207             }
08208         }
08209 
08210       /* Pop the current state because it cannot handle the error token.  */
08211       if (yyssp == yyss)
08212         YYABORT;
08213 
08214 
08215       yydestruct ("Error: popping",
08216                   yystos[yystate], yyvsp);
08217       YYPOPSTACK (1);
08218       yystate = *yyssp;
08219       YY_STACK_PRINT (yyss, yyssp);
08220     }
08221 
08222   *++yyvsp = yylval;
08223 
08224 
08225   /* Shift the error token.  */
08226   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
08227 
08228   yystate = yyn;
08229   goto yynewstate;
08230 
08231 
08232 /*-------------------------------------.
08233 | yyacceptlab -- YYACCEPT comes here.  |
08234 `-------------------------------------*/
08235 yyacceptlab:
08236   yyresult = 0;
08237   goto yyreturn;
08238 
08239 /*-----------------------------------.
08240 | yyabortlab -- YYABORT comes here.  |
08241 `-----------------------------------*/
08242 yyabortlab:
08243   yyresult = 1;
08244   goto yyreturn;
08245 
08246 #if !defined(yyoverflow) || YYERROR_VERBOSE
08247 /*-------------------------------------------------.
08248 | yyexhaustedlab -- memory exhaustion comes here.  |
08249 `-------------------------------------------------*/
08250 yyexhaustedlab:
08251   yyerror (YY_("memory exhausted"));
08252   yyresult = 2;
08253   /* Fall through.  */
08254 #endif
08255 
08256 yyreturn:
08257   if (yychar != YYEMPTY)
08258      yydestruct ("Cleanup: discarding lookahead",
08259                  yytoken, &yylval);
08260   /* Do not reclaim the symbols of the rule which action triggered
08261      this YYABORT or YYACCEPT.  */
08262   YYPOPSTACK (yylen);
08263   YY_STACK_PRINT (yyss, yyssp);
08264   while (yyssp != yyss)
08265     {
08266       yydestruct ("Cleanup: popping",
08267                   yystos[*yyssp], yyvsp);
08268       YYPOPSTACK (1);
08269     }
08270 #ifndef yyoverflow
08271   if (yyss != yyssa)
08272     YYSTACK_FREE (yyss);
08273 #endif
08274 #if YYERROR_VERBOSE
08275   if (yymsg != yymsgbuf)
08276     YYSTACK_FREE (yymsg);
08277 #endif
08278   /* Make sure YYID is used.  */
08279   return YYID (yyresult);
08280 }
08281 
08282 
08283 
08284 /* Line 1675 of yacc.c  */
08285 #line 2652 "vtkParse.y"
08286 
08287 #include <string.h>
08288 #include "lex.yy.c"
08289 
08290 /* initialize the structure */
08291 void vtkParse_InitTemplateArgs(TemplateArgs *args)
08292 {
08293   args->NumberOfArguments = 0;
08294 }
08295 
08296 void vtkParse_CopyTemplateArgs(TemplateArgs *args, const TemplateArgs *orig)
08297 {
08298   unsigned long i, n;
08299 
08300   n = orig->NumberOfArguments;
08301   args->NumberOfArguments = n;
08302   args->Arguments = (TemplateArg **)malloc(n*sizeof(TemplateArg *));
08303 
08304   for (i = 0; i < n; i++)
08305     {
08306     args->Arguments[i] = (TemplateArg *)malloc(sizeof(TemplateArg));
08307     vtkParse_CopyTemplateArg(args->Arguments[i], orig->Arguments[i]);
08308     }
08309 }
08310 
08311 void vtkParse_InitTemplateArg(TemplateArg *arg)
08312 {
08313   arg->Template = NULL;
08314   arg->Type = 0;
08315   arg->Class = NULL;
08316   arg->Name = NULL;
08317   arg->Value = NULL;
08318 }
08319 
08320 void vtkParse_CopyTemplateArg(TemplateArg *arg, const TemplateArg *orig)
08321 {
08322   arg->Template = NULL;
08323 
08324   if (orig->Template)
08325     {
08326     arg->Template = (TemplateArgs *)malloc(sizeof(TemplateArgs));
08327     vtkParse_CopyTemplateArgs(arg->Template, orig->Template);
08328     }
08329 
08330   arg->Type = orig->Type;
08331   arg->Class = orig->Class;
08332   arg->Name = orig->Name;
08333   arg->Value = orig->Value;
08334 }
08335 
08336 /* initialize the structure */
08337 void vtkParse_InitFunction(FunctionInfo *func)
08338 {
08339   unsigned long i;
08340 
08341   func->ItemType = VTK_FUNCTION_INFO;
08342   func->Access = VTK_ACCESS_PUBLIC;
08343   func->Name = NULL;
08344   func->Comment = NULL;
08345   func->Class = NULL;
08346   func->Signature = NULL;
08347   func->Template = NULL;
08348   func->NumberOfArguments = 0;
08349   func->ReturnValue = NULL;
08350   func->Macro = NULL;
08351   func->SizeHint = NULL;
08352   func->IsStatic = 0;
08353   func->IsVirtual = 0;
08354   func->IsPureVirtual = 0;
08355   func->IsOperator = 0;
08356   func->IsVariadic = 0;
08357   func->IsConst = 0;
08358   func->IsExplicit = 0;
08359 
08360   /* everything below here is legacy information, *
08361    * maintained only for backwards compatibility  */
08362   func->ReturnType = VTK_PARSE_VOID;
08363   func->ReturnClass = NULL;
08364   func->HaveHint = 0;
08365   func->HintSize = 0;
08366   func->IsLegacy = 0;
08367   func->ArrayFailure = 0;
08368   func->IsPublic = 0;
08369   func->IsProtected = 0;
08370 
08371   for (i = 0; i < MAX_ARGS; i++)
08372     {
08373     func->ArgTypes[i] = 0;
08374     func->ArgClasses[i] = 0;
08375     func->ArgCounts[i] = 0;
08376     }
08377 }
08378 
08379 void vtkParse_CopyFunction(FunctionInfo *func, const FunctionInfo *orig)
08380 {
08381   unsigned long i, n;
08382 
08383   func->ItemType = orig->ItemType;
08384   func->Access = orig->Access;
08385   func->Name = orig->Name;
08386   func->Comment = orig->Comment;
08387   func->Class = orig->Class;
08388   func->Signature = orig->Signature;
08389   func->Template = NULL;
08390 
08391   if (orig->Template)
08392     {
08393     func->Template = (TemplateArgs *)malloc(sizeof(TemplateArgs));
08394     vtkParse_CopyTemplateArgs(func->Template, orig->Template);
08395     }
08396 
08397   n = orig->NumberOfArguments;
08398   func->NumberOfArguments = n;
08399   if (n)
08400     {
08401     func->Arguments = (ValueInfo **)malloc(n*sizeof(ValueInfo *));
08402     for (i = 0; i < n; i++)
08403       {
08404       func->Arguments[i] = (ValueInfo *)malloc(sizeof(ValueInfo));
08405       vtkParse_CopyValue(func->Arguments[i], orig->Arguments[i]);
08406       }
08407     }
08408 
08409   func->ReturnValue = NULL;
08410   if (orig->ReturnValue)
08411     {
08412     func->ReturnValue = (ValueInfo *)malloc(sizeof(ValueInfo));
08413     vtkParse_CopyValue(func->ReturnValue, orig->ReturnValue);
08414     }
08415 
08416   func->Macro = orig->Macro;
08417   func->SizeHint = orig->SizeHint;
08418   func->IsStatic = orig->IsStatic;
08419   func->IsVirtual = orig->IsVirtual;
08420   func->IsPureVirtual = orig->IsPureVirtual;
08421   func->IsOperator = orig->IsOperator;
08422   func->IsVariadic = orig->IsVariadic;
08423   func->IsConst = orig->IsConst;
08424   func->IsExplicit = orig->IsExplicit;
08425 
08426   /* everything below here is legacy information, *
08427    * maintained only for backwards compatibility  */
08428   func->ReturnType = orig->ReturnType;
08429   func->ReturnClass = orig->ReturnClass;
08430   func->HaveHint = orig->HaveHint;
08431   func->HintSize = orig->HintSize;
08432   func->IsLegacy = orig->IsLegacy;
08433   func->ArrayFailure = orig->ArrayFailure;
08434   func->IsPublic = orig->IsPublic;
08435   func->IsProtected = orig->IsProtected;
08436 
08437   for (i = 0; i < MAX_ARGS; i++)
08438     {
08439     func->ArgTypes[i] = orig->ArgTypes[i];
08440     func->ArgClasses[i] = orig->ArgClasses[i];
08441     func->ArgCounts[i] = orig->ArgCounts[i];
08442     }
08443 }
08444 
08445 /* initialize the structure */
08446 void vtkParse_InitValue(ValueInfo *val)
08447 {
08448   val->ItemType = VTK_VARIABLE_INFO;
08449   val->Access = VTK_ACCESS_PUBLIC;
08450   val->Name = NULL;
08451   val->Comment = NULL;
08452   val->Value = NULL;
08453   val->Type = 0;
08454   val->Class = NULL;
08455   val->Count = 0;
08456   val->CountHint = NULL;
08457   val->NumberOfDimensions = 0;
08458   val->Function = NULL;
08459   val->IsStatic = 0;
08460   val->IsEnum = 0;
08461 }
08462 
08463 void vtkParse_CopyValue(ValueInfo *val, const ValueInfo *orig)
08464 {
08465   unsigned long i, n;
08466 
08467   val->ItemType = orig->ItemType;
08468   val->Access = orig->Access;
08469   val->Name = orig->Name;
08470   val->Comment = orig->Comment;
08471   val->Value = orig->Value;
08472   val->Type = orig->Type;
08473   val->Class = orig->Class;
08474   val->Count = orig->Count;
08475   val->CountHint = orig->CountHint;
08476 
08477   n = orig->NumberOfDimensions;
08478   val->NumberOfDimensions = n;
08479   if (n)
08480     {
08481     val->Dimensions = (const char **)malloc(n*sizeof(char *));
08482     for (i = 0; i < n; i++)
08483       {
08484       val->Dimensions[i] = orig->Dimensions[i];
08485       }
08486     }
08487 
08488   val->Function = NULL;
08489   if (orig->Function)
08490     {
08491     val->Function = (FunctionInfo *)malloc(sizeof(FunctionInfo));
08492     vtkParse_CopyFunction(val->Function, orig->Function);
08493     }
08494 
08495   val->IsStatic = orig->IsStatic;
08496   val->IsEnum = orig->IsEnum;
08497 }
08498 
08499 /* initialize the structure */
08500 void vtkParse_InitEnum(EnumInfo *item)
08501 {
08502   item->ItemType = VTK_ENUM_INFO;
08503   item->Access = VTK_ACCESS_PUBLIC;
08504   item->Name = NULL;
08505   item->Comment = NULL;
08506 }
08507 
08508 void vtkParse_CopyEnum(EnumInfo *item, const EnumInfo *orig)
08509 {
08510   item->ItemType = orig->ItemType;
08511   item->Access = orig->Access;
08512   item->Name = orig->Name;
08513   item->Comment = orig->Comment;
08514 }
08515 
08516 /* initialize the structure */
08517 void vtkParse_InitUsing(UsingInfo *item)
08518 {
08519   item->ItemType = VTK_USING_INFO;
08520   item->Access = VTK_ACCESS_PUBLIC;
08521   item->Name = NULL;
08522   item->Comment = NULL;
08523   item->Scope = NULL;
08524 }
08525 
08526 void vtkParse_CopyUsing(UsingInfo *item, const UsingInfo *orig)
08527 {
08528   item->ItemType = orig->ItemType;
08529   item->Access = orig->Access;
08530   item->Name = orig->Name;
08531   item->Comment = orig->Comment;
08532   item->Scope = orig->Scope;
08533 }
08534 
08535 /* initialize the structure */
08536 void vtkParse_InitClass(ClassInfo *cls)
08537 {
08538   cls->ItemType = VTK_CLASS_INFO;
08539   cls->Access = VTK_ACCESS_PUBLIC;
08540   cls->Name = NULL;
08541   cls->Comment = NULL;
08542   cls->Template = NULL;
08543   cls->NumberOfSuperClasses = 0;
08544   cls->NumberOfItems = 0;
08545   cls->NumberOfClasses = 0;
08546   cls->NumberOfFunctions = 0;
08547   cls->NumberOfConstants = 0;
08548   cls->NumberOfVariables = 0;
08549   cls->NumberOfEnums = 0;
08550   cls->NumberOfTypedefs = 0;
08551   cls->NumberOfUsings = 0;
08552   cls->IsAbstract = 0;
08553   cls->HasDelete = 0;
08554 }
08555 
08556 void vtkParse_CopyClass(ClassInfo *cls, const ClassInfo *orig)
08557 {
08558   unsigned long i, n;
08559 
08560   cls->ItemType = orig->ItemType;
08561   cls->Access = orig->Access;
08562   cls->Name = orig->Name;
08563   cls->Comment = orig->Comment;
08564   cls->Template = NULL;
08565 
08566   if (orig->Template)
08567     {
08568     cls->Template = (TemplateArgs *)malloc(sizeof(TemplateArgs));
08569     vtkParse_CopyTemplateArgs(cls->Template, orig->Template);
08570     }
08571 
08572   n = orig->NumberOfSuperClasses;
08573   cls->NumberOfSuperClasses = n;
08574   if (n)
08575     {
08576     cls->SuperClasses = (const char **)malloc(n*sizeof(char *));
08577     for (i = 0; i < n; i++)
08578       {
08579       cls->SuperClasses[i] = orig->SuperClasses[i];
08580       }
08581     }
08582 
08583   n = orig->NumberOfItems;
08584   cls->NumberOfItems = n;
08585   if (n)
08586     {
08587     cls->Items = (ItemInfo *)malloc(n*sizeof(ItemInfo));
08588     for (i = 0; i < n; i++)
08589       {
08590       cls->Items[i].Type = orig->Items[i].Type;
08591       cls->Items[i].Index = orig->Items[i].Index;
08592       }
08593     }
08594 
08595   n = orig->NumberOfClasses;
08596   cls->NumberOfClasses = n;
08597   if (n)
08598     {
08599     cls->Classes = (ClassInfo **)malloc(n*sizeof(ClassInfo *));
08600     for (i = 0; i < n; i++)
08601       {
08602       cls->Classes[i] = (ClassInfo *)malloc(sizeof(ClassInfo));
08603       vtkParse_CopyClass(cls->Classes[i], orig->Classes[i]);
08604       }
08605     }
08606 
08607   n = orig->NumberOfFunctions;
08608   cls->NumberOfFunctions = n;
08609   if (n)
08610     {
08611     cls->Functions = (FunctionInfo **)malloc(n*sizeof(FunctionInfo *));
08612     for (i = 0; i < n; i++)
08613       {
08614       cls->Functions[i] = (FunctionInfo *)malloc(sizeof(FunctionInfo));
08615       vtkParse_CopyFunction(cls->Functions[i], orig->Functions[i]);
08616       }
08617     }
08618 
08619   n = orig->NumberOfConstants;
08620   cls->NumberOfConstants = n;
08621   if (n)
08622     {
08623     cls->Constants = (ValueInfo **)malloc(n*sizeof(ValueInfo *));
08624     for (i = 0; i < n; i++)
08625       {
08626       cls->Constants[i] = (ValueInfo *)malloc(sizeof(ValueInfo));
08627       vtkParse_CopyValue(cls->Constants[i], orig->Constants[i]);
08628       }
08629     }
08630 
08631   n = orig->NumberOfVariables;
08632   cls->NumberOfVariables = n;
08633   if (n)
08634     {
08635     cls->Variables = (ValueInfo **)malloc(n*sizeof(ValueInfo *));
08636     for (i = 0; i < n; i++)
08637       {
08638       cls->Variables[i] = (ValueInfo *)malloc(sizeof(ValueInfo));
08639       vtkParse_CopyValue(cls->Variables[i], orig->Variables[i]);
08640       }
08641     }
08642 
08643   n = orig->NumberOfEnums;
08644   cls->NumberOfEnums = n;
08645   if (n)
08646     {
08647     cls->Enums = (EnumInfo **)malloc(n*sizeof(EnumInfo *));
08648     for (i = 0; i < n; i++)
08649       {
08650       cls->Enums[i] = (EnumInfo *)malloc(sizeof(EnumInfo));
08651       vtkParse_CopyEnum(cls->Enums[i], orig->Enums[i]);
08652       }
08653     }
08654 
08655   n = orig->NumberOfTypedefs;
08656   cls->NumberOfTypedefs = n;
08657   if (n)
08658     {
08659     cls->Typedefs = (ValueInfo **)malloc(n*sizeof(ValueInfo *));
08660     for (i = 0; i < n; i++)
08661       {
08662       cls->Typedefs[i] = (ValueInfo *)malloc(sizeof(ValueInfo));
08663       vtkParse_CopyValue(cls->Typedefs[i], orig->Typedefs[i]);
08664       }
08665     }
08666 
08667   n = orig->NumberOfUsings;
08668   cls->NumberOfUsings = n;
08669   if (n)
08670     {
08671     cls->Usings = (UsingInfo **)malloc(n*sizeof(UsingInfo *));
08672     for (i = 0; i < n; i++)
08673       {
08674       cls->Usings[i] = (UsingInfo *)malloc(sizeof(UsingInfo));
08675       vtkParse_CopyUsing(cls->Usings[i], orig->Usings[i]);
08676       }
08677     }
08678 
08679   cls->IsAbstract = orig->IsAbstract;
08680   cls->HasDelete = orig->HasDelete;
08681 }
08682 
08683 
08684 /* initialize the structure */
08685 void vtkParse_InitNamespace(NamespaceInfo *name_info)
08686 {
08687   /* namespace info */
08688   name_info->ItemType = VTK_NAMESPACE_INFO;
08689   name_info->Access = VTK_ACCESS_PUBLIC;
08690   name_info->Name = NULL;
08691   name_info->Comment = NULL;
08692   name_info->NumberOfItems = 0;
08693   name_info->NumberOfClasses = 0;
08694   name_info->NumberOfFunctions = 0;
08695   name_info->NumberOfConstants = 0;
08696   name_info->NumberOfVariables = 0;
08697   name_info->NumberOfEnums = 0;
08698   name_info->NumberOfTypedefs = 0;
08699   name_info->NumberOfUsings = 0;
08700   name_info->NumberOfNamespaces = 0;
08701 }
08702 
08703 void vtkParse_CopyNamespace(NamespaceInfo *ninfo, const NamespaceInfo *orig)
08704 {
08705   unsigned long i, n;
08706 
08707   /* namespace info */
08708   ninfo->ItemType = orig->ItemType;
08709   ninfo->Access = orig->Access;
08710   ninfo->Name = orig->Name;
08711   ninfo->Comment = orig->Comment;
08712 
08713   n = orig->NumberOfItems;
08714   ninfo->NumberOfItems = n;
08715   if (n)
08716     {
08717     ninfo->Items = (ItemInfo *)malloc(n*sizeof(ItemInfo));
08718     for (i = 0; i < n; i++)
08719       {
08720       ninfo->Items[i].Type = orig->Items[i].Type;
08721       ninfo->Items[i].Index = orig->Items[i].Index;
08722       }
08723     }
08724 
08725   n = orig->NumberOfClasses;
08726   ninfo->NumberOfClasses = n;
08727   if (n)
08728     {
08729     ninfo->Classes = (ClassInfo **)malloc(n*sizeof(ClassInfo *));
08730     for (i = 0; i < n; i++)
08731       {
08732       ninfo->Classes[i] = (ClassInfo *)malloc(sizeof(ClassInfo));
08733       vtkParse_CopyClass(ninfo->Classes[i], orig->Classes[i]);
08734       }
08735     }
08736 
08737   n = orig->NumberOfFunctions;
08738   ninfo->NumberOfFunctions = n;
08739   if (n)
08740     {
08741     ninfo->Functions = (FunctionInfo **)malloc(n*sizeof(FunctionInfo *));
08742     for (i = 0; i < n; i++)
08743       {
08744       ninfo->Functions[i] = (FunctionInfo *)malloc(sizeof(FunctionInfo));
08745       vtkParse_CopyFunction(ninfo->Functions[i], orig->Functions[i]);
08746       }
08747     }
08748 
08749   n = orig->NumberOfConstants;
08750   ninfo->NumberOfConstants = n;
08751   if (n)
08752     {
08753     ninfo->Constants = (ValueInfo **)malloc(n*sizeof(ValueInfo *));
08754     for (i = 0; i < n; i++)
08755       {
08756       ninfo->Constants[i] = (ValueInfo *)malloc(sizeof(ValueInfo));
08757       vtkParse_CopyValue(ninfo->Constants[i], orig->Constants[i]);
08758       }
08759     }
08760 
08761   n = orig->NumberOfVariables;
08762   ninfo->NumberOfVariables = n;
08763   if (n)
08764     {
08765     ninfo->Variables = (ValueInfo **)malloc(n*sizeof(ValueInfo *));
08766     for (i = 0; i < n; i++)
08767       {
08768       ninfo->Variables[i] = (ValueInfo *)malloc(sizeof(ValueInfo));
08769       vtkParse_CopyValue(ninfo->Variables[i], orig->Variables[i]);
08770       }
08771     }
08772 
08773   n = orig->NumberOfEnums;
08774   ninfo->NumberOfEnums = n;
08775   if (n)
08776     {
08777     ninfo->Enums = (EnumInfo **)malloc(n*sizeof(EnumInfo *));
08778     for (i = 0; i < n; i++)
08779       {
08780       ninfo->Enums[i] = (EnumInfo *)malloc(sizeof(EnumInfo));
08781       vtkParse_CopyEnum(ninfo->Enums[i], orig->Enums[i]);
08782       }
08783     }
08784 
08785   n = orig->NumberOfTypedefs;
08786   ninfo->NumberOfTypedefs = n;
08787   if (n)
08788     {
08789     ninfo->Typedefs = (ValueInfo **)malloc(n*sizeof(ValueInfo *));
08790     for (i = 0; i < n; i++)
08791       {
08792       ninfo->Typedefs[i] = (ValueInfo *)malloc(sizeof(ValueInfo));
08793       vtkParse_CopyValue(ninfo->Typedefs[i], orig->Typedefs[i]);
08794       }
08795     }
08796 
08797   n = orig->NumberOfUsings;
08798   ninfo->NumberOfUsings = n;
08799   if (n)
08800     {
08801     ninfo->Usings = (UsingInfo **)malloc(n*sizeof(UsingInfo *));
08802     for (i = 0; i < n; i++)
08803       {
08804       ninfo->Usings[i] = (UsingInfo *)malloc(sizeof(UsingInfo));
08805       vtkParse_CopyUsing(ninfo->Usings[i], orig->Usings[i]);
08806       }
08807     }
08808 }
08809 
08810 
08811 
08812 void vtkParse_InitFile(FileInfo *file_info)
08813 {
08814   /* file info */
08815   file_info->FileName = NULL;
08816   file_info->NameComment = NULL;
08817   file_info->Description = NULL;
08818   file_info->Caveats = NULL;
08819   file_info->SeeAlso = NULL;
08820 
08821   file_info->MainClass = NULL;
08822   file_info->Contents = NULL;
08823 }
08824 
08825 void vtkParse_FreeTemplateArgs(TemplateArgs *template_info)
08826 {
08827   int j, m;
08828 
08829   m = template_info->NumberOfArguments;
08830   for (j = 0; j < m; j++)
08831     {
08832     if (template_info->Arguments[j]->Template)
08833       {
08834       vtkParse_FreeTemplateArgs(template_info->Arguments[j]->Template);
08835       }
08836     free(template_info->Arguments[j]);
08837     }
08838 
08839   free(template_info);
08840 }
08841 
08842 void vtkParse_FreeFunction(FunctionInfo *function_info);
08843 
08844 void vtkParse_FreeValue(ValueInfo *value_info)
08845 {
08846   if (value_info->NumberOfDimensions)
08847     {
08848     free((char **)value_info->Dimensions);
08849     }
08850   if (value_info->Function)
08851     {
08852     vtkParse_FreeFunction(value_info->Function);
08853     }
08854 
08855   free(value_info);
08856 }
08857 
08858 void vtkParse_FreeEnum(EnumInfo *enum_info)
08859 {
08860   free(enum_info);
08861 }
08862 
08863 void vtkParse_FreeUsing(UsingInfo *using_info)
08864 {
08865   free(using_info);
08866 }
08867 
08868 void vtkParse_FreeFunction(FunctionInfo *function_info)
08869 {
08870   int j, m;
08871 
08872   if (function_info->Template)
08873     {
08874     vtkParse_FreeTemplateArgs(function_info->Template);
08875     }
08876 
08877   m = function_info->NumberOfArguments;
08878   for (j = 0; j < m; j++) { vtkParse_FreeValue(function_info->Arguments[j]); }
08879   if (m > 0) { free(function_info->Arguments); }
08880 
08881   if (function_info->ReturnValue)
08882     {
08883     vtkParse_FreeValue(function_info->ReturnValue);
08884     }
08885 
08886   free(function_info);
08887 }
08888 
08889 void vtkParse_FreeClass(ClassInfo *class_info)
08890 {
08891   int j, m;
08892 
08893   if (class_info->Template) { vtkParse_FreeTemplateArgs(class_info->Template); }
08894 
08895   m = class_info->NumberOfSuperClasses;
08896   if (m > 0) { free((char **)class_info->SuperClasses); }
08897 
08898   m = class_info->NumberOfClasses;
08899   for (j = 0; j < m; j++) { vtkParse_FreeClass(class_info->Classes[j]); }
08900   if (m > 0) { free(class_info->Classes); }
08901 
08902   m = class_info->NumberOfFunctions;
08903   for (j = 0; j < m; j++) { vtkParse_FreeFunction(class_info->Functions[j]); }
08904   if (m > 0) { free(class_info->Functions); }
08905 
08906   m = class_info->NumberOfConstants;
08907   for (j = 0; j < m; j++) { vtkParse_FreeValue(class_info->Constants[j]); }
08908   if (m > 0) { free(class_info->Constants); }
08909 
08910   m = class_info->NumberOfVariables;
08911   for (j = 0; j < m; j++) { vtkParse_FreeValue(class_info->Variables[j]); }
08912   if (m > 0) { free(class_info->Variables); }
08913 
08914   m = class_info->NumberOfEnums;
08915   for (j = 0; j < m; j++) { vtkParse_FreeEnum(class_info->Enums[j]); }
08916   if (m > 0) { free(class_info->Enums); }
08917 
08918   m = class_info->NumberOfTypedefs;
08919   for (j = 0; j < m; j++) { vtkParse_FreeValue(class_info->Typedefs[j]); }
08920   if (m > 0) { free(class_info->Typedefs); }
08921 
08922   m = class_info->NumberOfUsings;
08923   for (j = 0; j < m; j++) { vtkParse_FreeUsing(class_info->Usings[j]); }
08924   if (m > 0) { free(class_info->Usings); }
08925 
08926   if (class_info->NumberOfItems > 0) { free(class_info->Items); }
08927 
08928   free(class_info);
08929 }
08930 
08931 void vtkParse_FreeNamespace(NamespaceInfo *namespace_info)
08932 {
08933   int j, m;
08934 
08935   m = namespace_info->NumberOfClasses;
08936   for (j = 0; j < m; j++) { vtkParse_FreeClass(namespace_info->Classes[j]); }
08937   if (m > 0) { free(namespace_info->Classes); }
08938 
08939   m = namespace_info->NumberOfFunctions;
08940   for (j=0; j<m; j++) { vtkParse_FreeFunction(namespace_info->Functions[j]); }
08941   if (m > 0) { free(namespace_info->Functions); }
08942 
08943   m = namespace_info->NumberOfConstants;
08944   for (j=0; j<m; j++) { vtkParse_FreeValue(namespace_info->Constants[j]); }
08945   if (m > 0) { free(namespace_info->Constants); }
08946 
08947   m = namespace_info->NumberOfVariables;
08948   for (j=0; j<m; j++) { vtkParse_FreeValue(namespace_info->Variables[j]); }
08949   if (m > 0) { free(namespace_info->Variables); }
08950 
08951   m = namespace_info->NumberOfEnums;
08952   for (j = 0; j < m; j++) { vtkParse_FreeEnum(namespace_info->Enums[j]); }
08953   if (m > 0) { free(namespace_info->Enums); }
08954 
08955   m = namespace_info->NumberOfTypedefs;
08956   for (j = 0; j < m; j++) { vtkParse_FreeValue(namespace_info->Typedefs[j]); }
08957   if (m > 0) { free(namespace_info->Typedefs); }
08958 
08959   m = namespace_info->NumberOfUsings;
08960   for (j = 0; j < m; j++) { vtkParse_FreeUsing(namespace_info->Usings[j]); }
08961   if (m > 0) { free(namespace_info->Usings); }
08962 
08963   m = namespace_info->NumberOfNamespaces;
08964   for (j=0; j<m; j++) {vtkParse_FreeNamespace(namespace_info->Namespaces[j]);}
08965   if (m > 0) { free(namespace_info->Namespaces); }
08966 
08967   free(namespace_info);
08968 }
08969 
08970 /* check whether this is the class we are looking for */
08971 void start_class(const char *classname, int is_struct_or_union)
08972 {
08973   ClassInfo *outerClass = currentClass;
08974   pushClass();
08975   currentClass = (ClassInfo *)malloc(sizeof(ClassInfo));
08976   vtkParse_InitClass(currentClass);
08977   currentClass->Name = vtkstrdup(classname);
08978   if (is_struct_or_union == 1)
08979     {
08980     currentClass->ItemType = VTK_STRUCT_INFO;
08981     }
08982   if (is_struct_or_union == 2)
08983     {
08984     currentClass->ItemType = VTK_UNION_INFO;
08985     }
08986 
08987   if (outerClass)
08988     {
08989     vtkParse_AddClassToClass(outerClass, currentClass);
08990     }
08991   else
08992     {
08993     vtkParse_AddClassToNamespace(currentNamespace, currentClass);
08994     }
08995 
08996   /* template information */
08997   if (currentTemplate)
08998     {
08999     currentClass->Template = currentTemplate;
09000     currentTemplate = NULL;
09001     }
09002 
09003   /* comment, if any */
09004   currentClass->Comment = vtkstrdup(getComment());
09005 
09006   access_level = VTK_ACCESS_PRIVATE;
09007   if (is_struct_or_union)
09008     {
09009     access_level = VTK_ACCESS_PUBLIC;
09010     }
09011 
09012   vtkParse_InitFunction(currentFunction);
09013   startSig();
09014   clearComment();
09015 }
09016 
09017 /* reject the class */
09018 void reject_class(const char *classname, int is_struct_or_union)
09019 {
09020   static ClassInfo static_class;
09021 
09022   pushClass();
09023   currentClass = &static_class;
09024   currentClass->Name = vtkstrdup(classname);
09025   vtkParse_InitClass(currentClass);
09026 
09027   access_level = VTK_ACCESS_PRIVATE;
09028   if (is_struct_or_union)
09029     {
09030     access_level = VTK_ACCESS_PUBLIC;
09031     }
09032 
09033   vtkParse_InitFunction(currentFunction);
09034   startSig();
09035   clearComment();
09036 }
09037 
09038 /* reached the end of a class definition */
09039 void end_class()
09040 {
09041   /* add default constructors */
09042   vtkParse_AddDefaultConstructors(currentClass);
09043 
09044   popClass();
09045 }
09046 
09047 /* add a using declaration or directive */
09048 void add_using(const char *name, int is_namespace)
09049 {
09050   size_t i;
09051   UsingInfo *item;
09052 
09053   item = (UsingInfo *)malloc(sizeof(UsingInfo));
09054   vtkParse_InitUsing(item);
09055   if (is_namespace)
09056     {
09057     item->Name = NULL;
09058     item->Scope = vtkstrdup(name);
09059     }
09060   else
09061     {
09062     i = strlen(name);
09063     while (i > 0 && name[i-1] != ':') { i--; }
09064     item->Name = vtkstrdup(&name[i]);
09065     while (i > 0 && name[i-1] == ':') { i--; }
09066     item->Scope = vtkstrndup(name, i);
09067     }
09068 
09069   if (currentClass)
09070     {
09071     vtkParse_AddUsingToClass(currentClass, item);
09072     }
09073   else
09074     {
09075     vtkParse_AddUsingToNamespace(currentNamespace, item);
09076     }
09077 }
09078 
09079 /* start a new enum */
09080 void start_enum(const char *name)
09081 {
09082   static char text[256];
09083   EnumInfo *item;
09084 
09085   currentEnumName = "int";
09086   currentEnumValue = NULL;
09087   if (name)
09088     {
09089     strcpy(text, name);
09090     currentEnumName = text;
09091     item = (EnumInfo *)malloc(sizeof(EnumInfo));
09092     vtkParse_InitEnum(item);
09093     item->Name = vtkstrdup(name);
09094     item->Access = access_level;
09095     if (currentClass)
09096       {
09097       vtkParse_AddEnumToClass(currentClass, item);
09098       }
09099     else
09100       {
09101       vtkParse_AddEnumToNamespace(currentNamespace, item);
09102       }
09103     }
09104 }
09105 
09106 /* finish the enum */
09107 void end_enum()
09108 {
09109   currentEnumName = NULL;
09110   currentEnumValue = NULL;
09111 }
09112 
09113 /* add a constant to the enum */
09114 void add_enum(const char *name, const char *value)
09115 {
09116   static char text[2048];
09117   int i;
09118   long j;
09119 
09120   if (value)
09121     {
09122     strcpy(text, value);
09123     currentEnumValue = text;
09124     }
09125   else if (currentEnumValue)
09126     {
09127     i = strlen(text);
09128     while (i > 0 && text[i-1] >= '0' &&
09129            text[i-1] <= '9') { i--; }
09130 
09131     if (i == 0 || text[i-1] == ' ' ||
09132         (i > 1 && text[i-2] == ' ' &&
09133          (text[i-1] == '-' || text[i-1] == '+')))
09134       {
09135       if (i > 0 && text[i-1] != ' ')
09136         {
09137         i--;
09138         }
09139       j = (int)strtol(&text[i], NULL, 10);
09140       sprintf(&text[i], "%li", j+1);
09141       }
09142     else
09143       {
09144       i = strlen(text);
09145       strcpy(&text[i], " + 1");
09146       }
09147     }
09148   else
09149     {
09150     strcpy(text, "0");
09151     currentEnumValue = text;
09152     }
09153 
09154   add_constant(name, currentEnumValue, VTK_PARSE_INT, currentEnumName, 2);
09155 }
09156 
09157 /* for a macro constant, guess the constant type */
09158 unsigned int guess_constant_type(const char *valstring)
09159 {
09160   unsigned int valtype = 0;
09161   size_t k;
09162   int i;
09163   int is_name = 0;
09164 
09165   if (valstring == NULL || valstring[0] == '\0')
09166     {
09167     return 0;
09168     }
09169 
09170   if (valstring[0] < '0' || valstring[0] > '9')
09171     {
09172     k = 0;
09173     while ((valstring[k] >= '0' && valstring[k] <= '9') ||
09174            (valstring[k] >= 'a' && valstring[k] <= 'z') ||
09175            (valstring[k] >= 'A' && valstring[k] <= 'Z') ||
09176            valstring[k] == '_') { k++; }
09177 
09178     if (valstring[k] == '\0')
09179       {
09180       is_name = 1;
09181       }
09182     }
09183 
09184   if (strcmp(valstring, "true") == 0 || strcmp(valstring, "false") == 0)
09185     {
09186     return VTK_PARSE_BOOL;
09187     }
09188 
09189   if (valstring[0] == '\'')
09190     {
09191     return VTK_PARSE_CHAR;
09192     }
09193 
09194   if (strncmp(valstring, "VTK_TYPE_CAST(", 14) == 0 ||
09195       strncmp(valstring, "static_cast<", 12) == 0 ||
09196       strncmp(valstring, "const_cast<", 11) == 0 ||
09197       strncmp(valstring, "(", 1) == 0)
09198     {
09199     const char *cp;
09200     size_t n;
09201     int is_unsigned = 0;
09202 
09203     cp = &valstring[1];
09204     if (valstring[0] == 'c')
09205       {
09206       cp = &valstring[11];
09207       }
09208     else if (valstring[0] == 's')
09209       {
09210       cp = &valstring[12];
09211       }
09212     else if (valstring[0] == 'V')
09213       {
09214       cp = &valstring[14];
09215       }
09216 
09217     if (strncmp(cp, "unsigned ", 9) == 0)
09218       {
09219       is_unsigned = 1;
09220       cp += 9;
09221       }
09222 
09223     n = strlen(cp);
09224     for (k = 0; k < n && cp[k] != ',' &&
09225          cp[k] != '>' && cp[k] != ')'; k++) { ; };
09226 
09227     if (strncmp(cp, "long long", k) == 0)
09228       { valtype = VTK_PARSE_LONG_LONG; }
09229     else if (strncmp(cp, "__int64", k) == 0)
09230       { valtype = VTK_PARSE___INT64; }
09231     else if (strncmp(cp, "long", k) == 0)
09232       { valtype = VTK_PARSE_LONG; }
09233     else if (strncmp(cp, "short", k) == 0)
09234       { valtype = VTK_PARSE_SHORT; }
09235     else if (strncmp(cp, "signed char", k) == 0)
09236       { valtype = VTK_PARSE_SIGNED_CHAR; }
09237     else if (strncmp(cp, "char", k) == 0)
09238       { valtype = VTK_PARSE_CHAR; }
09239     else if (strncmp(cp, "int", k) == 0 ||
09240              strncmp(cp, "signed", k) == 0)
09241       { valtype = VTK_PARSE_INT; }
09242     else if (strncmp(cp, "float", k) == 0)
09243       { valtype = VTK_PARSE_FLOAT; }
09244     else if (strncmp(cp, "double", k) == 0)
09245       { valtype = VTK_PARSE_DOUBLE; }
09246     else if (strncmp(cp, "char *", k) == 0)
09247       { valtype = VTK_PARSE_CHAR_PTR; }
09248 
09249     if (is_unsigned)
09250       {
09251       if (valtype == 0) { valtype = VTK_PARSE_INT; }
09252       valtype = (valtype | VTK_PARSE_UNSIGNED);
09253       }
09254 
09255     if (valtype != 0)
09256       {
09257       return valtype;
09258       }
09259     }
09260 
09261   /* check the current scope */
09262   if (is_name)
09263     {
09264     NamespaceInfo *scope = currentNamespace;
09265     if (namespaceDepth > 0)
09266       {
09267       scope = namespaceStack[0];
09268       }
09269 
09270     for (i = 0; i < scope->NumberOfConstants; i++)
09271       {
09272       if (strcmp(scope->Constants[i]->Name, valstring) == 0)
09273         {
09274         return scope->Constants[i]->Type;
09275         }
09276       }
09277     }
09278 
09279   /* check for preprocessor macros */
09280   if (is_name)
09281     {
09282     MacroInfo *macro = vtkParsePreprocess_GetMacro(
09283       &preprocessor, valstring);
09284 
09285     if (macro && !macro->IsFunction)
09286       {
09287       return guess_constant_type(macro->Definition);
09288       }
09289     }
09290 
09291   /* fall back to the preprocessor to evaluate the constant */
09292     {
09293     preproc_int_t val;
09294     int is_unsigned;
09295     int result = vtkParsePreprocess_EvaluateExpression(
09296       &preprocessor, valstring, &val, &is_unsigned);
09297 
09298     if (result == VTK_PARSE_PREPROC_DOUBLE)
09299       {
09300       return VTK_PARSE_DOUBLE;
09301       }
09302     else if (result == VTK_PARSE_PREPROC_FLOAT)
09303       {
09304       return VTK_PARSE_FLOAT;
09305       }
09306     else if (result == VTK_PARSE_PREPROC_STRING)
09307       {
09308       return VTK_PARSE_CHAR_PTR;
09309       }
09310     else if (result == VTK_PARSE_OK)
09311       {
09312       if (is_unsigned)
09313         {
09314         if ((preproc_uint_t)val <= VTK_UNSIGNED_INT_MAX)
09315           {
09316           return VTK_PARSE_UNSIGNED_INT;
09317           }
09318         else
09319           {
09320 #if defined(VTK_TYPE_USE_LONG_LONG)
09321           return VTK_PARSE_UNSIGNED_LONG_LONG;
09322 #elif defined(VTK_TYPE_USE___INT64)
09323           return VTK_PARSE_UNSIGNED___INT64;
09324 #else
09325           return VTK_PARSE_UNSIGNED_LONG;
09326 #endif
09327           }
09328         }
09329       else
09330         {
09331         if (val >= VTK_INT_MIN && val <= VTK_INT_MAX)
09332           {
09333           return VTK_PARSE_INT;
09334           }
09335         else
09336           {
09337 #if defined(VTK_TYPE_USE_LONG_LONG)
09338           return VTK_PARSE_LONG_LONG;
09339 #elif defined(VTK_TYPE_USE___INT64)
09340           return VTK_PARSE___INT64;
09341 #else
09342           return VTK_PARSE_LONG;
09343 #endif
09344           }
09345         }
09346       }
09347     }
09348 
09349   return 0;
09350 }
09351 
09352 /* add a constant to the current class or namespace */
09353 void add_constant(const char *name, const char *value,
09354                   unsigned int type, const char *typeclass, int flag)
09355 {
09356   ValueInfo *con = (ValueInfo *)malloc(sizeof(ValueInfo));
09357   vtkParse_InitValue(con);
09358   con->ItemType = VTK_CONSTANT_INFO;
09359   con->Name = vtkstrdup(name);
09360   con->Value = vtkstrdup(value);
09361   con->Type = type;
09362   if (typeclass)
09363     {
09364     con->Class = vtkstrdup(typeclass);
09365     }
09366 
09367   if (flag == 2)
09368     {
09369     con->IsEnum = 1;
09370     }
09371 
09372   if (flag == 1)
09373     {
09374     con->Access = VTK_ACCESS_PUBLIC;
09375     if (con->Type == 0)
09376       {
09377       con->Type = guess_constant_type(con->Value);
09378       }
09379     vtkParse_AddConstantToNamespace(data.Contents, con);
09380     }
09381   else if (currentClass)
09382     {
09383     con->Access = access_level;
09384     vtkParse_AddConstantToClass(currentClass, con);
09385     }
09386   else
09387     {
09388     con->Access = VTK_ACCESS_PUBLIC;
09389     vtkParse_AddConstantToNamespace(currentNamespace, con);
09390     }
09391 }
09392 
09393 /* if the name is a const in this namespace, the scope it */
09394 const char *add_const_scope(const char *name)
09395 {
09396   static char text[256];
09397   NamespaceInfo *scope = currentNamespace;
09398   int i, j;
09399   int addscope = 0;
09400 
09401   strcpy(text, name);
09402 
09403   if (currentClass)
09404     {
09405     for (j = 0; j < currentClass->NumberOfConstants; j++)
09406       {
09407       if (strcmp(currentClass->Constants[j]->Name, text) == 0)
09408         {
09409         prepend_scope(text, currentClass->Name);
09410         addscope = 1;
09411         }
09412       }
09413     }
09414   i = namespaceDepth;
09415   while (scope && scope->Name)
09416     {
09417     if (addscope)
09418       {
09419       prepend_scope(text, scope->Name);
09420       }
09421     else
09422       {
09423       for (j = 0; j < scope->NumberOfConstants; j++)
09424         {
09425         if (strcmp(scope->Constants[j]->Name, text) == 0)
09426           {
09427           prepend_scope(text, scope->Name);
09428           addscope = 1;
09429           }
09430         }
09431       }
09432 
09433     scope = 0;
09434     if (i > 0)
09435       {
09436       scope = namespaceStack[--i];
09437       }
09438     }
09439 
09440   return text;
09441 }
09442 
09443 /* add an arg to a function */
09444 void add_argument(FunctionInfo *func, unsigned int type,
09445                   const char *typeclass, int count)
09446 {
09447   int i = func->NumberOfArguments;
09448   char text[64];
09449   ValueInfo *arg = (ValueInfo *)malloc(sizeof(ValueInfo));
09450   vtkParse_InitValue(arg);
09451 
09452   arg->Type = type;
09453   if (typeclass)
09454     {
09455     arg->Class = vtkstrdup(typeclass);
09456     }
09457 
09458   if (count)
09459     {
09460     arg->Count = count;
09461     sprintf(text, "%i", count);
09462     vtkParse_AddStringToArray(&arg->Dimensions, &arg->NumberOfDimensions,
09463                               vtkstrdup(text));
09464     }
09465 
09466   func->ArgTypes[i] = arg->Type;
09467   func->ArgClasses[i] = arg->Class;
09468   func->ArgCounts[i] = count;
09469 
09470   vtkParse_AddArgumentToFunction(func, arg);
09471 }
09472 
09473 /* set the return type for the current function */
09474 void set_return(FunctionInfo *func, unsigned int type,
09475                 const char *typeclass, int count)
09476 {
09477   char text[64];
09478   ValueInfo *val = (ValueInfo *)malloc(sizeof(ValueInfo));
09479 
09480   vtkParse_InitValue(val);
09481   val->Type = type;
09482   if (typeclass)
09483     {
09484     val->Class = vtkstrdup(typeclass);
09485     }
09486 
09487   if (count)
09488     {
09489     val->Count = count;
09490     sprintf(text, "%i", count);
09491     vtkParse_AddStringToArray(&val->Dimensions, &val->NumberOfDimensions,
09492                               vtkstrdup(text));
09493     func->HaveHint = 1;
09494     }
09495 
09496   func->ReturnValue = val;
09497   func->ReturnType = val->Type;
09498   func->ReturnClass = val->Class;
09499   func->HintSize = count;
09500 }
09501 
09502 /* deal with types that include function pointers or arrays */
09503 void handle_complex_type(
09504   ValueInfo *val, unsigned int datatype, unsigned int extra,
09505   const char *funcSig)
09506 {
09507   FunctionInfo *func = 0;
09508   int i, n;
09509   const char *cp;
09510 
09511   /* if "extra" was set, parentheses were involved */
09512   if ((extra & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FUNCTION)
09513     {
09514     /* the current type becomes the function return type */
09515     func = getFunction();
09516     func->ReturnValue = (ValueInfo *)malloc(sizeof(ValueInfo));
09517     vtkParse_InitValue(func->ReturnValue);
09518     func->ReturnValue->Type = datatype;
09519     func->ReturnValue->Class = vtkstrdup(getTypeId());
09520     func->ReturnType = func->ReturnValue->Type;
09521     func->ReturnClass = func->ReturnValue->Class;
09522     if (funcSig) { func->Signature = vtkstrdup(funcSig); }
09523     val->Function = func;
09524 
09525     /* the val type is whatever was inside the parentheses */
09526     clearTypeId();
09527     setTypeId(func->Class ? "method" : "function");
09528     datatype = (extra & VTK_PARSE_UNQUALIFIED_TYPE);
09529     }
09530   else if ((extra & VTK_PARSE_INDIRECT) == VTK_PARSE_BAD_INDIRECT)
09531     {
09532     datatype = (datatype | VTK_PARSE_BAD_INDIRECT);
09533     }
09534   else if ((extra & VTK_PARSE_INDIRECT) != 0)
09535     {
09536     extra = (extra & VTK_PARSE_INDIRECT);
09537 
09538     if ((extra & VTK_PARSE_REF) != 0)
09539       {
09540       datatype = (datatype | VTK_PARSE_REF);
09541       extra = (extra & ~VTK_PARSE_REF);
09542       }
09543 
09544     if (extra != 0 && getArrayNDims() > 0)
09545       {
09546       /* pointer represents an unsized array bracket */
09547       datatype = add_indirection(datatype, VTK_PARSE_ARRAY);
09548       extra = ((extra >> 2) & VTK_PARSE_POINTER_MASK);
09549       }
09550 
09551     datatype = add_indirection(datatype, extra);
09552     }
09553 
09554   if (getArrayNDims() == 1)
09555     {
09556     if ((datatype & VTK_PARSE_POINTER_LOWMASK) != VTK_PARSE_ARRAY)
09557       {
09558       /* turn the first set of brackets into a pointer */
09559       datatype = add_indirection(datatype, VTK_PARSE_POINTER);
09560       }
09561     else
09562       {
09563       pushArrayFront("");
09564       }
09565     }
09566   else if (getArrayNDims() > 1)
09567     {
09568     if ((datatype & VTK_PARSE_POINTER_LOWMASK) != VTK_PARSE_ARRAY)
09569       {
09570       /* turn the first set of brackets into a pointer */
09571       datatype = add_indirection(datatype, VTK_PARSE_ARRAY);
09572       }
09573     else
09574       {
09575       pushArrayFront("");
09576       }
09577     }
09578 
09579   /* get the data type */
09580   val->Type = datatype;
09581   val->Class = vtkstrdup(getTypeId());
09582 
09583   /* copy contents of all brackets to the ArgDimensions */
09584   val->NumberOfDimensions = getArrayNDims();
09585   val->Dimensions = getArray();
09586   clearArray();
09587 
09588   /* count is the product of the dimensions */
09589   val->Count = 0;
09590   if (val->NumberOfDimensions)
09591     {
09592     val->Count = 1;
09593     for (i = 0; i < val->NumberOfDimensions; i++)
09594       {
09595       n = 0;
09596       cp = val->Dimensions[i];
09597       if (cp[0] != '\0')
09598         {
09599         while (*cp != '\0' && *cp >= '0' && *cp <= '9') { cp++; }
09600         if (*cp == '\0')
09601           {
09602           n = (int)strtol(val->Dimensions[i], NULL, 0);
09603           }
09604         }
09605       val->Count *= n;
09606       }
09607     }
09608 }
09609 
09610 /* specifically handle a VAR_FUNCTION argument */
09611 void handle_function_type(
09612   ValueInfo *arg, const char *name, const char *funcSig)
09613 {
09614   FunctionInfo *func;
09615   size_t j;
09616 
09617   arg->Type = VTK_PARSE_FUNCTION;
09618   arg->Class = vtkstrdup("function");
09619 
09620   if (name && name[0] != '\0')
09621     {
09622     arg->Name = vtkstrdup(name);
09623     }
09624 
09625   func = (FunctionInfo *)malloc(sizeof(FunctionInfo));
09626   vtkParse_InitFunction(func);
09627   add_argument(func, VTK_PARSE_VOID_PTR, "void", 0);
09628   set_return(func, VTK_PARSE_VOID, "void", 0);
09629   j = strlen(funcSig);
09630   while (j > 0 && funcSig[j-1] == ' ')
09631     {
09632     j--;
09633     }
09634 
09635   func->Signature = vtkstrndup(funcSig, j);
09636   arg->Function = func;
09637 }
09638 
09639 
09640 /* reject the function, do not output it */
09641 void reject_function()
09642 {
09643   vtkParse_InitFunction(currentFunction);
09644   startSig();
09645 }
09646 
09647 /* a simple routine that updates a few variables */
09648 void output_function()
09649 {
09650   size_t n;
09651   int i, j;
09652   int match;
09653 
09654   /* reject template specializations */
09655   n = strlen(currentFunction->Name);
09656   if (currentFunction->Name[n-1] == '>')
09657     {
09658     /* make sure there is a matching angle bracket */
09659     while (n > 0 && currentFunction->Name[n-1] != '<') { n--; }
09660     if (n > 0)
09661       {
09662       reject_function();
09663       return;
09664       }
09665     }
09666 
09667   /* static */
09668   if (currentFunction->ReturnType & VTK_PARSE_STATIC)
09669     {
09670     currentFunction->IsStatic = 1;
09671     }
09672 
09673   /* the signature */
09674   if (!currentFunction->Signature)
09675     {
09676     currentFunction->Signature = getSig();
09677     }
09678 
09679   /* template information */
09680   if (currentTemplate)
09681     {
09682     currentFunction->Template = currentTemplate;
09683     currentTemplate = NULL;
09684     }
09685 
09686   /* a void argument is the same as no arguments */
09687   if (currentFunction->NumberOfArguments == 1 &&
09688       (currentFunction->Arguments[0]->Type & VTK_PARSE_UNQUALIFIED_TYPE) ==
09689       VTK_PARSE_VOID)
09690     {
09691     currentFunction->NumberOfArguments = 0;
09692     }
09693 
09694   /* if return type is void, set return class to void */
09695   if (currentFunction->ReturnClass == NULL &&
09696       (currentFunction->ReturnType & VTK_PARSE_UNQUALIFIED_TYPE) ==
09697        VTK_PARSE_VOID)
09698     {
09699     currentFunction->ReturnClass = vtkstrdup("void");
09700     }
09701 
09702   /* set public, protected */
09703   if (currentClass)
09704     {
09705     currentFunction->Access = access_level;
09706     /* set legacy flags */
09707     currentFunction->IsPublic = (access_level == VTK_ACCESS_PUBLIC);
09708     currentFunction->IsProtected = (access_level == VTK_ACCESS_PROTECTED);
09709     }
09710   else
09711     {
09712     currentFunction->Access = VTK_ACCESS_PUBLIC;
09713     /* set legacy flags */
09714     currentFunction->IsPublic = 1;
09715     currentFunction->IsProtected = 0;
09716     }
09717 
09718   /* look for legacy VAR FUNCTIONS */
09719   if (currentFunction->NumberOfArguments
09720       && (currentFunction->Arguments[0]->Type == VTK_PARSE_FUNCTION))
09721     {
09722     if (currentFunction->NumberOfArguments != 2 ||
09723         currentFunction->Arguments[1]->Type != VTK_PARSE_VOID_PTR)
09724       {
09725       currentFunction->ArrayFailure = 1;
09726       }
09727     }
09728 
09729   /* check for too many arguments */
09730   if (currentFunction->NumberOfArguments > MAX_ARGS)
09731     {
09732     currentFunction->ArrayFailure = 1;
09733     }
09734 
09735   /* also legacy: tell old wrappers that multi-dimensional arrays are bad */
09736   for (i = 0; i < currentFunction->NumberOfArguments; i++)
09737     {
09738     ValueInfo *arg = currentFunction->Arguments[i];
09739     if ((arg->Type & VTK_PARSE_POINTER_MASK) != 0)
09740       {
09741       if (((arg->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FUNCTION) ||
09742           ((arg->Type & VTK_PARSE_INDIRECT) == VTK_PARSE_BAD_INDIRECT) ||
09743           ((arg->Type & VTK_PARSE_POINTER_LOWMASK) != VTK_PARSE_POINTER))
09744        {
09745        currentFunction->ArrayFailure = 1;
09746        }
09747       }
09748     }
09749 
09750   if (currentClass)
09751     {
09752     /* is it a delete function */
09753     if (currentFunction->Name && !strcmp("Delete",currentFunction->Name))
09754       {
09755       currentClass->HasDelete = 1;
09756       }
09757 
09758     currentFunction->Class = vtkstrdup(currentClass->Name);
09759     vtkParse_AddFunctionToClass(currentClass, currentFunction);
09760 
09761     currentFunction = (FunctionInfo *)malloc(sizeof(FunctionInfo));
09762     }
09763   else
09764     {
09765     /* make sure this function isn't a repeat */
09766     match = 0;
09767     for (i = 0; i < currentNamespace->NumberOfFunctions; i++)
09768       {
09769       if (currentNamespace->Functions[i]->Name &&
09770           strcmp(currentNamespace->Functions[i]->Name,
09771                  currentFunction->Name) == 0)
09772         {
09773         if (currentNamespace->Functions[i]->NumberOfArguments ==
09774             currentFunction->NumberOfArguments)
09775           {
09776           for (j = 0; j < currentFunction->NumberOfArguments; j++)
09777             {
09778             if (currentNamespace->Functions[i]->Arguments[j]->Type ==
09779                 currentFunction->Arguments[j]->Type)
09780               {
09781               if (currentFunction->Arguments[j]->Type == VTK_PARSE_OBJECT &&
09782                   strcmp(currentNamespace->Functions[i]->Arguments[j]->Class,
09783                          currentFunction->Arguments[j]->Class) == 0)
09784                 {
09785                 break;
09786                 }
09787               }
09788             }
09789           if (j == currentFunction->NumberOfArguments)
09790             {
09791             match = 1;
09792             break;
09793             }
09794           }
09795         }
09796       }
09797 
09798     if (!match)
09799       {
09800       vtkParse_AddFunctionToNamespace(currentNamespace, currentFunction);
09801 
09802       currentFunction = (FunctionInfo *)malloc(sizeof(FunctionInfo));
09803       }
09804     }
09805 
09806   vtkParse_InitFunction(currentFunction);
09807   startSig();
09808 }
09809 
09810 void outputSetVectorMacro(const char *var, unsigned int argType,
09811                           const char *typeText, int n)
09812 {
09813   static const char *mnames[] = {
09814     NULL, NULL,
09815     "vtkSetVector2Macro", "vtkSetVector3Macro", "vtkSetVector4Macro",
09816     NULL,
09817     "vtkSetVector6Macro",
09818     NULL };
09819   char ntext[32];
09820   int i, m;
09821   m = (n > 7 ? 0 : n);
09822 
09823   sprintf(ntext, "%i", n);
09824 
09825   currentFunction->Macro = mnames[m];
09826   currentFunction->Name = vtkstrcat("Set", var);
09827   startSig();
09828   postSig("void ");
09829   postSig(currentFunction->Name);
09830   postSig("(");
09831   postSig(typeText);
09832   for (i = 1; i < n; i++)
09833     {
09834     postSig(", ");
09835     postSig(typeText);
09836     }
09837   postSig(");");
09838   for (i = 0; i < n; i++)
09839     {
09840     add_argument(currentFunction, argType, getTypeId(), 0);
09841     }
09842   set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
09843   output_function();
09844 
09845   currentFunction->Macro = mnames[m];
09846   currentFunction->Name = vtkstrcat("Set", var);
09847   currentFunction->Signature =
09848     vtkstrcat7("void ", currentFunction->Name, "(", getTypeId(),
09849                " a[", ntext, "]);");
09850   add_argument(currentFunction, (VTK_PARSE_POINTER | argType),
09851                getTypeId(), n);
09852   set_return(currentFunction, VTK_PARSE_VOID, "void", 0);
09853   output_function();
09854 }
09855 
09856 void outputGetVectorMacro(const char *var, unsigned int argType,
09857                           const char *typeText, int n)
09858 {
09859   static const char *mnames[] = {
09860     NULL, NULL,
09861     "vtkGetVector2Macro", "vtkGetVector3Macro", "vtkGetVector4Macro",
09862     NULL,
09863     "vtkGetVector6Macro",
09864     NULL };
09865   int m;
09866   m = (n > 7 ? 0 : n);
09867 
09868   currentFunction->Macro = mnames[m];
09869   currentFunction->Name = vtkstrcat("Get", var);
09870   currentFunction->Signature =
09871     vtkstrcat4(typeText, " *", currentFunction->Name, "();");
09872   set_return(currentFunction, (VTK_PARSE_POINTER | argType), getTypeId(), n);
09873   output_function();
09874 }
09875 
09876 /* This method is used for extending dynamic arrays in a progression of
09877  * powers of two.  If "n" reaches a power of two, then the array size is
09878  * doubled so that "n" can be safely incremented. */
09879 static void *array_size_check(
09880   void *arraymem, size_t size, int n)
09881 {
09882   /* if empty, alloc for the first time */
09883   if (n == 0)
09884     {
09885     return malloc(size);
09886     }
09887   /* if count is power of two, reallocate with double size */
09888   else if ((n & (n-1)) == 0)
09889     {
09890     return realloc(arraymem, (n << 1)*size);
09891     }
09892 
09893   /* no reallocation, just return the original array */
09894   return arraymem;
09895 }
09896 
09897 /* Utility method to add a pointer to an array */
09898 void vtkParse_AddPointerToArray(
09899   void *valueArray, int *count, const void *value)
09900 {
09901   void **values = *(void ***)valueArray;
09902   int n = *count;
09903 
09904   values = (void **)array_size_check(values, sizeof(void *), n);
09905 
09906   values[n++] = (void *)value;
09907   *count = n;
09908   *(void ***)valueArray = values;
09909 }
09910 
09911 /*
09912  * There is a lot of repetition here, but all the code is written
09913  * out explicitly to avoid the use of macros or typecasts.  The
09914  * use of macros for generic programming makes code harder to debug,
09915  * and the use of C typecasts for anything but void* and char* breaks
09916  * the C99 standard.
09917  */
09918 
09919 /* Utility method to add an item to an array */
09920 void vtkParse_AddItemToArray(
09921   ItemInfo **valueArray, int *count,
09922   parse_item_t type, int idx)
09923 {
09924   size_t n = *count;
09925   ItemInfo *values = *valueArray;
09926 
09927   values = (ItemInfo *)array_size_check(values, sizeof(ItemInfo), n);
09928 
09929   values[n].Type = type;
09930   values[n].Index = idx;
09931   *count = n+1;
09932   *valueArray = values;
09933 }
09934 
09935 /* Add a ClassInfo to a ClassInfo */
09936 void vtkParse_AddClassToClass(ClassInfo *info, ClassInfo *item)
09937 {
09938   vtkParse_AddItemToArray(&info->Items, &info->NumberOfItems,
09939     item->ItemType, info->NumberOfClasses);
09940   info->Classes = (ClassInfo **)array_size_check(
09941     info->Classes, sizeof(ClassInfo *), info->NumberOfClasses);
09942   info->Classes[info->NumberOfClasses++] = item;
09943 }
09944 
09945 /* Add a FunctionInfo to a ClassInfo */
09946 void vtkParse_AddFunctionToClass(ClassInfo *info, FunctionInfo *item)
09947 {
09948   vtkParse_AddItemToArray(&info->Items, &info->NumberOfItems,
09949     item->ItemType, info->NumberOfFunctions);
09950   info->Functions = (FunctionInfo **)array_size_check(
09951     info->Functions, sizeof(FunctionInfo *), info->NumberOfFunctions);
09952   info->Functions[info->NumberOfFunctions++] = item;
09953 }
09954 
09955 /* Add a EnumInfo to a ClassInfo */
09956