1    | /* A Bison parser, made by GNU Bison 3.0.4.  */
2    | 
3    | /* Bison implementation for Yacc-like parsers in C
4    | 
5    |    Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
6    | 
7    |    This program is free software: you can redistribute it and/or modify
8    |    it under the terms of the GNU General Public License as published by
9    |    the Free Software Foundation, either version 3 of the License, or
10   |    (at your option) any later version.
11   | 
12   |    This program is distributed in the hope that it will be useful,
13   |    but WITHOUT ANY WARRANTY; without even the implied warranty of
14   |    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   |    GNU General Public License for more details.
16   | 
17   |    You should have received a copy of the GNU General Public License
18   |    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19   | 
20   | /* As a special exception, you may create a larger work that contains
21   |    part or all of the Bison parser skeleton and distribute that work
22   |    under terms of your choice, so long as that work isn't itself a
23   |    parser generator using the skeleton or a modified version thereof
24   |    as a parser skeleton.  Alternatively, if you modify or redistribute
25   |    the parser skeleton itself, you may (at your option) remove this
26   |    special exception, which will cause the skeleton and the resulting
27   |    Bison output files to be licensed under the GNU General Public
28   |    License without this special exception.
29   | 
30   |    This special exception was added by the Free Software Foundation in
31   |    version 2.2 of Bison.  */
32   | 
33   | /* C LALR(1) parser skeleton written by Richard Stallman, by
34   |    simplifying the original so-called "semantic" parser.  */
35   | 
36   | /* All symbols defined below should begin with yy or YY, to avoid
37   |    infringing on user name space.  This should be done even for local
38   |    variables, as they might otherwise be expanded by user macros.
39   |    There are some unavoidable exceptions within include files to
40   |    define necessary library symbols; they are noted "INFRINGES ON
41   |    USER NAME SPACE" below.  */
42   | 
43   | /* Identify Bison output.  */
44   | #define YYBISON 1
45   | 
46   | /* Bison version.  */
47   | #define YYBISON_VERSION "3.0.4"
48   | 
49   | /* Skeleton name.  */
50   | #define YYSKELETON_NAME "yacc.c"
51   | 
52   | /* Pure parsers.  */
53   | #define YYPURE 0
54   | 
55   | /* Push parsers.  */
56   | #define YYPUSH 0
57   | 
58   | /* Pull parsers.  */
59   | #define YYPULL 1
60   | 
61   | 
62   | 
63   | 
64   | /* Copy the first part of user declarations.  */
65   | #line 1 "./parse.y" /* yacc.c:339  */
66   | 
67   | /***************************************
68   |   C Cross Referencing & Documentation tool. Version 1.6e.
69   | 
70   |   C parser.
71   |   ******************/ /******************
72   |   Written by Andrew M. Bishop
73   | 
74   |   This file Copyright 1995-2013 Andrew M. Bishop
75   |   It may be distributed under the GNU Public License, version 2, or
76   |   any higher version.  See section COPYING of the GNU Public license
77   |   for conditions under which this file may be redistributed.
78   |   ***************************************/
79   | 
80   | #include <string.h>
81   | #include "parse-yy.h"
82   | #include "cxref.h"
83   | #include "memory.h"
84   | 
85   | /*+ A structure to hold the information about an object. +*/
86   | typedef struct _stack
87   | {
88   |  char *name;                    /*+ The name of the object. +*/
89   |  char *type;                    /*+ The type of the object. +*/
90   |  char *qual;                    /*+ The type qualifier of the object. +*/
91   | }
92   | stack;
93   | 
94   | #define yylex cxref_yylex
95   | 
96   | static int cxref_yylex(void);
97   | 
98   | static void yyerror(const char *s);
99   | 
100  | /*+ When in a header file, some stuff can be skipped over quickly. +*/
101  | extern int in_header;
102  | 
103  | /*+ A flag that is set to true when typedef is seen in a statement. +*/
104  | int in_typedef=0;
105  | 
106  | /*+ The scope of the function / variable that is being examined. +*/
107  | static int scope;
108  | 
109  | /*+ The variable must be LOCAL or EXTERNAL or GLOBAL, so this checks and sets that. +*/
110  | #define SCOPE ( scope&(LOCAL|EXTERNAL|EXTERN_H|EXTERN_F) ? scope : scope|GLOBAL )
111  | 
112  | /*+ When in a function or a function definition, the behaviour is different. +*/
113  | static int in_function=0,in_funcdef=0,in_funcbody=0;
114  | 
115  | /*+ The parsing stack +*/
116  | static stack first={NULL,NULL,NULL},  /*+ first value. +*/
117  |             *list=NULL,               /*+ list of all values. +*/
118  |             *current=&first;          /*+ current values. +*/
119  | 
120  | /*+ The depth of the stack +*/
121  | static int depth=0,             /*+ currently in use. +*/
122  |            maxdepth=0;          /*+ total malloced. +*/
123  | 
124  | /*+ Declarations that are in the same statement share this comment. +*/
125  | static char* common_comment=NULL;
126  | 
127  | /*+ When inside a struct / union / enum definition, this is the depth. +*/
128  | static int in_structunion=0;
129  | 
130  | /*+ When inside a struct / union definition, this is the component type. +*/
131  | static char *comp_type=NULL;
132  | 
133  | /*+ To solve the problem where a type name is used as an identifier. +*/
134  | static int in_type_spec=0;
135  | 
136  | 
137  | /*++++++++++++++++++++++++++++++++++++++
138  |   Reset the current level on the stack.
139  |   ++++++++++++++++++++++++++++++++++++++*/
140  | 
141  | static void reset(void)
142  | {
143  |  current->name=NULL;
144  |  current->type=NULL;
145  |  current->qual=NULL;
146  | }
147  | 
148  | 
149  | /*++++++++++++++++++++++++++++++++++++++
150  |   Push a level onto the stack.
151  |   ++++++++++++++++++++++++++++++++++++++*/
152  | 
153  | static void push(void)
154  | {
155  |  if(list==NULL)
156  |    {
157  |     list=(stack*)Malloc(8*sizeof(struct _stack));
158  |     list[0]=first;
159  |     maxdepth=8;
160  |    }
161  |  else if(depth==(maxdepth-1))
162  |    {
163  |     list=Realloc(list,(maxdepth+8)*sizeof(struct _stack));
164  |     maxdepth+=8;
165  |    }
166  | 
167  |  depth++;
168  |  current=&list[depth];
169  | 
170  |  reset();
171  | }
172  | 
173  | 
174  | /*++++++++++++++++++++++++++++++++++++++
175  |   Pop a level from the stack.
176  |   ++++++++++++++++++++++++++++++++++++++*/
177  | 
178  | static void pop(void)
179  | {
180  |  reset();
181  | 
182  |  depth--;
183  |  current=&list[depth];
184  | }
185  | 
186  | 
187  | /*++++++++++++++++++++++++++++++++++++++
188  |   Reset the Parser, ready for the next file.
189  |   ++++++++++++++++++++++++++++++++++++++*/
190  | 
191  | void ResetParser(void)
192  | {
193  |  in_typedef=0;
194  |  scope=0;
195  |  in_function=0;
196  |  in_funcdef=0;
197  |  in_funcbody=0;
198  |  depth=0;
199  |  maxdepth=0;
200  |  if(list) Free(list);
201  |  list=NULL;
202  |  current=&first;
203  |  reset();
204  |  common_comment=NULL;
205  |  in_structunion=0;
206  |  comp_type=NULL;
207  |  in_type_spec=0;
208  | }
209  | 
210  | 
211  | #line 212 "y.tab.c" /* yacc.c:339  */
212  | 
213  | # ifndef YY_NULLPTR
214  | #  if defined __cplusplus && 201103L <= __cplusplus
215  | #   define YY_NULLPTR nullptr
216  | #  else
217  | #   define YY_NULLPTR 0
218  | #  endif
219  | # endif
220  | 
221  | /* Enabling verbose error messages.  */
222  | #ifdef YYERROR_VERBOSE
223  | # undef YYERROR_VERBOSE
224  | # define YYERROR_VERBOSE 1
225  | #else
226  | # define YYERROR_VERBOSE 0
227  | #endif
228  | 
229  | /* In a future release of Bison, this section will be replaced
230  |    by #include "y.tab.h".  */
231  | #ifndef YY_YY_Y_TAB_H_INCLUDED
232  | # define YY_YY_Y_TAB_H_INCLUDED
233  | /* Debug traces.  */
234  | #ifndef YYDEBUG
235  | # define YYDEBUG 0
236  | #endif
237  | #if YYDEBUG
238  | extern int yydebug;
239  | #endif
240  | 
241  | /* Token type.  */
242  | #ifndef YYTOKENTYPE
243  | # define YYTOKENTYPE
244  |   enum yytokentype
245  |   {
246  |     IDENTIFIER = 258,
247  |     TYPE_NAME = 259,
248  |     LITERAL = 260,
249  |     STRING_LITERAL = 261,
250  |     ELLIPSES = 262,
251  |     MUL_ASSIGN = 263,
252  |     DIV_ASSIGN = 264,
253  |     MOD_ASSIGN = 265,
254  |     ADD_ASSIGN = 266,
255  |     SUB_ASSIGN = 267,
256  |     LEFT_ASSIGN = 268,
257  |     RIGHT_ASSIGN = 269,
258  |     AND_ASSIGN = 270,
259  |     XOR_ASSIGN = 271,
260  |     OR_ASSIGN = 272,
261  |     EQ_OP = 273,
262  |     NE_OP = 274,
263  |     PTR_OP = 275,
264  |     AND_OP = 276,
265  |     OR_OP = 277,
266  |     DEC_OP = 278,
267  |     INC_OP = 279,
268  |     LE_OP = 280,
269  |     GE_OP = 281,
270  |     LEFT_SHIFT = 282,
271  |     RIGHT_SHIFT = 283,
272  |     SIZEOF = 284,
273  |     TYPEDEF = 285,
274  |     EXTERN = 286,
275  |     STATIC = 287,
276  |     AUTO = 288,
277  |     REGISTER = 289,
278  |     CONST = 290,
279  |     VOLATILE = 291,
280  |     VOID = 292,
281  |     INLINE = 293,
282  |     CHAR = 294,
283  |     SHORT = 295,
284  |     INT = 296,
285  |     LONG = 297,
286  |     SIGNED = 298,
287  |     UNSIGNED = 299,
288  |     FLOAT = 300,
289  |     DOUBLE = 301,
290  |     BOOL = 302,
291  |     STRUCT = 303,
292  |     UNION = 304,
293  |     ENUM = 305,
294  |     CASE = 306,
295  |     DEFAULT = 307,
296  |     IF = 308,
297  |     ELSE = 309,
298  |     SWITCH = 310,
299  |     WHILE = 311,
300  |     DO = 312,
301  |     FOR = 313,
302  |     GOTO = 314,
303  |     CONTINUE = 315,
304  |     BREAK = 316,
305  |     RETURN = 317,
306  |     ASM = 318
307  |   };
308  | #endif
309  | /* Tokens.  */
310  | #define IDENTIFIER 258
311  | #define TYPE_NAME 259
312  | #define LITERAL 260
313  | #define STRING_LITERAL 261
314  | #define ELLIPSES 262
315  | #define MUL_ASSIGN 263
316  | #define DIV_ASSIGN 264
317  | #define MOD_ASSIGN 265
318  | #define ADD_ASSIGN 266
319  | #define SUB_ASSIGN 267
320  | #define LEFT_ASSIGN 268
321  | #define RIGHT_ASSIGN 269
322  | #define AND_ASSIGN 270
323  | #define XOR_ASSIGN 271
324  | #define OR_ASSIGN 272
325  | #define EQ_OP 273
326  | #define NE_OP 274
327  | #define PTR_OP 275
328  | #define AND_OP 276
329  | #define OR_OP 277
330  | #define DEC_OP 278
331  | #define INC_OP 279
332  | #define LE_OP 280
333  | #define GE_OP 281
334  | #define LEFT_SHIFT 282
335  | #define RIGHT_SHIFT 283
336  | #define SIZEOF 284
337  | #define TYPEDEF 285
338  | #define EXTERN 286
339  | #define STATIC 287
340  | #define AUTO 288
341  | #define REGISTER 289
342  | #define CONST 290
343  | #define VOLATILE 291
344  | #define VOID 292
345  | #define INLINE 293
346  | #define CHAR 294
347  | #define SHORT 295
348  | #define INT 296
349  | #define LONG 297
350  | #define SIGNED 298
351  | #define UNSIGNED 299
352  | #define FLOAT 300
353  | #define DOUBLE 301
354  | #define BOOL 302
355  | #define STRUCT 303
356  | #define UNION 304
357  | #define ENUM 305
358  | #define CASE 306
359  | #define DEFAULT 307
360  | #define IF 308
361  | #define ELSE 309
362  | #define SWITCH 310
363  | #define WHILE 311
364  | #define DO 312
365  | #define FOR 313
366  | #define GOTO 314
367  | #define CONTINUE 315
368  | #define BREAK 316
369  | #define RETURN 317
370  | #define ASM 318
371  | 
372  | /* Value type.  */
373  | #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
374  | typedef int YYSTYPE;
375  | # define YYSTYPE_IS_TRIVIAL 1
376  | # define YYSTYPE_IS_DECLARED 1
377  | #endif
378  | 
379  | 
380  | extern YYSTYPE yylval;
381  | 
382  | int yyparse (void);
383  | 
384  | #endif /* !YY_YY_Y_TAB_H_INCLUDED  */
385  | 
386  | /* Copy the second part of user declarations.  */
387  | 
388  | #line 389 "y.tab.c" /* yacc.c:358  */
389  | 
390  | #ifdef short
391  | # undef short
392  | #endif
393  | 
394  | #ifdef YYTYPE_UINT8
395  | typedef YYTYPE_UINT8 yytype_uint8;
396  | #else
397  | typedef unsigned char yytype_uint8;
398  | #endif
399  | 
400  | #ifdef YYTYPE_INT8
401  | typedef YYTYPE_INT8 yytype_int8;
402  | #else
403  | typedef signed char yytype_int8;
404  | #endif
405  | 
406  | #ifdef YYTYPE_UINT16
407  | typedef YYTYPE_UINT16 yytype_uint16;
408  | #else
409  | typedef unsigned short int yytype_uint16;
410  | #endif
411  | 
412  | #ifdef YYTYPE_INT16
413  | typedef YYTYPE_INT16 yytype_int16;
414  | #else
415  | typedef short int yytype_int16;
416  | #endif
417  | 
418  | #ifndef YYSIZE_T
419  | # ifdef __SIZE_TYPE__
420  | #  define YYSIZE_T __SIZE_TYPE__
421  | # elif defined size_t
422  | #  define YYSIZE_T size_t
423  | # elif ! defined YYSIZE_T
424  | #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
425  | #  define YYSIZE_T size_t
426  | # else
427  | #  define YYSIZE_T unsigned int
428  | # endif
429  | #endif
430  | 
431  | #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
432  | 
433  | #ifndef YY_
434  | # if defined YYENABLE_NLS && YYENABLE_NLS
435  | #  if ENABLE_NLS
436  | #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
437  | #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
438  | #  endif
439  | # endif
440  | # ifndef YY_
441  | #  define YY_(Msgid) Msgid
442  | # endif
443  | #endif
444  | 
445  | #ifndef YY_ATTRIBUTE
446  | # if (defined __GNUC__                                               \
447  |       && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
448  |      || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
449  | #  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
450  | # else
451  | #  define YY_ATTRIBUTE(Spec) /* empty */
452  | # endif
453  | #endif
454  | 
455  | #ifndef YY_ATTRIBUTE_PURE
456  | # define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
457  | #endif
458  | 
459  | #ifndef YY_ATTRIBUTE_UNUSED
460  | # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
461  | #endif
462  | 
463  | #if !defined _Noreturn \
464  |      && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
465  | # if defined _MSC_VER && 1200 <= _MSC_VER
466  | #  define _Noreturn __declspec (noreturn)
467  | # else
468  | #  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
469  | # endif
470  | #endif
471  | 
472  | /* Suppress unused-variable warnings by "using" E.  */
473  | #if ! defined lint || defined __GNUC__
474  | # define YYUSE(E) ((void) (E))
475  | #else
476  | # define YYUSE(E) /* empty */
477  | #endif
478  | 
479  | #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
480  | /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
481  | # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
482  |     _Pragma ("GCC diagnostic push") \
483  |     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
484  |     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
485  | # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
486  |     _Pragma ("GCC diagnostic pop")
487  | #else
488  | # define YY_INITIAL_VALUE(Value) Value
489  | #endif
490  | #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
491  | # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
492  | # define YY_IGNORE_MAYBE_UNINITIALIZED_END
493  | #endif
494  | #ifndef YY_INITIAL_VALUE
495  | # define YY_INITIAL_VALUE(Value) /* Nothing. */
496  | #endif
497  | 
498  | 
499  | #if ! defined yyoverflow || YYERROR_VERBOSE
500  | 
501  | /* The parser invokes alloca or malloc; define the necessary symbols.  */
502  | 
503  | # ifdef YYSTACK_USE_ALLOCA
504  | #  if YYSTACK_USE_ALLOCA
505  | #   ifdef __GNUC__
506  | #    define YYSTACK_ALLOC __builtin_alloca
507  | #   elif defined __BUILTIN_VA_ARG_INCR
508  | #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
509  | #   elif defined _AIX
510  | #    define YYSTACK_ALLOC __alloca
511  | #   elif defined _MSC_VER
512  | #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
513  | #    define alloca _alloca
514  | #   else
515  | #    define YYSTACK_ALLOC alloca
516  | #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
517  | #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
518  |       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
519  | #     ifndef EXIT_SUCCESS
520  | #      define EXIT_SUCCESS 0
521  | #     endif
522  | #    endif
523  | #   endif
524  | #  endif
525  | # endif
526  | 
527  | # ifdef YYSTACK_ALLOC
528  |    /* Pacify GCC's 'empty if-body' warning.  */
529  | #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
530  | #  ifndef YYSTACK_ALLOC_MAXIMUM
531  |     /* The OS might guarantee only one guard page at the bottom of the stack,
532  |        and a page size can be as small as 4096 bytes.  So we cannot safely
533  |        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
534  |        to allow for a few compiler-allocated temporary stack slots.  */
535  | #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
536  | #  endif
537  | # else
538  | #  define YYSTACK_ALLOC YYMALLOC
539  | #  define YYSTACK_FREE YYFREE
540  | #  ifndef YYSTACK_ALLOC_MAXIMUM
541  | #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
542  | #  endif
543  | #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
544  |        && ! ((defined YYMALLOC || defined malloc) \
545  |              && (defined YYFREE || defined free)))
546  | #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
547  | #   ifndef EXIT_SUCCESS
548  | #    define EXIT_SUCCESS 0
549  | #   endif
550  | #  endif
551  | #  ifndef YYMALLOC
552  | #   define YYMALLOC malloc
553  | #   if ! defined malloc && ! defined EXIT_SUCCESS
554  | void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
555  | #   endif
556  | #  endif
557  | #  ifndef YYFREE
558  | #   define YYFREE free
559  | #   if ! defined free && ! defined EXIT_SUCCESS
560  | void free (void *); /* INFRINGES ON USER NAME SPACE */
561  | #   endif
562  | #  endif
563  | # endif
564  | #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
565  | 
566  | 
567  | #if (! defined yyoverflow \
568  |      && (! defined __cplusplus \
569  |          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
570  | 
571  | /* A type that is properly aligned for any stack member.  */
572  | union yyalloc
573  | {
574  |   yytype_int16 yyss_alloc;
575  |   YYSTYPE yyvs_alloc;
576  | };
577  | 
578  | /* The size of the maximum gap between one aligned stack and the next.  */
579  | # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
580  | 
581  | /* The size of an array large to enough to hold all stacks, each with
582  |    N elements.  */
583  | # define YYSTACK_BYTES(N) \
584  |      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
585  |       + YYSTACK_GAP_MAXIMUM)
586  | 
587  | # define YYCOPY_NEEDED 1
588  | 
589  | /* Relocate STACK from its old location to the new one.  The
590  |    local variables YYSIZE and YYSTACKSIZE give the old and new number of
591  |    elements in the stack, and YYPTR gives the new location of the
592  |    stack.  Advance YYPTR to a properly aligned location for the next
593  |    stack.  */
594  | # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
595  |     do                                                                  \
596  |       {                                                                 \
597  |         YYSIZE_T yynewbytes;                                            \
598  |         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
599  |         Stack = &yyptr->Stack_alloc;                                    \
600  |         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
601  |         yyptr += yynewbytes / sizeof (*yyptr);                          \
602  |       }                                                                 \
603  |     while (0)
604  | 
605  | #endif
606  | 
607  | #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
608  | /* Copy COUNT objects from SRC to DST.  The source and destination do
609  |    not overlap.  */
610  | # ifndef YYCOPY
611  | #  if defined __GNUC__ && 1 < __GNUC__
612  | #   define YYCOPY(Dst, Src, Count) \
613  |       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
614  | #  else
615  | #   define YYCOPY(Dst, Src, Count)              \
616  |       do                                        \
617  |         {                                       \
618  |           YYSIZE_T yyi;                         \
619  |           for (yyi = 0; yyi < (Count); yyi++)   \
620  |             (Dst)[yyi] = (Src)[yyi];            \
621  |         }                                       \
622  |       while (0)
623  | #  endif
624  | # endif
625  | #endif /* !YYCOPY_NEEDED */
626  | 
627  | /* YYFINAL -- State number of the termination state.  */
628  | #define YYFINAL  92
629  | /* YYLAST -- Last index in YYTABLE.  */
630  | #define YYLAST   1500
631  | 
632  | /* YYNTOKENS -- Number of terminals.  */
633  | #define YYNTOKENS  88
634  | /* YYNNTS -- Number of nonterminals.  */
635  | #define YYNNTS  172
636  | /* YYNRULES -- Number of rules.  */
637  | #define YYNRULES  379
638  | /* YYNSTATES -- Number of states.  */
639  | #define YYNSTATES  572
640  | 
641  | /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
642  |    by yylex, with out-of-bounds checking.  */
643  | #define YYUNDEFTOK  2
644  | #define YYMAXUTOK   318
645  | 
646  | #define YYTRANSLATE(YYX)                                                \
647  |   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
648  | 
649  | /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
650  |    as returned by yylex, without out-of-bounds checking.  */
651  | static const yytype_uint8 yytranslate[] =
652  | {
653  |        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
654  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
655  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
656  |        2,     2,     2,    87,     2,     2,     2,    85,    79,     2,
657  |       73,    74,    75,    82,    65,    83,    70,    84,     2,     2,
658  |        2,     2,     2,     2,     2,     2,     2,     2,    69,    64,
659  |       80,    66,    81,    76,     2,     2,     2,     2,     2,     2,
660  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
661  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
662  |        2,    71,     2,    72,    78,     2,     2,     2,     2,     2,
663  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
664  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
665  |        2,     2,     2,    67,    77,    68,    86,     2,     2,     2,
666  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
667  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
668  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
669  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
670  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
671  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
672  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
673  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
674  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
675  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
676  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
677  |        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
678  |        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
679  |        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
680  |       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
681  |       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
682  |       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
683  |       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
684  |       55,    56,    57,    58,    59,    60,    61,    62,    63
685  | };
686  | 
687  | #if YYDEBUG
688  |   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
689  | static const yytype_uint16 yyrline[] =
690  | {
691  |        0,   166,   166,   168,   172,   173,   177,   179,   181,   182,
692  |      188,   190,   196,   198,   203,   209,   210,   212,   214,   217,
693  |      218,   225,   226,   226,   230,   274,   275,   276,   277,   281,
694  |      285,   286,   289,   291,   292,   293,   297,   298,   299,   303,
695  |      304,   308,   309,   313,   314,   320,   321,   323,   327,   330,
696  |      332,   334,   336,   338,   340,   342,   344,   351,   353,   358,
697  |      359,   361,   363,   368,   369,   373,   374,   378,   385,   387,
698  |      387,   387,   394,   398,   400,   405,   407,   409,   413,   418,
699  |      419,   424,   426,   433,   438,   439,   440,   441,   442,   443,
700  |      444,   445,   449,   450,   451,   453,   458,   459,   461,   466,
701  |      467,   468,   469,   470,   471,   475,   479,   483,   487,   489,
702  |      496,   497,   502,   501,   515,   514,   530,   531,   535,   536,
703  |      541,   543,   548,   552,   557,   558,   564,   565,   570,   569,
704  |      583,   582,   598,   603,   604,   610,   611,   616,   615,   629,
705  |      628,   644,   649,   650,   655,   657,   661,   662,   667,   668,
706  |      671,   674,   679,   678,   683,   682,   687,   686,   693,   695,
707  |      701,   702,   706,   711,   713,   718,   722,   723,   732,   731,
708  |      738,   761,   762,   764,   765,   772,   777,   778,   779,   781,
709  |      787,   786,   797,   806,   808,   809,   813,   815,   821,   822,
710  |      828,   831,   837,   839,   841,   848,   849,   850,   851,   852,
711  |      853,   854,   855,   856,   857,   858,   859,   866,   868,   865,
712  |      872,   874,   878,   879,   883,   884,   891,   892,   896,   900,
713  |      906,   907,   908,   912,   917,   916,   923,   924,   925,   926,
714  |      927,   928,   929,   930,   934,   935,   937,   942,   948,   949,
715  |      950,   954,   955,   959,   963,   964,   970,   976,   980,   984,
716  |      988,   992,   996,   997,  1003,  1009,  1010,  1017,  1018,  1019,
717  |     1020,  1024,  1025,  1026,  1027,  1028,  1029,  1030,  1031,  1032,
718  |     1033,  1034,  1040,  1041,  1043,  1050,  1051,  1058,  1059,  1066,
719  |     1067,  1074,  1075,  1082,  1083,  1090,  1091,  1096,  1097,  1103,
720  |     1104,  1109,  1110,  1111,  1112,  1118,  1119,  1124,  1125,  1131,
721  |     1132,  1137,  1138,  1144,  1145,  1150,  1151,  1152,  1158,  1159,
722  |     1160,  1161,  1162,  1163,  1164,  1165,  1166,  1167,  1168,  1172,
723  |     1176,  1181,  1183,  1187,  1191,  1196,  1200,  1204,  1206,  1211,
724  |     1216,  1223,  1224,  1225,  1227,  1228,  1229,  1230,  1234,  1235,
725  |     1239,  1243,  1247,  1248,  1252,  1253,  1257,  1261,  1265,  1269,
726  |     1271,  1272,  1273,  1277,  1278,  1282,  1284,  1284,  1284,  1290,
727  |     1294,  1295,  1303,  1304,  1305,  1306,  1310,  1311,  1312,  1315,
728  |     1317,  1318,  1322,  1323,  1324,  1327,  1329,  1330,  1334,  1340
729  | };
730  | #endif
731  | 
732  | #if YYDEBUG || YYERROR_VERBOSE || 0
733  | /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
734  |    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
735  | static const char *const yytname[] =
736  | {
737  |   "$end", "error", "$undefined", "IDENTIFIER", "TYPE_NAME", "LITERAL",
738  |   "STRING_LITERAL", "ELLIPSES", "MUL_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN",
739  |   "ADD_ASSIGN", "SUB_ASSIGN", "LEFT_ASSIGN", "RIGHT_ASSIGN", "AND_ASSIGN",
740  |   "XOR_ASSIGN", "OR_ASSIGN", "EQ_OP", "NE_OP", "PTR_OP", "AND_OP", "OR_OP",
741  |   "DEC_OP", "INC_OP", "LE_OP", "GE_OP", "LEFT_SHIFT", "RIGHT_SHIFT",
742  |   "SIZEOF", "TYPEDEF", "EXTERN", "STATIC", "AUTO", "REGISTER", "CONST",
743  |   "VOLATILE", "VOID", "INLINE", "CHAR", "SHORT", "INT", "LONG", "SIGNED",
744  |   "UNSIGNED", "FLOAT", "DOUBLE", "BOOL", "STRUCT", "UNION", "ENUM", "CASE",
745  |   "DEFAULT", "IF", "ELSE", "SWITCH", "WHILE", "DO", "FOR", "GOTO",
746  |   "CONTINUE", "BREAK", "RETURN", "ASM", "';'", "','", "'='", "'{'", "'}'",
747  |   "':'", "'.'", "'['", "']'", "'('", "')'", "'*'", "'?'", "'|'", "'^'",
748  |   "'&'", "'<'", "'>'", "'+'", "'-'", "'/'", "'%'", "'~'", "'!'", "$accept",
749  |   "file", "program", "top_level_declaration", "declaration_list",
750  |   "declaration", "declaration_specifiers", "declaration_specifiers1",
751  |   "initialized_declarator_list", "$@1", "initialized_declarator",
752  |   "initialized_declarator1", "initializer_part", "initializer",
753  |   "struct_initializer_list", "named_initializer", "designator",
754  |   "designator_list", "named_initializer_index", "abstract_declarator",
755  |   "direct_abstract_declarator", "declarator", "pointer",
756  |   "direct_declarator", "simple_declarator", "array_declarator", "$@2",
757  |   "$@3", "name", "storage_class_specifier", "type_qualifier_list",
758  |   "type_qualifier", "type_specifier", "type_specifier1",
759  |   "floating_type_specifier", "integer_type_specifier",
760  |   "integer_type_specifier_part", "boolean_type_specifier", "typedef_name",
761  |   "void_type_specifier", "type_name", "enumeration_type_specifier",
762  |   "enumeration_type_definition", "$@4", "$@5",
763  |   "enumeration_definition_list", "enumeration_definition_list1",
764  |   "enumeration_constant_definition", "enumeration_constant",
765  |   "enumeration_type_reference", "enumeration_tag",
766  |   "structure_type_specifier", "structure_type_definition", "$@6", "$@7",
767  |   "structure_type_reference", "structure_tag", "union_type_specifier",
768  |   "union_type_definition", "$@8", "$@9", "union_type_reference",
769  |   "union_tag", "field_list", "field_list1", "field_list2",
770  |   "component_declaration", "$@10", "$@11", "$@12",
771  |   "component_declarator_list", "component_declarator", "simple_component",
772  |   "bit_field", "width", "component_name", "function_definition", "$@13",
773  |   "function_specifier", "function_specifier1", "function_declarator",
774  |   "function_declarator0", "function_direct_declarator", "$@14",
775  |   "function_declarator1", "function_declarator2", "identifier_list",
776  |   "parameter_type_list", "parameter_list", "parameter_declaration",
777  |   "statement", "compound_statement", "$@15", "$@16",
778  |   "compound_statement_body", "block_item_list", "block_item",
779  |   "conditional_statement", "if_else_statement", "if_statement",
780  |   "iterative_statement", "do_statement", "for_statement", "$@17",
781  |   "for_expressions", "for_expression_or_declaration", "while_statement",
782  |   "labeled_statement", "case_label", "default_label", "named_label",
783  |   "switch_statement", "break_statement", "continue_statement",
784  |   "expression_statement", "goto_statement", "null_statement",
785  |   "return_statement", "expression", "comma_expression",
786  |   "assignment_expression", "assignment_op", "conditional_expression",
787  |   "logical_or_expression", "logical_and_expression",
788  |   "bitwise_or_expression", "bitwise_xor_expression",
789  |   "bitwise_and_expression", "equality_expression", "equality_op",
790  |   "relational_expression", "relational_op", "shift_expression", "shift_op",
791  |   "additive_expression", "add_op", "multiplicative_expression", "mult_op",
792  |   "unary_expression", "address_expression", "bitwise_negation_expression",
793  |   "cast_expression", "indirection_expression",
794  |   "logical_negation_expression", "predecrement_expression",
795  |   "preincrement_expression", "sizeof_expression", "unary_minus_expression",
796  |   "unary_plus_expression", "postfix_expression",
797  |   "component_selection_expression", "direct_component_selection",
798  |   "indirect_component_selection", "function_call", "function_call_direct",
799  |   "postdecrement_expression", "postincrement_expression",
800  |   "subscript_expression", "primary_expression", "string_literal",
801  |   "parenthesized_expression", "$@18", "$@19", "constant_expression",
802  |   "expression_list", "asm_statement", "asm_type", "asm_inout_list",
803  |   "asm_inout", "asm_clobber_list", "asm_label", "named_label_address", YY_NULLPTR
804  | };
805  | #endif
806  | 
807  | # ifdef YYPRINT
808  | /* YYTOKNUM[NUM] -- (External) token number corresponding to the
809  |    (internal) symbol number NUM (which must be that of a token).  */
810  | static const yytype_uint16 yytoknum[] =
811  | {
812  |        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
813  |      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
814  |      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
815  |      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
816  |      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
817  |      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
818  |      315,   316,   317,   318,    59,    44,    61,   123,   125,    58,
819  |       46,    91,    93,    40,    41,    42,    63,   124,    94,    38,
820  |       60,    62,    43,    45,    47,    37,   126,    33
821  | };
822  | # endif
823  | 
824  | #define YYPACT_NINF -406
825  | 
826  | #define yypact_value_is_default(Yystate) \
827  |   (!!((Yystate) == (-406)))
828  | 
829  | #define YYTABLE_NINF -246
830  | 
831  | #define yytable_value_is_error(Yytable_value) \
832  |   0
833  | 
834  |   /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
835  |      STATE-NUM.  */
836  | static const yytype_int16 yypact[] =
837  | {
838  |     1192,  -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,    -1,
839  |     -406,  -406,  -406,  -406,  -406,    21,  -406,  -406,  -406,    36,
840  |     -406,    53,    57,    61,    62,  -406,    43,   120,   151,  1192,
841  |     -406,  -406,    19,  -406,    14,   104,  -406,  -406,  1450,  1450,
842  |     1450,  -406,  -406,   386,   126,  -406,  -406,  -406,  -406,  -406,
843  |     -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,
844  |     1450,  -406,   332,   106,  -406,  -406,   117,  -406,  -406,  -406,
845  |     -406,  -406,  -406,   129,  -406,  -406,  -406,   165,  -406,  -406,
846  |     -406,   188,  -406,    43,   130,    39,    -3,   144,  -406,  -406,
847  |      120,  -406,  -406,  -406,  -406,   223,  -406,  -406,    78,    14,
848  |     1450,    43,   332,   152,  -406,  -406,  -406,  -406,  -406,  -406,
849  |      200,  1450,  -406,    38,  -406,   235,   417,  -406,   417,  -406,
850  |      248,  -406,  -406,  -406,    -3,  -406,  -406,  -406,  -406,  -406,
851  |      187,   301,  -406,   209,  1450,   205,  -406,  1042,  -406,  -406,
852  |     -406,  1382,  -406,    30,  -406,  1257,   126,   218,   220,   237,
853  |      417,  -406,  -406,   417,   251,   417,  -406,   253,   264,  -406,
854  |      273,   248,    43,   235,  -406,  -406,   287,  1107,  1107,  1132,
855  |      210,   636,  1107,  1107,  1107,  1107,  1107,  1107,  -406,   281,
856  |     -406,  -406,     1,   325,   279,   284,   278,   276,   140,   275,
857  |      244,   103,   300,  -406,  -406,  -406,  -406,  -406,  -406,  -406,
858  |     -406,  -406,  -406,   174,  -406,  -406,  -406,  -406,  -406,  -406,
859  |     -406,  -406,  -406,   353,  -406,  -406,  -406,  -406,  -406,   306,
860  |     -406,  -406,   466,  -406,   137,   299,   313,  -406,   314,  -406,
861  |     -406,    68,   317,  -406,   126,    11,  -406,  -406,  -406,  -406,
862  |      318,  -406,   326,  -406,   248,  1042,   338,  -406,    41,  -406,
863  |     -406,  -406,  -406,  -406,   636,  -406,   316,  -406,   328,  1042,
864  |     -406,    32,  -406,  -406,   192,   324,   193,   308,   333,   200,
865  |     -406,  -406,  -406,  -406,  -406,  -406,    85,  1107,   755,  1107,
866  |     1107,  1107,  1107,  -406,  -406,  1107,  -406,  -406,  -406,  -406,
867  |     1107,  -406,  -406,  1107,  -406,  -406,  1107,  -406,  -406,  -406,
868  |     1107,  -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,
869  |     -406,  -406,   777,   328,  -406,  -406,   328,  1042,   802,  1042,
870  |      336,   341,   342,  1042,  -406,   339,   343,   344,   684,  -406,
871  |      415,   355,   359,   877,  -406,  -406,  -406,  -406,   466,  -406,
872  |     -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,   362,   363,
873  |      364,  -406,  -406,  -406,  -406,  -406,  -406,  -406,   371,  -406,
874  |      899,  1240,  -406,   169,  -406,    52,  -406,   433,  1403,   330,
875  |       28,   161,  -406,  -406,    11,    11,  1042,   368,   272,  -406,
876  |     -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,   365,  -406,
877  |     -406,   369,   435,   210,  -406,   301,  -406,   301,  1287,  -406,
878  |      199,  1085,  -406,  -406,  -406,  -406,    89,   325,  -406,  1107,
879  |      374,   279,   284,   278,   276,   140,   275,   244,   103,  -406,
880  |      210,  -406,  -406,  -406,   372,  -406,   109,  -406,  -406,   438,
881  |     1042,  1042,  1042,    -1,   384,   375,   383,  -406,  -406,  -406,
882  |      385,   382,  -406,  -406,  -406,  -406,  -406,  -406,   379,  -406,
883  |      394,   399,   924,  1334,   169,  -406,  -406,  -406,   402,   403,
884  |     1042,    68,    68,   412,   280,   286,  -406,  -406,  1042,  -406,
885  |       11,  1085,  -406,  1042,  -406,  -406,  -406,   210,  -406,   404,
886  |     1042,  -406,  -406,  1107,   157,  -406,  -406,  1042,   405,   406,
887  |      408,   410,   551,  -406,  -406,  -406,  -406,  -406,  -406,  -406,
888  |      413,  -406,   414,   235,   235,   418,  -406,   185,  -406,  -406,
889  |     -406,  -406,  -406,  -406,   184,  -406,  -406,  -406,  -406,  -406,
890  |      684,   684,   684,  1042,   995,    43,   446,   420,  -406,  -406,
891  |     -406,    34,    46,  -406,   235,   422,  -406,   423,  -406,  -406,
892  |      457,  1042,   427,   467,   684,  1020,  1042,  1042,   353,   115,
893  |     -406,   684,   470,  -406,  1042,  -406,  1042,   471,   462,   463,
894  |      235,   474,  -406,  -406,  -406,  -406,  1042,  -406,  -406,   353,
895  |     -406,  -406
896  | };
897  | 
898  |   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
899  |      Performed when YYTABLE does not specify something else to do.  Zero
900  |      means the default is an error.  */
901  | static const yytype_uint16 yydefact[] =
902  | {
903  |        2,    67,   106,    77,    74,    76,    73,    75,    81,    82,
904  |      107,    78,   101,   102,   103,   104,    99,   100,    92,    93,
905  |      105,     0,     0,     0,   366,   251,     0,    59,     0,     3,
906  |        4,     6,     0,    14,     0,   182,    63,    65,    15,    19,
907  |       17,    83,    85,    86,    96,    87,    89,    91,    84,   110,
908  |      111,    88,   126,   127,    90,   135,   136,     7,   168,   170,
909  |      171,   175,   176,     0,     9,     8,     0,   368,    95,    94,
910  |      133,   134,   128,   132,   142,   143,   137,   141,   124,   125,
911  |      112,   123,   367,     0,     0,     0,    57,    66,    82,    61,
912  |       60,    79,     1,     5,    13,     0,    21,    24,    25,     0,
913  |      172,     0,   178,    69,    16,    20,    18,   104,    98,    97,
914  |        0,   173,    10,     0,   180,     0,   144,   130,   144,   139,
915  |        0,   114,    66,    64,    58,   177,    62,    80,    12,    22,
916  |        0,     0,    27,    26,   174,    66,    68,     0,   207,   169,
917  |       11,   183,   353,     0,   148,     0,   152,   126,   135,     0,
918  |      145,   146,   151,   144,     0,   144,   122,     0,   116,   118,
919  |      120,     0,     0,     0,    72,   350,     0,     0,     0,     0,
920  |       32,   356,     0,     0,     0,     0,     0,     0,    29,   349,
921  |       30,   257,   272,   275,   277,   279,   281,   283,   285,   289,
922  |      295,   299,   303,   308,   309,   310,   311,   312,   313,   314,
923  |      315,   316,   317,   318,   331,   338,   339,   332,   333,   334,
924  |      335,   336,   337,   351,   352,   258,    28,   179,   359,   254,
925  |      255,    70,   210,   186,   193,     0,   185,   184,   188,   190,
926  |      354,   369,     0,   154,   156,     0,   149,   150,   129,   147,
927  |        0,   138,     0,   113,   117,     0,     0,    23,     0,   244,
928  |      245,   379,   325,   326,   356,   328,    72,   167,     0,     0,
929  |       36,     0,    33,    41,     0,     0,   108,     0,     0,     0,
930  |      323,   319,   330,   329,   320,   324,     0,     0,     0,     0,
931  |        0,     0,     0,   287,   288,     0,   292,   294,   291,   293,
932  |        0,   297,   298,     0,   301,   302,     0,   305,   306,   307,
933  |        0,   262,   263,   264,   265,   266,   267,   268,   269,   270,
934  |      271,   261,     0,     0,   346,   347,     0,     0,     0,     0,
935  |        0,    72,   106,     0,   243,     0,     0,     0,     0,   224,
936  |        0,     0,     0,     0,   215,   214,   196,   208,   211,   212,
937  |      197,   217,   216,   198,   220,   221,   222,   199,     0,     0,
938  |        0,   200,   201,   202,   203,   204,   205,   206,     0,   195,
939  |        0,     0,   194,    47,   192,    45,   181,     0,     0,     0,
940  |        0,     0,   370,   362,     0,     0,     0,   162,     0,   158,
941  |      160,   161,   131,   140,   119,   121,   115,   378,     0,   166,
942  |       39,     0,    43,    35,    31,     0,    42,     0,     0,   109,
943  |       45,     0,   355,   357,   344,   360,     0,   276,   303,     0,
944  |        0,   278,   280,   282,   284,   286,   290,   296,   300,   304,
945  |       32,   259,   341,   340,     0,   342,     0,   256,    71,   241,
946  |        0,     0,     0,     0,     0,     0,     0,   248,   247,   252,
947  |        0,     0,   213,   238,   240,   239,   249,    49,     0,    53,
948  |        0,     0,     0,     0,    46,   187,   189,   191,     0,     0,
949  |        0,     0,   369,     0,     0,     0,   163,   165,     0,   153,
950  |        0,   327,    40,     0,    34,    38,    37,    32,   321,     0,
951  |        0,   345,   274,     0,     0,   348,   343,     0,     0,     0,
952  |        0,     0,     0,   250,   253,   209,    51,    48,    55,    50,
953  |        0,    54,     0,     0,     0,     0,   371,     0,   363,   155,
954  |      157,   164,   159,    44,     0,   358,   361,   273,   260,   242,
955  |        0,     0,     0,     0,     0,   236,     0,     0,   234,    52,
956  |       56,     0,     0,   374,   375,     0,   322,   219,   246,   237,
957  |        0,   226,     0,   235,     0,     0,     0,     0,   376,     0,
958  |      364,     0,     0,   229,   228,   225,   227,     0,     0,     0,
959  |        0,     0,   218,   223,   230,   231,   232,   372,   373,   377,
960  |      365,   233
961  | };
962  | 
963  |   /* YYPGOTO[NTERM-NUM].  */
964  | static const yytype_int16 yypgoto[] =
965  | {
966  |     -406,  -406,  -406,   511,   442,   -52,     2,     5,    18,  -406,
967  |      388,  -406,   411,  -124,  -405,   153,   283,  -406,  -406,  -170,
968  |     -347,   -32,     3,     4,  -406,  -406,  -406,  -406,  -406,  -406,
969  |      -11,    31,    93,  -406,  -406,  -406,   508,  -406,  -406,  -406,
970  |      304,  -406,  -406,  -406,  -406,   398,  -406,   319,  -406,  -406,
971  |     -406,  -406,   222,  -406,  -406,  -406,  -406,  -406,   249,  -406,
972  |     -406,  -406,  -406,    64,  -406,   416,  -406,  -406,  -406,  -406,
973  |      -22,    90,  -406,  -406,    94,  -163,  -406,  -406,  -406,  -406,
974  |      529,  -406,    37,  -406,  -406,  -406,  -406,  -135,  -406,   196,
975  |     -315,  -100,  -406,  -406,  -406,  -406,   227,  -406,  -406,  -406,
976  |     -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,
977  |      401,  -406,  -406,  -406,  -406,  -406,    50,  -406,  -132,  -406,
978  |     -119,  -406,  -398,  -406,   291,   290,   293,   289,   294,  -406,
979  |      292,  -406,   288,  -406,   309,  -406,   307,  -406,  -148,  -406,
980  |     -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,
981  |     -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,  -406,  -114,
982  |     -406,  -406,  -406,  -250,   261,    76,  -406,   142,   110,  -406,
983  |     -406,  -406
984  | };
985  | 
986  |   /* YYDEFGOTO[NTERM-NUM].  */
987  | static const yytype_int16 yydefgoto[] =
988  | {
989  |       -1,    28,    29,    30,   111,    31,   113,    33,    95,   162,
990  |       96,    97,   132,   260,   261,   262,   263,   264,   391,   450,
991  |      363,    84,    85,    86,    36,    37,   137,   320,   179,    38,
992  |      145,    39,    40,    41,    42,    43,    44,    45,    46,    47,
993  |      267,    48,    49,   120,   161,   157,   158,   159,   160,    50,
994  |       81,    51,    52,   116,   153,    53,    73,    54,    55,   118,
995  |      155,    56,    77,   149,   150,   151,   152,   235,   374,   375,
996  |      378,   379,   380,   381,   466,   265,    57,   110,    58,    59,
997  |       60,    61,   122,   141,    63,   225,   226,   451,   228,   229,
998  |      335,   336,   222,   441,   337,   338,   339,   340,   341,   342,
999  |      343,   344,   345,   435,   526,   527,   346,   347,   348,   349,
1000 |      350,   351,   352,   353,   354,   355,   356,   357,   358,   219,
1001 |      220,   312,   181,   182,   183,   184,   185,   186,   187,   285,
1002 |      188,   290,   189,   293,   190,   296,   191,   300,   192,   193,
1003 |      194,   195,   196,   197,   198,   199,   200,   201,   202,   203,
1004 |      204,   205,   206,   207,   208,   209,   210,   211,   212,   213,
1005 |      214,   269,   479,   221,   406,   359,    66,   371,   372,   549,
1006 |      133,   215
1007 | };
1008 | 
1009 |   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
1010 |      positive, shift that token.  If negative, reduce the rule whose
1011 |      number is the opposite.  If YYTABLE_NINF, syntax error.  */
1012 | static const yytype_int16 yytable[] =
1013 | {
1014 |       98,   143,    32,    34,    35,   218,   227,   178,   112,   392,
1015 |      139,   482,   180,   434,     1,   484,    90,     1,   454,   252,
1016 |      253,   255,     1,   277,   270,   271,   272,   273,   274,   275,
1017 |       89,    32,    34,    35,   230,    99,   230,    62,    35,   268,
1018 |      230,     1,     1,   104,   105,   106,     1,   230,   112,   248,
1019 |       64,   180,   230,   454,   362,     1,    70,    71,    91,   140,
1020 |       74,    75,    67,    87,    78,    79,    62,    68,   103,    62,
1021 |     -182,   102,   514,   429,   142,   109,    65,   278,    69,    64,
1022 |      376,    98,   140,    94,    83,   517,    27,   101,   164,   124,
1023 |      165,   142,    26,   126,    27,   390,   399,   393,    82,   231,
1024 |      394,   460,    94,   124,   232,    65,   166,   546,   167,   168,
1025 |      448,    83,    83,    27,   169,   387,    83,   370,    27,   547,
1026 |       72,   127,   268,   360,    76,   361,   385,   218,    80,   408,
1027 |       98,   408,   408,   408,   408,   234,   102,   408,   135,   369,
1028 |        1,   130,   408,   224,   131,   408,   410,    91,   408,    91,
1029 |      422,    92,   419,   423,   480,     8,    88,   405,   171,   404,
1030 |      172,     8,    88,   481,   173,   286,   287,   174,   175,   403,
1031 |      334,   176,   177,   266,   480,   103,   127,    91,   297,   114,
1032 |      560,    91,   154,   486,    91,   424,    91,   298,   299,   561,
1033 |      115,   218,   364,   421,   313,    27,   117,   314,   315,   405,
1034 |      427,   440,   500,   377,   123,   537,   538,   539,   360,   146,
1035 |      361,   146,    27,   256,   257,   165,   142,   240,   125,   242,
1036 |      288,   289,   393,   513,   136,   518,   461,   365,   218,   555,
1037 |      462,   166,   119,   167,   168,   463,   562,   519,   233,   169,
1038 |      452,   142,   453,   146,   316,   317,   146,   318,   146,   393,
1039 |      461,   156,   536,   478,   534,   121,   266,   467,   395,   535,
1040 |      163,   408,   258,   259,   360,   127,   398,   138,    27,   400,
1041 |      360,   475,   398,   476,   180,   131,   180,   170,   180,   217,
1042 |      258,   259,   236,   171,   237,   172,   334,   128,   129,   173,
1043 |      249,   250,   174,   175,   283,   284,   176,   177,   488,   489,
1044 |      490,   180,   291,   292,   164,   238,   165,   142,   301,   302,
1045 |      303,   304,   305,   306,   307,   308,   309,   310,   502,   241,
1046 |      218,   243,   166,   478,   167,   168,   294,   295,   505,   244,
1047 |      169,   389,   257,   458,   459,   408,   469,   470,   147,   245,
1048 |      147,   218,   377,   377,   509,   470,   279,   370,   370,   467,
1049 |      510,   470,   464,   465,   276,   218,   280,   282,   180,   230,
1050 |      528,   516,   281,   224,   365,   148,   311,   148,   170,   124,
1051 |      224,   319,   147,   366,   171,   147,   172,   147,   367,   368,
1052 |      173,   373,   401,   174,   175,  -166,   382,   176,   177,   531,
1053 |      532,   540,   542,   397,   383,   -66,   -66,   -66,   -66,   148,
1054 |      224,   400,   148,   -66,   148,   -66,   386,   402,   428,   553,
1055 |     -244,  -245,   430,   557,   558,   559,   431,   432,   436,   437,
1056 |      548,     2,   564,   438,   565,    12,    13,    14,   107,    16,
1057 |       17,   443,   444,   445,   571,   446,   455,   468,   377,   471,
1058 |      491,   472,   473,   483,   485,   487,   569,   493,   492,   494,
1059 |      495,   496,     8,    88,    10,   224,    12,    13,    14,    15,
1060 |       16,    17,    18,    19,    20,    21,    22,    23,   497,   321,
1061 |      322,   165,   142,   498,   503,   504,   508,   551,   515,   520,
1062 |      521,   144,   522,   523,   545,   529,   550,   166,   530,   167,
1063 |      168,   554,   533,    98,   525,   169,     3,     4,     5,     6,
1064 |        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
1065 |       17,    18,    19,    20,    21,    22,    23,   323,   324,   325,
1066 |      544,   326,   327,   328,   329,   330,   331,   332,   333,    24,
1067 |       25,   552,   129,   138,   563,   566,   567,   568,   570,   171,
1068 |       93,   172,   134,   543,   216,   173,   474,   396,   174,   175,
1069 |      247,   108,   176,   177,   164,     2,   165,   142,   388,   246,
1070 |      512,   100,   511,   384,   457,   442,   239,   251,   407,   411,
1071 |      413,   506,   166,   412,   167,   168,   414,   415,   416,   426,
1072 |      169,     3,     4,     5,     6,     7,     8,    88,    10,    11,
1073 |       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
1074 |       22,    23,   417,   418,   507,     0,     0,     0,     0,     0,
1075 |        0,     0,     0,     0,     0,   524,     0,     0,     0,     0,
1076 |        0,     0,     0,     0,   171,     0,   172,     0,     0,     0,
1077 |      173,     0,     0,   174,   175,     0,     0,   176,   177,   164,
1078 |        2,   165,   142,     0,     0,     0,     0,     0,     0,     0,
1079 |        0,     0,     0,     0,     0,     0,     0,   166,     0,   167,
1080 |      168,     0,     0,     0,     0,   169,     3,     4,     5,     6,
1081 |        7,     8,    88,    10,    11,    12,    13,    14,    15,    16,
1082 |       17,    18,    19,    20,    21,    22,    23,   321,   250,   165,
1083 |      142,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1084 |        0,     0,     0,     0,     0,   166,     0,   167,   168,   171,
1085 |        0,   172,     0,   169,     0,   173,     0,     0,   174,   175,
1086 |      433,     0,   176,   177,     0,     0,     0,     0,     0,     0,
1087 |        0,     0,     0,     0,     0,   323,   324,   325,     0,   326,
1088 |      327,   328,   329,   330,   331,   332,   333,    24,    25,     0,
1089 |        0,   138,     0,     0,     0,     0,     0,   171,   164,   172,
1090 |      165,   142,     0,   173,     0,     0,   174,   175,     0,     0,
1091 |      176,   177,     0,     0,     0,     0,   166,     0,   167,   168,
1092 |      164,     0,   165,   142,   169,     0,     0,     0,     0,     0,
1093 |        0,     0,     0,     0,     0,     0,     0,     0,   166,     0,
1094 |      167,   168,     0,     0,     0,   164,   169,   165,   142,     0,
1095 |        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1096 |        0,     0,     0,   166,   409,   167,   168,     0,   171,     0,
1097 |      172,   169,     0,     0,   173,     0,     0,   174,   175,     0,
1098 |        0,   176,   177,     0,   420,     0,     0,     0,     0,     0,
1099 |      171,     0,   172,     0,     0,     0,   173,     0,     0,   174,
1100 |      175,     0,     0,   176,   177,     0,     0,     0,     0,     0,
1101 |        0,     0,     0,     0,     0,   171,   425,   172,     0,     0,
1102 |      164,   173,   165,   142,   174,   175,     0,     0,   176,   177,
1103 |        0,     0,     0,     0,     0,     0,     0,     0,   166,     0,
1104 |      167,   168,   164,     0,   165,   142,   169,     0,     0,     0,
1105 |        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1106 |      166,     0,   167,   168,     0,     0,     0,   164,   169,   165,
1107 |      142,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1108 |        0,   439,     0,     0,     0,   166,     0,   167,   168,     0,
1109 |      171,     0,   172,   169,     0,     0,   173,     0,     0,   174,
1110 |      175,     0,     0,   176,   177,     0,     0,     0,     0,     0,
1111 |        0,   447,   171,     0,   172,     0,     0,     0,   173,     0,
1112 |        0,   174,   175,     0,     0,   176,   177,     0,     0,     0,
1113 |        0,     0,     0,     0,     0,     0,   499,   171,   164,   172,
1114 |      165,   142,     0,   173,     0,     0,   174,   175,     0,     0,
1115 |      176,   177,     0,     0,     0,     0,   166,     0,   167,   168,
1116 |        0,     0,     0,   164,   169,   165,   142,     0,     0,     0,
1117 |        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1118 |        0,   166,     0,   167,   168,   164,     0,   165,   142,   169,
1119 |        0,     0,     0,     0,     0,     0,     0,     0,     0,   541,
1120 |        0,     0,     0,   166,     0,   167,   168,     0,   171,     0,
1121 |      172,   169,     0,     0,   173,     0,     0,   174,   175,     0,
1122 |        0,   176,   177,     0,   556,     0,     0,     0,   164,     0,
1123 |      165,   142,     0,   171,     0,   172,     0,     0,     0,   173,
1124 |        0,     0,   174,   175,     0,     0,   176,   177,   167,   168,
1125 |      164,     0,   165,   142,   169,   171,     0,   172,     0,     0,
1126 |        0,   173,     0,     0,   174,   175,     0,     0,   176,   177,
1127 |      167,   168,     0,     0,     0,   164,   169,   165,   142,     0,
1128 |        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1129 |        0,     0,   477,     0,     0,   167,   168,     0,   171,     0,
1130 |      172,   169,     0,     0,   173,     0,     0,   174,   175,     0,
1131 |        0,   176,   177,     0,     0,     0,     0,     0,     0,     0,
1132 |      171,     0,   172,     0,     0,     0,   173,     0,     0,   174,
1133 |      175,     0,     0,   176,   177,     1,     2,     0,     0,     0,
1134 |        0,     0,     0,     0,     0,   254,     0,   172,     0,     0,
1135 |        0,   173,     0,     0,   174,   175,     0,     0,   176,   177,
1136 |        0,     0,     3,     4,     5,     6,     7,     8,     9,    10,
1137 |       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
1138 |       21,    22,    23,     1,     2,     0,     0,     0,     0,     0,
1139 |        0,     0,     0,     0,     0,    24,    25,     0,     0,     0,
1140 |        0,     2,     0,     0,     0,    26,     0,    27,     0,     0,
1141 |        3,     4,     5,     6,     7,     8,    88,    10,    11,    12,
1142 |       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
1143 |       23,     2,     8,    88,    10,     0,    12,    13,    14,    15,
1144 |       16,    17,    18,    19,    20,    21,    22,    23,     0,     0,
1145 |        0,   360,     0,   361,   449,    27,     0,     3,     4,     5,
1146 |        6,     7,     8,    88,    10,    11,    12,    13,    14,    15,
1147 |       16,    17,    18,    19,    20,    21,    22,    23,     2,     0,
1148 |        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1149 |        0,     0,     0,     0,     0,     0,     0,     0,   360,     0,
1150 |      398,   449,    27,     0,     3,     4,     5,     6,     7,     8,
1151 |       88,    10,    11,    12,    13,    14,    15,    16,    17,    18,
1152 |       19,    20,    21,    22,    23,   223,     2,     0,     0,     0,
1153 |        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1154 |        0,     0,     0,     0,     0,     0,     0,     2,   501,     0,
1155 |      456,     0,     3,     4,     5,     6,     7,     8,    88,    10,
1156 |       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
1157 |       21,    22,    23,     3,     4,     5,     6,     7,     8,    88,
1158 |       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
1159 |       20,    21,    22,    23,     2,     0,     0,     0,     0,     0,
1160 |        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1161 |        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1162 |        3,     4,     5,     6,     7,     8,    88,    10,    11,    12,
1163 |       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
1164 |       23
1165 | };
1166 | 
1167 | static const yytype_int16 yycheck[] =
1168 | {
1169 |       32,   115,     0,     0,     0,   137,   141,   131,    60,   259,
1170 |      110,   409,   131,   328,     3,   420,    27,     3,   365,   167,
1171 |      168,   169,     3,    22,   172,   173,   174,   175,   176,   177,
1172 |       27,    29,    29,    29,     6,    32,     6,     0,    34,   171,
1173 |        6,     3,     3,    38,    39,    40,     3,     6,   100,   163,
1174 |        0,   170,     6,   400,   224,     3,     3,     4,    27,   111,
1175 |        3,     4,    63,    26,     3,     4,    29,    46,    71,    32,
1176 |       73,    34,   477,   323,     6,    44,     0,    76,    42,    29,
1177 |       69,   113,   134,    64,    73,   483,    75,    73,     3,    85,
1178 |        5,     6,    73,    90,    75,   258,   266,    65,    36,    69,
1179 |       68,    73,    64,    99,    74,    29,    21,    73,    23,    24,
1180 |      360,    73,    73,    75,    29,    74,    73,   231,    75,    73,
1181 |       67,    90,   254,    71,    67,    73,   245,   259,    67,   277,
1182 |      162,   279,   280,   281,   282,   146,    99,   285,   101,    71,
1183 |        3,    63,   290,   141,    66,   293,   278,   116,   296,   118,
1184 |      313,     0,   300,   316,    65,    35,    36,   276,    73,    74,
1185 |       75,    35,    36,    74,    79,    25,    26,    82,    83,   269,
1186 |      222,    86,    87,   171,    65,    71,   145,   146,    75,    73,
1187 |       65,   150,   118,    74,   153,   317,   155,    84,    85,    74,
1188 |       73,   323,   224,   312,    20,    75,    67,    23,    24,   318,
1189 |      319,   333,   452,   235,    74,   520,   521,   522,    71,   116,
1190 |       73,   118,    75,     3,     4,     5,     6,   153,    74,   155,
1191 |       80,    81,    65,   473,    72,    68,    65,   224,   360,   544,
1192 |       69,    21,    67,    23,    24,    74,   551,   487,   145,    29,
1193 |       71,     6,    73,   150,    70,    71,   153,    73,   155,    65,
1194 |       65,     3,    68,   401,    69,    67,   254,   376,    66,    74,
1195 |       73,   409,    70,    71,    71,   234,    73,    67,    75,   266,
1196 |       71,   395,    73,   397,   393,    66,   395,    67,   397,    74,
1197 |       70,    71,    64,    73,    64,    75,   338,    64,    65,    79,
1198 |        3,     4,    82,    83,    18,    19,    86,    87,   430,   431,
1199 |      432,   420,    27,    28,     3,    68,     5,     6,     8,     9,
1200 |       10,    11,    12,    13,    14,    15,    16,    17,   453,    68,
1201 |      452,    68,    21,   471,    23,    24,    82,    83,   460,    65,
1202 |       29,     3,     4,     3,     4,   483,    64,    65,   116,    66,
1203 |      118,   473,   374,   375,    64,    65,    21,   461,   462,   468,
1204 |       64,    65,   374,   375,    73,   487,    77,    79,   477,     6,
1205 |      492,   480,    78,   361,   361,   116,    66,   118,    67,   365,
1206 |      368,    65,   150,    74,    73,   153,    75,   155,    65,    65,
1207 |       79,    64,    74,    82,    83,    69,    68,    86,    87,   503,
1208 |      504,   523,   524,    69,    68,    63,    64,    65,    66,   150,
1209 |      398,   398,   153,    71,   155,    73,    68,    74,    72,   541,
1210 |       69,    69,    73,   545,   546,   547,    73,    73,     3,    64,
1211 |      534,     4,   554,    64,   556,    39,    40,    41,    42,    43,
1212 |       44,    69,    69,    69,   566,    64,     3,    69,   470,    74,
1213 |       56,    72,     7,    69,    72,     7,   560,    64,    73,    64,
1214 |       68,    72,    35,    36,    37,   453,    39,    40,    41,    42,
1215 |       43,    44,    45,    46,    47,    48,    49,    50,    74,     3,
1216 |        4,     5,     6,    74,    72,    72,    64,    54,    74,    74,
1217 |       74,    64,    74,    73,    64,    72,    64,    21,    74,    23,
1218 |       24,    64,    74,   525,   492,    29,    30,    31,    32,    33,
1219 |       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
1220 |       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
1221 |       74,    55,    56,    57,    58,    59,    60,    61,    62,    63,
1222 |       64,    74,    65,    67,    64,    64,    74,    74,    64,    73,
1223 |       29,    75,   100,   525,   133,    79,   393,   264,    82,    83,
1224 |      162,    43,    86,    87,     3,     4,     5,     6,   254,   161,
1225 |      470,    32,   468,   244,   368,   338,   150,   166,   277,   279,
1226 |      281,   461,    21,   280,    23,    24,   282,   285,   290,   318,
1227 |       29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
1228 |       39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
1229 |       49,    50,   293,   296,   462,    -1,    -1,    -1,    -1,    -1,
1230 |       -1,    -1,    -1,    -1,    -1,    64,    -1,    -1,    -1,    -1,
1231 |       -1,    -1,    -1,    -1,    73,    -1,    75,    -1,    -1,    -1,
1232 |       79,    -1,    -1,    82,    83,    -1,    -1,    86,    87,     3,
1233 |        4,     5,     6,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1234 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    21,    -1,    23,
1235 |       24,    -1,    -1,    -1,    -1,    29,    30,    31,    32,    33,
1236 |       34,    35,    36,    37,    38,    39,    40,    41,    42,    43,
1237 |       44,    45,    46,    47,    48,    49,    50,     3,     4,     5,
1238 |        6,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1239 |       -1,    -1,    -1,    -1,    -1,    21,    -1,    23,    24,    73,
1240 |       -1,    75,    -1,    29,    -1,    79,    -1,    -1,    82,    83,
1241 |       36,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,
1242 |       -1,    -1,    -1,    -1,    -1,    51,    52,    53,    -1,    55,
1243 |       56,    57,    58,    59,    60,    61,    62,    63,    64,    -1,
1244 |       -1,    67,    -1,    -1,    -1,    -1,    -1,    73,     3,    75,
1245 |        5,     6,    -1,    79,    -1,    -1,    82,    83,    -1,    -1,
1246 |       86,    87,    -1,    -1,    -1,    -1,    21,    -1,    23,    24,
1247 |        3,    -1,     5,     6,    29,    -1,    -1,    -1,    -1,    -1,
1248 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    21,    -1,
1249 |       23,    24,    -1,    -1,    -1,     3,    29,     5,     6,    -1,
1250 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1251 |       -1,    -1,    -1,    21,    69,    23,    24,    -1,    73,    -1,
1252 |       75,    29,    -1,    -1,    79,    -1,    -1,    82,    83,    -1,
1253 |       -1,    86,    87,    -1,    67,    -1,    -1,    -1,    -1,    -1,
1254 |       73,    -1,    75,    -1,    -1,    -1,    79,    -1,    -1,    82,
1255 |       83,    -1,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,
1256 |       -1,    -1,    -1,    -1,    -1,    73,    74,    75,    -1,    -1,
1257 |        3,    79,     5,     6,    82,    83,    -1,    -1,    86,    87,
1258 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    21,    -1,
1259 |       23,    24,     3,    -1,     5,     6,    29,    -1,    -1,    -1,
1260 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1261 |       21,    -1,    23,    24,    -1,    -1,    -1,     3,    29,     5,
1262 |        6,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1263 |       -1,    64,    -1,    -1,    -1,    21,    -1,    23,    24,    -1,
1264 |       73,    -1,    75,    29,    -1,    -1,    79,    -1,    -1,    82,
1265 |       83,    -1,    -1,    86,    87,    -1,    -1,    -1,    -1,    -1,
1266 |       -1,    72,    73,    -1,    75,    -1,    -1,    -1,    79,    -1,
1267 |       -1,    82,    83,    -1,    -1,    86,    87,    -1,    -1,    -1,
1268 |       -1,    -1,    -1,    -1,    -1,    -1,    72,    73,     3,    75,
1269 |        5,     6,    -1,    79,    -1,    -1,    82,    83,    -1,    -1,
1270 |       86,    87,    -1,    -1,    -1,    -1,    21,    -1,    23,    24,
1271 |       -1,    -1,    -1,     3,    29,     5,     6,    -1,    -1,    -1,
1272 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1273 |       -1,    21,    -1,    23,    24,     3,    -1,     5,     6,    29,
1274 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    64,
1275 |       -1,    -1,    -1,    21,    -1,    23,    24,    -1,    73,    -1,
1276 |       75,    29,    -1,    -1,    79,    -1,    -1,    82,    83,    -1,
1277 |       -1,    86,    87,    -1,    64,    -1,    -1,    -1,     3,    -1,
1278 |        5,     6,    -1,    73,    -1,    75,    -1,    -1,    -1,    79,
1279 |       -1,    -1,    82,    83,    -1,    -1,    86,    87,    23,    24,
1280 |        3,    -1,     5,     6,    29,    73,    -1,    75,    -1,    -1,
1281 |       -1,    79,    -1,    -1,    82,    83,    -1,    -1,    86,    87,
1282 |       23,    24,    -1,    -1,    -1,     3,    29,     5,     6,    -1,
1283 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1284 |       -1,    -1,    67,    -1,    -1,    23,    24,    -1,    73,    -1,
1285 |       75,    29,    -1,    -1,    79,    -1,    -1,    82,    83,    -1,
1286 |       -1,    86,    87,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1287 |       73,    -1,    75,    -1,    -1,    -1,    79,    -1,    -1,    82,
1288 |       83,    -1,    -1,    86,    87,     3,     4,    -1,    -1,    -1,
1289 |       -1,    -1,    -1,    -1,    -1,    73,    -1,    75,    -1,    -1,
1290 |       -1,    79,    -1,    -1,    82,    83,    -1,    -1,    86,    87,
1291 |       -1,    -1,    30,    31,    32,    33,    34,    35,    36,    37,
1292 |       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
1293 |       48,    49,    50,     3,     4,    -1,    -1,    -1,    -1,    -1,
1294 |       -1,    -1,    -1,    -1,    -1,    63,    64,    -1,    -1,    -1,
1295 |       -1,     4,    -1,    -1,    -1,    73,    -1,    75,    -1,    -1,
1296 |       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
1297 |       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
1298 |       50,     4,    35,    36,    37,    -1,    39,    40,    41,    42,
1299 |       43,    44,    45,    46,    47,    48,    49,    50,    -1,    -1,
1300 |       -1,    71,    -1,    73,    74,    75,    -1,    30,    31,    32,
1301 |       33,    34,    35,    36,    37,    38,    39,    40,    41,    42,
1302 |       43,    44,    45,    46,    47,    48,    49,    50,     4,    -1,
1303 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1304 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,    -1,
1305 |       73,    74,    75,    -1,    30,    31,    32,    33,    34,    35,
1306 |       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
1307 |       46,    47,    48,    49,    50,     3,     4,    -1,    -1,    -1,
1308 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1309 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,     4,    74,    -1,
1310 |        7,    -1,    30,    31,    32,    33,    34,    35,    36,    37,
1311 |       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
1312 |       48,    49,    50,    30,    31,    32,    33,    34,    35,    36,
1313 |       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
1314 |       47,    48,    49,    50,     4,    -1,    -1,    -1,    -1,    -1,
1315 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1316 |       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1317 |       30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
1318 |       40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
1319 |       50
1320 | };
1321 | 
1322 |   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1323 |      symbol of state STATE-NUM.  */
1324 | static const yytype_uint16 yystos[] =
1325 | {
1326 |        0,     3,     4,    30,    31,    32,    33,    34,    35,    36,
1327 |       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
1328 |       47,    48,    49,    50,    63,    64,    73,    75,    89,    90,
1329 |       91,    93,    94,    95,   110,   111,   112,   113,   117,   119,
1330 |      120,   121,   122,   123,   124,   125,   126,   127,   129,   130,
1331 |      137,   139,   140,   143,   145,   146,   149,   164,   166,   167,
1332 |      168,   169,   170,   172,   204,   253,   254,    63,    46,    42,
1333 |        3,     4,    67,   144,     3,     4,    67,   150,     3,     4,
1334 |       67,   138,    36,    73,   109,   110,   111,   170,    36,   110,
1335 |      118,   119,     0,    91,    64,    96,    98,    99,   109,   110,
1336 |      168,    73,   170,    71,    95,    95,    95,    42,   124,   119,
1337 |      165,    92,    93,    94,    73,    73,   141,    67,   147,    67,
1338 |      131,    67,   170,    74,   111,    74,   110,   119,    64,    65,
1339 |       63,    66,   100,   258,    92,   170,    72,   114,    67,   179,
1340 |       93,   171,     6,   247,    64,   118,   120,   140,   146,   151,
1341 |      152,   153,   154,   142,   151,   148,     3,   133,   134,   135,
1342 |      136,   132,    97,    73,     3,     5,    21,    23,    24,    29,
1343 |       67,    73,    75,    79,    82,    83,    86,    87,   101,   116,
1344 |      208,   210,   211,   212,   213,   214,   215,   216,   218,   220,
1345 |      222,   224,   226,   227,   228,   229,   230,   231,   232,   233,
1346 |      234,   235,   236,   237,   238,   239,   240,   241,   242,   243,
1347 |      244,   245,   246,   247,   248,   259,   100,    74,   206,   207,
1348 |      208,   251,   180,     3,    94,   173,   174,   175,   176,   177,
1349 |        6,    69,    74,   120,   118,   155,    64,    64,    68,   153,
1350 |      151,    68,   151,    68,    65,    66,   133,    98,   247,     3,
1351 |        4,   198,   226,   226,    73,   226,     3,     4,    70,    71,
1352 |      101,   102,   103,   104,   105,   163,    94,   128,   206,   249,
1353 |      226,   226,   226,   226,   226,   226,    73,    22,    76,    21,
1354 |       77,    78,    79,    18,    19,   217,    25,    26,    80,    81,
1355 |      219,    27,    28,   221,    82,    83,   223,    75,    84,    85,
1356 |      225,     8,     9,    10,    11,    12,    13,    14,    15,    16,
1357 |       17,    66,   209,    20,    23,    24,    70,    71,    73,    65,
1358 |      115,     3,     4,    51,    52,    53,    55,    56,    57,    58,
1359 |       59,    60,    61,    62,    93,   178,   179,   182,   183,   184,
1360 |      185,   186,   187,   188,   189,   190,   194,   195,   196,   197,
1361 |      198,   199,   200,   201,   202,   203,   204,   205,   206,   253,
1362 |       71,    73,   107,   108,   109,   110,    74,    65,    65,    71,
1363 |      247,   255,   256,    64,   156,   157,    69,   109,   158,   159,
1364 |      160,   161,    68,    68,   135,   208,    68,    74,   128,     3,
1365 |      163,   106,   251,    65,    68,    66,   104,    69,    73,   107,
1366 |      110,    74,    74,   179,    74,   208,   252,   212,   226,    69,
1367 |      206,   213,   214,   215,   216,   218,   220,   222,   224,   226,
1368 |       67,   208,   163,   163,   206,    74,   252,   208,    72,   251,
1369 |       73,    73,    73,    36,   178,   191,     3,    64,    64,    64,
1370 |      206,   181,   184,    69,    69,    69,    64,    72,   251,    74,
1371 |      107,   175,    71,    73,   108,     3,     7,   177,     3,     4,
1372 |       73,    65,    69,    74,   158,   158,   162,   208,    69,    64,
1373 |       65,    74,    72,     7,   103,   101,   101,    67,   226,   250,
1374 |       65,    74,   210,    69,   102,    72,    74,     7,   206,   206,
1375 |      206,    56,    73,    64,    64,    68,    72,    74,    74,    72,
1376 |      251,    74,   175,    72,    72,   206,   256,   255,    64,    64,
1377 |       64,   162,   159,   251,   102,    74,   208,   210,    68,   251,
1378 |       74,    74,    74,    73,    64,    94,   192,   193,   206,    72,
1379 |       74,   247,   247,    74,    69,    74,    68,   178,   178,   178,
1380 |      206,    64,   206,    96,    74,    64,    73,    73,   247,   257,
1381 |       64,    54,    74,   206,    64,   178,    64,   206,   206,   206,
1382 |       65,    74,   178,    64,   206,   206,    64,    74,    74,   247,
1383 |       64,   206
1384 | };
1385 | 
1386 |   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1387 | static const yytype_uint16 yyr1[] =
1388 | {
1389 |        0,    88,    89,    89,    90,    90,    91,    91,    91,    91,
1390 |       92,    92,    93,    93,    94,    95,    95,    95,    95,    95,
1391 |       95,    96,    97,    96,    98,    99,    99,    99,    99,   100,
1392 |      101,   101,   102,   102,   102,   102,   103,   103,   103,   104,
1393 |      104,   105,   105,   106,   106,   107,   107,   107,   108,   108,
1394 |      108,   108,   108,   108,   108,   108,   108,   109,   109,   110,
1395 |      110,   110,   110,   111,   111,   111,   111,   112,   113,   114,
1396 |      115,   113,   116,   117,   117,   117,   117,   117,   117,   118,
1397 |      118,   119,   119,   120,   121,   121,   121,   121,   121,   121,
1398 |      121,   121,   122,   122,   122,   122,   123,   123,   123,   124,
1399 |      124,   124,   124,   124,   124,   125,   126,   127,   128,   128,
1400 |      129,   129,   131,   130,   132,   130,   133,   133,   134,   134,
1401 |      135,   135,   136,   137,   138,   138,   139,   139,   141,   140,
1402 |      142,   140,   143,   144,   144,   145,   145,   147,   146,   148,
1403 |      146,   149,   150,   150,   151,   151,   152,   152,   153,   153,
1404 |      153,   153,   155,   154,   156,   154,   157,   154,   158,   158,
1405 |      159,   159,   160,   161,   161,   162,   163,   163,   165,   164,
1406 |      166,   167,   167,   167,   167,   168,   169,   169,   169,   169,
1407 |      171,   170,   172,   173,   173,   173,   174,   174,   175,   175,
1408 |      176,   176,   177,   177,   177,   178,   178,   178,   178,   178,
1409 |      178,   178,   178,   178,   178,   178,   178,   180,   181,   179,
1410 |      182,   182,   183,   183,   184,   184,   185,   185,   186,   187,
1411 |      188,   188,   188,   189,   191,   190,   192,   192,   192,   192,
1412 |      192,   192,   192,   192,   193,   193,   193,   194,   195,   195,
1413 |      195,   196,   196,   197,   198,   198,   199,   200,   201,   202,
1414 |      203,   204,   205,   205,   206,   207,   207,   208,   208,   208,
1415 |      208,   209,   209,   209,   209,   209,   209,   209,   209,   209,
1416 |      209,   209,   210,   210,   210,   211,   211,   212,   212,   213,
1417 |      213,   214,   214,   215,   215,   216,   216,   217,   217,   218,
1418 |      218,   219,   219,   219,   219,   220,   220,   221,   221,   222,
1419 |      222,   223,   223,   224,   224,   225,   225,   225,   226,   226,
1420 |      226,   226,   226,   226,   226,   226,   226,   226,   226,   227,
1421 |      228,   229,   229,   230,   231,   232,   233,   234,   234,   235,
1422 |      236,   237,   237,   237,   237,   237,   237,   237,   238,   238,
1423 |      239,   240,   241,   241,   242,   242,   243,   244,   245,   246,
1424 |      246,   246,   246,   247,   247,   248,   249,   250,   248,   251,
1425 |      252,   252,   253,   253,   253,   253,   254,   254,   254,   255,
1426 |      255,   255,   256,   256,   256,   257,   257,   257,   258,   259
1427 | };
1428 | 
1429 |   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
1430 | static const yytype_uint8 yyr2[] =
1431 | {
1432 |        0,     2,     0,     1,     1,     2,     1,     1,     1,     1,
1433 |        1,     2,     3,     2,     1,     1,     2,     1,     2,     1,
1434 |        2,     1,     0,     4,     1,     1,     2,     2,     3,     2,
1435 |        1,     3,     0,     1,     3,     2,     1,     3,     3,     2,
1436 |        3,     1,     2,     1,     3,     1,     2,     1,     3,     2,
1437 |        3,     3,     4,     2,     3,     3,     4,     1,     2,     1,
1438 |        2,     2,     3,     1,     3,     1,     1,     1,     3,     0,
1439 |        0,     6,     1,     1,     1,     1,     1,     1,     1,     1,
1440 |        2,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1441 |        1,     1,     1,     1,     2,     2,     1,     2,     2,     1,
1442 |        1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
1443 |        1,     1,     0,     5,     0,     6,     1,     2,     1,     3,
1444 |        1,     3,     1,     2,     1,     1,     1,     1,     0,     5,
1445 |        0,     6,     2,     1,     1,     1,     1,     0,     5,     0,
1446 |        6,     2,     1,     1,     0,     1,     1,     2,     1,     2,
1447 |        2,     1,     0,     4,     0,     5,     0,     5,     1,     3,
1448 |        1,     1,     1,     2,     3,     1,     1,     1,     0,     3,
1449 |        1,     1,     2,     2,     3,     1,     1,     3,     2,     4,
1450 |        0,     5,     1,     0,     1,     1,     1,     3,     1,     3,
1451 |        1,     3,     2,     1,     2,     1,     1,     1,     1,     1,
1452 |        1,     1,     1,     1,     1,     1,     1,     0,     0,     5,
1453 |        0,     1,     1,     2,     1,     1,     1,     1,     7,     5,
1454 |        1,     1,     1,     7,     0,     6,     2,     3,     3,     3,
1455 |        4,     4,     4,     5,     1,     2,     1,     5,     2,     2,
1456 |        2,     2,     4,     1,     1,     1,     5,     2,     2,     2,
1457 |        3,     1,     2,     3,     1,     1,     3,     1,     1,     3,
1458 |        5,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1459 |        1,     1,     1,     5,     4,     1,     3,     1,     3,     1,
1460 |        3,     1,     3,     1,     3,     1,     3,     1,     1,     1,
1461 |        3,     1,     1,     1,     1,     1,     3,     1,     1,     1,
1462 |        3,     1,     1,     1,     3,     1,     1,     1,     1,     1,
1463 |        1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
1464 |        2,     4,     6,     2,     2,     2,     2,     4,     2,     2,
1465 |        2,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1466 |        3,     3,     3,     4,     3,     4,     2,     2,     4,     1,
1467 |        1,     1,     1,     1,     2,     3,     0,     0,     5,     1,
1468 |        1,     3,     5,     7,     9,    11,     1,     2,     2,     0,
1469 |        1,     3,     7,     7,     4,     0,     1,     3,     4,     2
1470 | };
1471 | 
1472 | 
1473 | #define yyerrok         (yyerrstatus = 0)
1474 | #define yyclearin       (yychar = YYEMPTY)
1475 | #define YYEMPTY         (-2)
1476 | #define YYEOF           0
1477 | 
1478 | #define YYACCEPT        goto yyacceptlab
1479 | #define YYABORT         goto yyabortlab
1480 | #define YYERROR         goto yyerrorlab
1481 | 
1482 | 
1483 | #define YYRECOVERING()  (!!yyerrstatus)
1484 | 
1485 | #define YYBACKUP(Token, Value)                                  \
1486 | do                                                              \
1487 |   if (yychar == YYEMPTY)                                        \
1488 |     {                                                           \
1489 |       yychar = (Token);                                         \
1490 |       yylval = (Value);                                         \
1491 |       YYPOPSTACK (yylen);                                       \
1492 |       yystate = *yyssp;                                         \
1493 |       goto yybackup;                                            \
1494 |     }                                                           \
1495 |   else                                                          \
1496 |     {                                                           \
1497 |       yyerror (YY_("syntax error: cannot back up")); \
1498 |       YYERROR;                                                  \
1499 |     }                                                           \
1500 | while (0)
1501 | 
1502 | /* Error token number */
1503 | #define YYTERROR        1
1504 | #define YYERRCODE       256
1505 | 
1506 | 
1507 | 
1508 | /* Enable debugging if requested.  */
1509 | #if YYDEBUG
1510 | 
1511 | # ifndef YYFPRINTF
1512 | #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1513 | #  define YYFPRINTF fprintf
1514 | # endif
1515 | 
1516 | # define YYDPRINTF(Args)                        \
1517 | do {                                            \
1518 |   if (yydebug)                                  \
1519 |     YYFPRINTF Args;                             \
1520 | } while (0)
1521 | 
1522 | /* This macro is provided for backward compatibility. */
1523 | #ifndef YY_LOCATION_PRINT
1524 | # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1525 | #endif
1526 | 
1527 | 
1528 | # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
1529 | do {                                                                      \
1530 |   if (yydebug)                                                            \
1531 |     {                                                                     \
1532 |       YYFPRINTF (stderr, "%s ", Title);                                   \
1533 |       yy_symbol_print (stderr,                                            \
1534 |                   Type, Value); \
1535 |       YYFPRINTF (stderr, "\n");                                           \
1536 |     }                                                                     \
1537 | } while (0)
1538 | 
1539 | 
1540 | /*----------------------------------------.
1541 | | Print this symbol's value on YYOUTPUT.  |
1542 | `----------------------------------------*/
1543 | 
1544 | static void
1545 | yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1546 | {
1547 |   FILE *yyo = yyoutput;
1548 |   YYUSE (yyo);
1549 |   if (!yyvaluep)
1550 |     return;
1551 | # ifdef YYPRINT
1552 |   if (yytype < YYNTOKENS)
1553 |     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1554 | # endif
1555 |   YYUSE (yytype);
1556 | }
1557 | 
1558 | 
1559 | /*--------------------------------.
1560 | | Print this symbol on YYOUTPUT.  |
1561 | `--------------------------------*/
1562 | 
1563 | static void
1564 | yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1565 | {
1566 |   YYFPRINTF (yyoutput, "%s %s (",
1567 |              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1568 | 
1569 |   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1570 |   YYFPRINTF (yyoutput, ")");
1571 | }
1572 | 
1573 | /*------------------------------------------------------------------.
1574 | | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1575 | | TOP (included).                                                   |
1576 | `------------------------------------------------------------------*/
1577 | 
1578 | static void
1579 | yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1580 | {
1581 |   YYFPRINTF (stderr, "Stack now");
1582 |   for (; yybottom <= yytop; yybottom++)
1583 |     {
1584 |       int yybot = *yybottom;
1585 |       YYFPRINTF (stderr, " %d", yybot);
1586 |     }
1587 |   YYFPRINTF (stderr, "\n");
1588 | }
1589 | 
1590 | # define YY_STACK_PRINT(Bottom, Top)                            \
1591 | do {                                                            \
1592 |   if (yydebug)                                                  \
1593 |     yy_stack_print ((Bottom), (Top));                           \
1594 | } while (0)
1595 | 
1596 | 
1597 | /*------------------------------------------------.
1598 | | Report that the YYRULE is going to be reduced.  |
1599 | `------------------------------------------------*/
1600 | 
1601 | static void
1602 | yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
1603 | {
1604 |   unsigned long int yylno = yyrline[yyrule];
1605 |   int yynrhs = yyr2[yyrule];
1606 |   int yyi;
1607 |   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1608 |              yyrule - 1, yylno);
1609 |   /* The symbols being reduced.  */
1610 |   for (yyi = 0; yyi < yynrhs; yyi++)
1611 |     {
1612 |       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
1613 |       yy_symbol_print (stderr,
1614 |                        yystos[yyssp[yyi + 1 - yynrhs]],
1615 |                        &(yyvsp[(yyi + 1) - (yynrhs)])
1616 |                                               );
1617 |       YYFPRINTF (stderr, "\n");
1618 |     }
1619 | }
1620 | 
1621 | # define YY_REDUCE_PRINT(Rule)          \
1622 | do {                                    \
1623 |   if (yydebug)                          \
1624 |     yy_reduce_print (yyssp, yyvsp, Rule); \
1625 | } while (0)
1626 | 
1627 | /* Nonzero means print parse trace.  It is left uninitialized so that
1628 |    multiple parsers can coexist.  */
1629 | int yydebug;
1630 | #else /* !YYDEBUG */
1631 | # define YYDPRINTF(Args)
1632 | # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1633 | # define YY_STACK_PRINT(Bottom, Top)
1634 | # define YY_REDUCE_PRINT(Rule)
1635 | #endif /* !YYDEBUG */
1636 | 
1637 | 
1638 | /* YYINITDEPTH -- initial size of the parser's stacks.  */
1639 | #ifndef YYINITDEPTH
1640 | # define YYINITDEPTH 200
1641 | #endif
1642 | 
1643 | /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1644 |    if the built-in stack extension method is used).
1645 | 
1646 |    Do not make this value too large; the results are undefined if
1647 |    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1648 |    evaluated with infinite-precision integer arithmetic.  */
1649 | 
1650 | #ifndef YYMAXDEPTH
1651 | # define YYMAXDEPTH 10000
1652 | #endif
1653 | 
1654 | 
1655 | #if YYERROR_VERBOSE
1656 | 
1657 | # ifndef yystrlen
1658 | #  if defined __GLIBC__ && defined _STRING_H
1659 | #   define yystrlen strlen
1660 | #  else
1661 | /* Return the length of YYSTR.  */
1662 | static YYSIZE_T
1663 | yystrlen (const char *yystr)
1664 | {
1665 |   YYSIZE_T yylen;
1666 |   for (yylen = 0; yystr[yylen]; yylen++)
1667 |     continue;
1668 |   return yylen;
1669 | }
1670 | #  endif
1671 | # endif
1672 | 
1673 | # ifndef yystpcpy
1674 | #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1675 | #   define yystpcpy stpcpy
1676 | #  else
1677 | /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1678 |    YYDEST.  */
1679 | static char *
1680 | yystpcpy (char *yydest, const char *yysrc)
1681 | {
1682 |   char *yyd = yydest;
1683 |   const char *yys = yysrc;
1684 | 
1685 |   while ((*yyd++ = *yys++) != '\0')
1686 |     continue;
1687 | 
1688 |   return yyd - 1;
1689 | }
1690 | #  endif
1691 | # endif
1692 | 
1693 | # ifndef yytnamerr
1694 | /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1695 |    quotes and backslashes, so that it's suitable for yyerror.  The
1696 |    heuristic is that double-quoting is unnecessary unless the string
1697 |    contains an apostrophe, a comma, or backslash (other than
1698 |    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1699 |    null, do not copy; instead, return the length of what the result
1700 |    would have been.  */
1701 | static YYSIZE_T
1702 | yytnamerr (char *yyres, const char *yystr)
1703 | {
1704 |   if (*yystr == '"')
1705 |     {
1706 |       YYSIZE_T yyn = 0;
1707 |       char const *yyp = yystr;
1708 | 
1709 |       for (;;)
1710 |         switch (*++yyp)
1711 |           {
1712 |           case '\'':
1713 |           case ',':
1714 |             goto do_not_strip_quotes;
1715 | 
1716 |           case '\\':
1717 |             if (*++yyp != '\\')
1718 |               goto do_not_strip_quotes;
1719 |             /* Fall through.  */
1720 |           default:
1721 |             if (yyres)
1722 |               yyres[yyn] = *yyp;
1723 |             yyn++;
1724 |             break;
1725 | 
1726 |           case '"':
1727 |             if (yyres)
1728 |               yyres[yyn] = '\0';
1729 |             return yyn;
1730 |           }
1731 |     do_not_strip_quotes: ;
1732 |     }
1733 | 
1734 |   if (! yyres)
1735 |     return yystrlen (yystr);
1736 | 
1737 |   return yystpcpy (yyres, yystr) - yyres;
1738 | }
1739 | # endif
1740 | 
1741 | /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1742 |    about the unexpected token YYTOKEN for the state stack whose top is
1743 |    YYSSP.
1744 | 
1745 |    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
1746 |    not large enough to hold the message.  In that case, also set
1747 |    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
1748 |    required number of bytes is too large to store.  */
1749 | static int
1750 | yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1751 |                 yytype_int16 *yyssp, int yytoken)
1752 | {
1753 |   YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1754 |   YYSIZE_T yysize = yysize0;
1755 |   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1756 |   /* Internationalized format string. */
1757 |   const char *yyformat = YY_NULLPTR;
1758 |   /* Arguments of yyformat. */
1759 |   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1760 |   /* Number of reported tokens (one for the "unexpected", one per
1761 |      "expected"). */
1762 |   int yycount = 0;
1763 | 
1764 |   /* There are many possibilities here to consider:
1765 |      - If this state is a consistent state with a default action, then
1766 |        the only way this function was invoked is if the default action
1767 |        is an error action.  In that case, don't check for expected
1768 |        tokens because there are none.
1769 |      - The only way there can be no lookahead present (in yychar) is if
1770 |        this state is a consistent state with a default action.  Thus,
1771 |        detecting the absence of a lookahead is sufficient to determine
1772 |        that there is no unexpected or expected token to report.  In that
1773 |        case, just report a simple "syntax error".
1774 |      - Don't assume there isn't a lookahead just because this state is a
1775 |        consistent state with a default action.  There might have been a
1776 |        previous inconsistent state, consistent state with a non-default
1777 |        action, or user semantic action that manipulated yychar.
1778 |      - Of course, the expected token list depends on states to have
1779 |        correct lookahead information, and it depends on the parser not
1780 |        to perform extra reductions after fetching a lookahead from the
1781 |        scanner and before detecting a syntax error.  Thus, state merging
1782 |        (from LALR or IELR) and default reductions corrupt the expected
1783 |        token list.  However, the list is correct for canonical LR with
1784 |        one exception: it will still contain any token that will not be
1785 |        accepted due to an error action in a later state.
1786 |   */
1787 |   if (yytoken != YYEMPTY)
1788 |     {
1789 |       int yyn = yypact[*yyssp];
1790 |       yyarg[yycount++] = yytname[yytoken];
1791 |       if (!yypact_value_is_default (yyn))
1792 |         {
1793 |           /* Start YYX at -YYN if negative to avoid negative indexes in
1794 |              YYCHECK.  In other words, skip the first -YYN actions for
1795 |              this state because they are default actions.  */
1796 |           int yyxbegin = yyn < 0 ? -yyn : 0;
1797 |           /* Stay within bounds of both yycheck and yytname.  */
1798 |           int yychecklim = YYLAST - yyn + 1;
1799 |           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1800 |           int yyx;
1801 | 
1802 |           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1803 |             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1804 |                 && !yytable_value_is_error (yytable[yyx + yyn]))
1805 |               {
1806 |                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1807 |                   {
1808 |                     yycount = 1;
1809 |                     yysize = yysize0;
1810 |                     break;
1811 |                   }
1812 |                 yyarg[yycount++] = yytname[yyx];
1813 |                 {
1814 |                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1815 |                   if (! (yysize <= yysize1
1816 |                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1817 |                     return 2;
1818 |                   yysize = yysize1;
1819 |                 }
1820 |               }
1821 |         }
1822 |     }
1823 | 
1824 |   switch (yycount)
1825 |     {
1826 | # define YYCASE_(N, S)                      \
1827 |       case N:                               \
1828 |         yyformat = S;                       \
1829 |       break
1830 |       YYCASE_(0, YY_("syntax error"));
1831 |       YYCASE_(1, YY_("syntax error, unexpected %s"));
1832 |       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1833 |       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1834 |       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1835 |       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1836 | # undef YYCASE_
1837 |     }
1838 | 
1839 |   {
1840 |     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1841 |     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1842 |       return 2;
1843 |     yysize = yysize1;
1844 |   }
1845 | 
1846 |   if (*yymsg_alloc < yysize)
1847 |     {
1848 |       *yymsg_alloc = 2 * yysize;
1849 |       if (! (yysize <= *yymsg_alloc
1850 |              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1851 |         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1852 |       return 1;
1853 |     }
1854 | 
1855 |   /* Avoid sprintf, as that infringes on the user's name space.
1856 |      Don't have undefined behavior even if the translation
1857 |      produced a string with the wrong number of "%s"s.  */
1858 |   {
1859 |     char *yyp = *yymsg;
1860 |     int yyi = 0;
1861 |     while ((*yyp = *yyformat) != '\0')
1862 |       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1863 |         {
1864 |           yyp += yytnamerr (yyp, yyarg[yyi++]);
1865 |           yyformat += 2;
1866 |         }
1867 |       else
1868 |         {
1869 |           yyp++;
1870 |           yyformat++;
1871 |         }
1872 |   }
1873 |   return 0;
1874 | }
1875 | #endif /* YYERROR_VERBOSE */
1876 | 
1877 | /*-----------------------------------------------.
1878 | | Release the memory associated to this symbol.  |
1879 | `-----------------------------------------------*/
1880 | 
1881 | static void
1882 | yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1883 | {
1884 |   YYUSE (yyvaluep);
1885 |   if (!yymsg)
1886 |     yymsg = "Deleting";
1887 |   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1888 | 
1889 |   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1890 |   YYUSE (yytype);
1891 |   YY_IGNORE_MAYBE_UNINITIALIZED_END
1892 | }
1893 | 
1894 | 
1895 | 
1896 | 
1897 | /* The lookahead symbol.  */
1898 | int yychar;
1899 | 
1900 | /* The semantic value of the lookahead symbol.  */
1901 | YYSTYPE yylval;
1902 | /* Number of syntax errors so far.  */
1903 | int yynerrs;
1904 | 
1905 | 
1906 | /*----------.
1907 | | yyparse.  |
1908 | `----------*/
1909 | 
1910 | int
1911 | yyparse (void)
1912 | {
1913 |     int yystate;
1914 |     /* Number of tokens to shift before error messages enabled.  */
1915 |     int yyerrstatus;
1916 | 
1917 |     /* The stacks and their tools:
1918 |        'yyss': related to states.
1919 |        'yyvs': related to semantic values.
1920 | 
1921 |        Refer to the stacks through separate pointers, to allow yyoverflow
1922 |        to reallocate them elsewhere.  */
1923 | 
1924 |     /* The state stack.  */
1925 |     yytype_int16 yyssa[YYINITDEPTH];
1926 |     yytype_int16 *yyss;
1927 |     yytype_int16 *yyssp;
1928 | 
1929 |     /* The semantic value stack.  */
1930 |     YYSTYPE yyvsa[YYINITDEPTH];
1931 |     YYSTYPE *yyvs;
1932 |     YYSTYPE *yyvsp;
1933 | 
1934 |     YYSIZE_T yystacksize;
1935 | 
1936 |   int yyn;
1937 |   int yyresult;
1938 |   /* Lookahead token as an internal (translated) token number.  */
1939 |   int yytoken = 0;
1940 |   /* The variables used to return semantic value and location from the
1941 |      action routines.  */
1942 |   YYSTYPE yyval;
1943 | 
1944 | #if YYERROR_VERBOSE
1945 |   /* Buffer for error messages, and its allocated size.  */
1946 |   char yymsgbuf[128];
1947 |   char *yymsg = yymsgbuf;
1948 |   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1949 | #endif
1950 | 
1951 | #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1952 | 
1953 |   /* The number of symbols on the RHS of the reduced rule.
1954 |      Keep to zero when no symbol should be popped.  */
1955 |   int yylen = 0;
1956 | 
1957 |   yyssp = yyss = yyssa;
1958 |   yyvsp = yyvs = yyvsa;
1959 |   yystacksize = YYINITDEPTH;
1960 | 
1961 |   YYDPRINTF ((stderr, "Starting parse\n"));
1962 | 
1963 |   yystate = 0;
1964 |   yyerrstatus = 0;
1965 |   yynerrs = 0;
1966 |   yychar = YYEMPTY; /* Cause a token to be read.  */
1967 |   goto yysetstate;
1968 | 
1969 | /*------------------------------------------------------------.
1970 | | yynewstate -- Push a new state, which is found in yystate.  |
1971 | `------------------------------------------------------------*/
1972 |  yynewstate:
1973 |   /* In all cases, when you get here, the value and location stacks
1974 |      have just been pushed.  So pushing a state here evens the stacks.  */
1975 |   yyssp++;
1976 | 
1977 |  yysetstate:
1978 |   *yyssp = yystate;
1979 | 
1980 |   if (yyss + yystacksize - 1 <= yyssp)
1981 |     {
1982 |       /* Get the current used size of the three stacks, in elements.  */
1983 |       YYSIZE_T yysize = yyssp - yyss + 1;
1984 | 
1985 | #ifdef yyoverflow
1986 |       {
1987 |         /* Give user a chance to reallocate the stack.  Use copies of
1988 |            these so that the &'s don't force the real ones into
1989 |            memory.  */
1990 |         YYSTYPE *yyvs1 = yyvs;
1991 |         yytype_int16 *yyss1 = yyss;
1992 | 
1993 |         /* Each stack pointer address is followed by the size of the
1994 |            data in use in that stack, in bytes.  This used to be a
1995 |            conditional around just the two extra args, but that might
1996 |            be undefined if yyoverflow is a macro.  */
1997 |         yyoverflow (YY_("memory exhausted"),
1998 |                     &yyss1, yysize * sizeof (*yyssp),
1999 |                     &yyvs1, yysize * sizeof (*yyvsp),
2000 |                     &yystacksize);
2001 | 
2002 |         yyss = yyss1;
2003 |         yyvs = yyvs1;
2004 |       }
2005 | #else /* no yyoverflow */
2006 | # ifndef YYSTACK_RELOCATE
2007 |       goto yyexhaustedlab;
2008 | # else
2009 |       /* Extend the stack our own way.  */
2010 |       if (YYMAXDEPTH <= yystacksize)
2011 |         goto yyexhaustedlab;
2012 |       yystacksize *= 2;
2013 |       if (YYMAXDEPTH < yystacksize)
2014 |         yystacksize = YYMAXDEPTH;
2015 | 
2016 |       {
2017 |         yytype_int16 *yyss1 = yyss;
2018 |         union yyalloc *yyptr =
2019 |           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2020 |         if (! yyptr)
2021 |           goto yyexhaustedlab;
2022 |         YYSTACK_RELOCATE (yyss_alloc, yyss);
2023 |         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2024 | #  undef YYSTACK_RELOCATE
2025 |         if (yyss1 != yyssa)
2026 |           YYSTACK_FREE (yyss1);
2027 |       }
2028 | # endif
2029 | #endif /* no yyoverflow */
2030 | 
2031 |       yyssp = yyss + yysize - 1;
2032 |       yyvsp = yyvs + yysize - 1;
2033 | 
2034 |       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2035 |                   (unsigned long int) yystacksize));
2036 | 
2037 |       if (yyss + yystacksize - 1 <= yyssp)
2038 |         YYABORT;
2039 |     }
2040 | 
2041 |   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2042 | 
2043 |   if (yystate == YYFINAL)
2044 |     YYACCEPT;
2045 | 
2046 |   goto yybackup;
2047 | 
2048 | /*-----------.
2049 | | yybackup.  |
2050 | `-----------*/
2051 | yybackup:
2052 | 
2053 |   /* Do appropriate processing given the current state.  Read a
2054 |      lookahead token if we need one and don't already have one.  */
2055 | 
2056 |   /* First try to decide what to do without reference to lookahead token.  */
2057 |   yyn = yypact[yystate];
2058 |   if (yypact_value_is_default (yyn))
2059 |     goto yydefault;
2060 | 
2061 |   /* Not known => get a lookahead token if don't already have one.  */
2062 | 
2063 |   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
2064 |   if (yychar == YYEMPTY)
2065 |     {
2066 |       YYDPRINTF ((stderr, "Reading a token: "));
2067 |       yychar = yylex ();
2068 |     }
2069 | 
2070 |   if (yychar <= YYEOF)
2071 |     {
2072 |       yychar = yytoken = YYEOF;
2073 |       YYDPRINTF ((stderr, "Now at end of input.\n"));
2074 |     }
2075 |   else
2076 |     {
2077 |       yytoken = YYTRANSLATE (yychar);
2078 |       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2079 |     }
2080 | 
2081 |   /* If the proper action on seeing token YYTOKEN is to reduce or to
2082 |      detect an error, take that action.  */
2083 |   yyn += yytoken;
2084 |   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2085 |     goto yydefault;
2086 |   yyn = yytable[yyn];
2087 |   if (yyn <= 0)
2088 |     {
2089 |       if (yytable_value_is_error (yyn))
2090 |         goto yyerrlab;
2091 |       yyn = -yyn;
2092 |       goto yyreduce;
2093 |     }
2094 | 
2095 |   /* Count tokens shifted since error; after three, turn off error
2096 |      status.  */
2097 |   if (yyerrstatus)
2098 |     yyerrstatus--;
2099 | 
2100 |   /* Shift the lookahead token.  */
2101 |   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2102 | 
2103 |   /* Discard the shifted token.  */
2104 |   yychar = YYEMPTY;
2105 | 
2106 |   yystate = yyn;
2107 |   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2108 |   *++yyvsp = yylval;
2109 |   YY_IGNORE_MAYBE_UNINITIALIZED_END
2110 | 
2111 |   goto yynewstate;
2112 | 
2113 | 
2114 | /*-----------------------------------------------------------.
2115 | | yydefault -- do the default action for the current state.  |
2116 | `-----------------------------------------------------------*/
2117 | yydefault:
2118 |   yyn = yydefact[yystate];
2119 |   if (yyn == 0)
2120 |     goto yyerrlab;
2121 |   goto yyreduce;
2122 | 
2123 | 
2124 | /*-----------------------------.
2125 | | yyreduce -- Do a reduction.  |
2126 | `-----------------------------*/
2127 | yyreduce:
2128 |   /* yyn is the number of a rule to reduce with.  */
2129 |   yylen = yyr2[yyn];
2130 | 
2131 |   /* If YYLEN is nonzero, implement the default value of the action:
2132 |      '$$ = $1'.
2133 | 
2134 |      Otherwise, the following line sets YYVAL to garbage.
2135 |      This behavior is undocumented and Bison
2136 |      users should not rely upon it.  Assigning to YYVAL
2137 |      unconditionally makes the parser a bit smaller, and it avoids a
2138 |      GCC warning that YYVAL may be used uninitialized.  */
2139 |   yyval = yyvsp[1-yylen];
2140 | 
2141 | 
2142 |   YY_REDUCE_PRINT (yyn);
2143 |   switch (yyn)
2144 |     {
2145 |         case 6:
2146 | #line 178 "./parse.y" /* yacc.c:1646  */
2147 |     { scope=0; reset(); common_comment=NULL; in_typedef=0; GetCurrentComment(); }
2148 | #line 2149 "y.tab.c" /* yacc.c:1646  */
2149 |     break;
2150 | 
2151 |   case 7:
2152 | #line 180 "./parse.y" /* yacc.c:1646  */
2153 |     { scope=0; reset(); common_comment=NULL; in_typedef=0; GetCurrentComment(); }
2154 | #line 2155 "y.tab.c" /* yacc.c:1646  */
2155 |     break;
2156 | 
2157 |   case 10:
2158 | #line 189 "./parse.y" /* yacc.c:1646  */
2159 |     { scope=0; reset(); common_comment=NULL; in_typedef=0; }
2160 | #line 2161 "y.tab.c" /* yacc.c:1646  */
2161 |     break;
2162 | 
2163 |   case 11:
2164 | #line 191 "./parse.y" /* yacc.c:1646  */
2165 |     { scope=0; reset(); common_comment=NULL; in_typedef=0;
2166 |                   (yyval)=(yyvsp[0]); }
2167 | #line 2168 "y.tab.c" /* yacc.c:1646  */
2168 |     break;
2169 | 
2170 |   case 12:
2171 | #line 197 "./parse.y" /* yacc.c:1646  */
2172 |     { in_type_spec=0; }
2173 | #line 2174 "y.tab.c" /* yacc.c:1646  */
2174 |     break;
2175 | 
2176 |   case 13:
2177 | #line 199 "./parse.y" /* yacc.c:1646  */
2178 |     { in_type_spec=0; }
2179 | #line 2180 "y.tab.c" /* yacc.c:1646  */
2180 |     break;
2181 | 
2182 |   case 14:
2183 | #line 204 "./parse.y" /* yacc.c:1646  */
2184 |     { if(!in_structunion && !in_typedef && !in_function && !common_comment)
2185 |                   {common_comment=CopyString(GetCurrentComment()); SetCurrentComment(common_comment);} }
2186 | #line 2187 "y.tab.c" /* yacc.c:1646  */
2187 |     break;
2188 | 
2189 |   case 16:
2190 | #line 211 "./parse.y" /* yacc.c:1646  */
2191 |     { if((yyvsp[-1])) (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); else (yyval)=(yyvsp[0]); }
2192 | #line 2193 "y.tab.c" /* yacc.c:1646  */
2193 |     break;
2194 | 
2195 |   case 17:
2196 | #line 213 "./parse.y" /* yacc.c:1646  */
2197 |     { if(!current->type) current->type=(yyvsp[0]); }
2198 | #line 2199 "y.tab.c" /* yacc.c:1646  */
2199 |     break;
2200 | 
2201 |   case 18:
2202 | #line 215 "./parse.y" /* yacc.c:1646  */
2203 |     { if(!current->type) current->type=(yyvsp[-1]);
2204 |                   (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2205 | #line 2206 "y.tab.c" /* yacc.c:1646  */
2206 |     break;
2207 | 
2208 |   case 20:
2209 | #line 219 "./parse.y" /* yacc.c:1646  */
2210 |     { (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2211 | #line 2212 "y.tab.c" /* yacc.c:1646  */
2212 |     break;
2213 | 
2214 |   case 22:
2215 | #line 226 "./parse.y" /* yacc.c:1646  */
2216 |     { in_type_spec=1; }
2217 | #line 2218 "y.tab.c" /* yacc.c:1646  */
2218 |     break;
2219 | 
2220 |   case 24:
2221 | #line 231 "./parse.y" /* yacc.c:1646  */
2222 |     {
2223 |                  if((in_function==0 || in_function==3) && !in_funcdef && !in_structunion)
2224 |                    {
2225 |                     char* specific_comment=GetCurrentComment();
2226 |                     if(!common_comment)   SetCurrentComment(specific_comment); else
2227 |                     if(!specific_comment) SetCurrentComment(common_comment);   else
2228 |                     if(strcmp(common_comment,specific_comment)) SetCurrentComment(ConcatStrings(3,common_comment," ",specific_comment)); else
2229 |                                           SetCurrentComment(common_comment);
2230 |                    }
2231 | 
2232 |                  if(in_typedef)
2233 |                    {
2234 |                     char* vname=strstr((yyvsp[0]),current->name);
2235 |                     SeenTypedefName(current->name,vname[strlen(current->name)]=='('?-1:1);
2236 |                     if(!in_header)
2237 |                        SeenTypedef(current->name,ConcatStrings(3,current->qual,current->type,(yyvsp[0])));
2238 |                     if(in_function==3)
2239 |                        DownScope();
2240 |                    }
2241 |                  else if(in_function==2)
2242 |                     SeenFunctionArg(current->name,ConcatStrings(3,current->qual,current->type,(yyvsp[0])));
2243 |                  else
2244 |                    {
2245 |                     char* vname=strstr((yyvsp[0]),current->name);
2246 |                     if(vname[strlen(current->name)]!='(' && IsATypeName(current->type)!='f')
2247 |                       {
2248 |                        if((in_funcbody==0 || scope&EXTERN_F) && !in_structunion && !(in_header==GLOBAL && scope&EXTERN_H))
2249 |                           SeenVariableDefinition(current->name,ConcatStrings(3,current->qual,current->type,(yyvsp[0])),SCOPE);
2250 |                        else
2251 |                           if(in_funcbody)
2252 |                              SeenScopeVariable(current->name);
2253 |                       }
2254 |                     else
2255 |                        SeenFunctionProto(current->name,in_funcbody);
2256 |                     if(in_function==3)
2257 |                        DownScope();
2258 |                    }
2259 | 
2260 |                  if(in_function==3 && !in_structunion) in_function=0;
2261 |                 }
2262 | #line 2263 "y.tab.c" /* yacc.c:1646  */
2263 |     break;
2264 | 
2265 |   case 46:
2266 | #line 322 "./parse.y" /* yacc.c:1646  */
2267 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
2268 | #line 2269 "y.tab.c" /* yacc.c:1646  */
2269 |     break;
2270 | 
2271 |   case 48:
2272 | #line 328 "./parse.y" /* yacc.c:1646  */
2273 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0]));
2274 |                   { int i=0; while((yyvsp[-1])[i] && (yyvsp[-1])[i]=='*') i++; if(!(yyvsp[-1])[i]) in_type_spec=0; } }
2275 | #line 2276 "y.tab.c" /* yacc.c:1646  */
2276 |     break;
2277 | 
2278 |   case 49:
2279 | #line 331 "./parse.y" /* yacc.c:1646  */
2280 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
2281 | #line 2282 "y.tab.c" /* yacc.c:1646  */
2282 |     break;
2283 | 
2284 |   case 50:
2285 | #line 333 "./parse.y" /* yacc.c:1646  */
2286 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2287 | #line 2288 "y.tab.c" /* yacc.c:1646  */
2288 |     break;
2289 | 
2290 |   case 51:
2291 | #line 335 "./parse.y" /* yacc.c:1646  */
2292 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2293 | #line 2294 "y.tab.c" /* yacc.c:1646  */
2294 |     break;
2295 | 
2296 |   case 52:
2297 | #line 337 "./parse.y" /* yacc.c:1646  */
2298 |     { (yyval)=ConcatStrings(4,(yyvsp[-3]),(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2299 | #line 2300 "y.tab.c" /* yacc.c:1646  */
2300 |     break;
2301 | 
2302 |   case 53:
2303 | #line 339 "./parse.y" /* yacc.c:1646  */
2304 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
2305 | #line 2306 "y.tab.c" /* yacc.c:1646  */
2306 |     break;
2307 | 
2308 |   case 54:
2309 | #line 341 "./parse.y" /* yacc.c:1646  */
2310 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2311 | #line 2312 "y.tab.c" /* yacc.c:1646  */
2312 |     break;
2313 | 
2314 |   case 55:
2315 | #line 343 "./parse.y" /* yacc.c:1646  */
2316 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2317 | #line 2318 "y.tab.c" /* yacc.c:1646  */
2318 |     break;
2319 | 
2320 |   case 56:
2321 | #line 345 "./parse.y" /* yacc.c:1646  */
2322 |     { (yyval)=ConcatStrings(4,(yyvsp[-3]),(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2323 | #line 2324 "y.tab.c" /* yacc.c:1646  */
2324 |     break;
2325 | 
2326 |   case 57:
2327 | #line 352 "./parse.y" /* yacc.c:1646  */
2328 |     { in_type_spec=0; }
2329 | #line 2330 "y.tab.c" /* yacc.c:1646  */
2330 |     break;
2331 | 
2332 |   case 58:
2333 | #line 354 "./parse.y" /* yacc.c:1646  */
2334 |     { in_type_spec=0; (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
2335 | #line 2336 "y.tab.c" /* yacc.c:1646  */
2336 |     break;
2337 | 
2338 |   case 60:
2339 | #line 360 "./parse.y" /* yacc.c:1646  */
2340 |     { (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2341 | #line 2342 "y.tab.c" /* yacc.c:1646  */
2342 |     break;
2343 | 
2344 |   case 61:
2345 | #line 362 "./parse.y" /* yacc.c:1646  */
2346 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
2347 | #line 2348 "y.tab.c" /* yacc.c:1646  */
2348 |     break;
2349 | 
2350 |   case 62:
2351 | #line 364 "./parse.y" /* yacc.c:1646  */
2352 |     { (yyval)=ConcatStrings(4,(yyvsp[-2])," ",(yyvsp[-1]),(yyvsp[0])); }
2353 | #line 2354 "y.tab.c" /* yacc.c:1646  */
2354 |     break;
2355 | 
2356 |   case 64:
2357 | #line 370 "./parse.y" /* yacc.c:1646  */
2358 |     { if((yyvsp[-1])[0]=='*' && (yyvsp[-1])[1]==' ') { (yyvsp[-1])=&(yyvsp[-1])[1]; (yyvsp[-1])[0]='*'; }
2359 |                   (yyval)=ConcatStrings(4," ",(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0]));
2360 |                 }
2361 | #line 2362 "y.tab.c" /* yacc.c:1646  */
2362 |     break;
2363 | 
2364 |   case 67:
2365 | #line 379 "./parse.y" /* yacc.c:1646  */
2366 |     { (yyval)=ConcatStrings(2," ",(yyvsp[0])); current->name=(yyvsp[0]);
2367 |                   if(!current->type) current->type="int";
2368 |                   if(in_funcdef==1 && in_function!=3 && !in_structunion) SeenScopeVariable((yyvsp[0])); }
2369 | #line 2370 "y.tab.c" /* yacc.c:1646  */
2370 |     break;
2371 | 
2372 |   case 68:
2373 | #line 386 "./parse.y" /* yacc.c:1646  */
2374 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2375 | #line 2376 "y.tab.c" /* yacc.c:1646  */
2376 |     break;
2377 | 
2378 |   case 69:
2379 | #line 387 "./parse.y" /* yacc.c:1646  */
2380 |     { in_type_spec=0; }
2381 | #line 2382 "y.tab.c" /* yacc.c:1646  */
2382 |     break;
2383 | 
2384 |   case 70:
2385 | #line 387 "./parse.y" /* yacc.c:1646  */
2386 |     { in_type_spec=1; }
2387 | #line 2388 "y.tab.c" /* yacc.c:1646  */
2388 |     break;
2389 | 
2390 |   case 71:
2391 | #line 388 "./parse.y" /* yacc.c:1646  */
2392 |     { (yyval)=ConcatStrings(4,(yyvsp[-5]),(yyvsp[-4]),(yyvsp[-2]),(yyvsp[0])); }
2393 | #line 2394 "y.tab.c" /* yacc.c:1646  */
2394 |     break;
2395 | 
2396 |   case 73:
2397 | #line 399 "./parse.y" /* yacc.c:1646  */
2398 |     { (yyval)=NULL; }
2399 | #line 2400 "y.tab.c" /* yacc.c:1646  */
2400 |     break;
2401 | 
2402 |   case 74:
2403 | #line 401 "./parse.y" /* yacc.c:1646  */
2404 |     { (yyval)=NULL;
2405 |                   if(in_funcbody) scope|=EXTERN_F;
2406 |                   else if(in_header) scope|=EXTERN_H;
2407 |                   else scope|=EXTERNAL; }
2408 | #line 2409 "y.tab.c" /* yacc.c:1646  */
2409 |     break;
2410 | 
2411 |   case 75:
2412 | #line 406 "./parse.y" /* yacc.c:1646  */
2413 |     { (yyval)=NULL; }
2414 | #line 2415 "y.tab.c" /* yacc.c:1646  */
2415 |     break;
2416 | 
2417 |   case 76:
2418 | #line 408 "./parse.y" /* yacc.c:1646  */
2419 |     { (yyval)=NULL; scope |= LOCAL; }
2420 | #line 2421 "y.tab.c" /* yacc.c:1646  */
2421 |     break;
2422 | 
2423 |   case 77:
2424 | #line 410 "./parse.y" /* yacc.c:1646  */
2425 |     { (yyval)=NULL;
2426 |                   in_typedef=1; if(!in_header) SeenTypedef(NULL,NULL);
2427 |                   common_comment=CopyString(GetCurrentComment()); }
2428 | #line 2429 "y.tab.c" /* yacc.c:1646  */
2429 |     break;
2430 | 
2431 |   case 78:
2432 | #line 414 "./parse.y" /* yacc.c:1646  */
2433 |     { (yyval)=NULL; scope |= INLINED; }
2434 | #line 2435 "y.tab.c" /* yacc.c:1646  */
2435 |     break;
2436 | 
2437 |   case 80:
2438 | #line 420 "./parse.y" /* yacc.c:1646  */
2439 |     { (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2440 | #line 2441 "y.tab.c" /* yacc.c:1646  */
2441 |     break;
2442 | 
2443 |   case 81:
2444 | #line 425 "./parse.y" /* yacc.c:1646  */
2445 |     { if(!current->type) current->qual=ConcatStrings(3,current->qual,(yyvsp[0])," "); }
2446 | #line 2447 "y.tab.c" /* yacc.c:1646  */
2447 |     break;
2448 | 
2449 |   case 82:
2450 | #line 427 "./parse.y" /* yacc.c:1646  */
2451 |     { if(!current->type) current->qual=ConcatStrings(3,current->qual,(yyvsp[0])," "); }
2452 | #line 2453 "y.tab.c" /* yacc.c:1646  */
2453 |     break;
2454 | 
2455 |   case 83:
2456 | #line 434 "./parse.y" /* yacc.c:1646  */
2457 |     { in_type_spec=1; }
2458 | #line 2459 "y.tab.c" /* yacc.c:1646  */
2459 |     break;
2460 | 
2461 |   case 94:
2462 | #line 452 "./parse.y" /* yacc.c:1646  */
2463 |     { (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2464 | #line 2465 "y.tab.c" /* yacc.c:1646  */
2465 |     break;
2466 | 
2467 |   case 95:
2468 | #line 454 "./parse.y" /* yacc.c:1646  */
2469 |     { (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2470 | #line 2471 "y.tab.c" /* yacc.c:1646  */
2471 |     break;
2472 | 
2473 |   case 97:
2474 | #line 460 "./parse.y" /* yacc.c:1646  */
2475 |     { (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2476 | #line 2477 "y.tab.c" /* yacc.c:1646  */
2477 |     break;
2478 | 
2479 |   case 98:
2480 | #line 462 "./parse.y" /* yacc.c:1646  */
2481 |     { (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2482 | #line 2483 "y.tab.c" /* yacc.c:1646  */
2483 |     break;
2484 | 
2485 |   case 108:
2486 | #line 488 "./parse.y" /* yacc.c:1646  */
2487 |     { in_type_spec=0; }
2488 | #line 2489 "y.tab.c" /* yacc.c:1646  */
2489 |     break;
2490 | 
2491 |   case 109:
2492 | #line 490 "./parse.y" /* yacc.c:1646  */
2493 |     { in_type_spec=0; (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
2494 | #line 2495 "y.tab.c" /* yacc.c:1646  */
2495 |     break;
2496 | 
2497 |   case 112:
2498 | #line 502 "./parse.y" /* yacc.c:1646  */
2499 |     { push();
2500 |                   if(!in_header)
2501 |                     {
2502 |                      if(in_structunion) SeenStructUnionComp((yyvsp[-1]),in_structunion);
2503 |                      else               SeenStructUnionStart((yyvsp[-1]));
2504 |                     }
2505 |                   in_structunion++; }
2506 | #line 2507 "y.tab.c" /* yacc.c:1646  */
2507 |     break;
2508 | 
2509 |   case 113:
2510 | #line 510 "./parse.y" /* yacc.c:1646  */
2511 |     { pop(); in_structunion--;
2512 |                   if(!in_structunion && !current->type) current->type=ConcatStrings(2,(yyvsp[-4])," {...}");
2513 |                   if(!in_header && !in_structunion && in_typedef) SeenStructUnionEnd();
2514 |                   (yyval)=ConcatStrings(5,(yyvsp[-4])," ",(yyvsp[-3]),(yyvsp[-1]),(yyvsp[0])); }
2515 | #line 2516 "y.tab.c" /* yacc.c:1646  */
2516 |     break;
2517 | 
2518 |   case 114:
2519 | #line 515 "./parse.y" /* yacc.c:1646  */
2520 |     { push();
2521 |                   if(!in_header)
2522 |                     {
2523 |                      if(in_structunion) SeenStructUnionComp(ConcatStrings(3,(yyvsp[-2])," ",(yyvsp[-1])),in_structunion);
2524 |                      else               SeenStructUnionStart(ConcatStrings(3,(yyvsp[-2])," ",(yyvsp[-1])));
2525 |                     }
2526 |                   in_structunion++; }
2527 | #line 2528 "y.tab.c" /* yacc.c:1646  */
2528 |     break;
2529 | 
2530 |   case 115:
2531 | #line 523 "./parse.y" /* yacc.c:1646  */
2532 |     { pop(); in_structunion--;
2533 |                   if(!in_structunion && !current->type) current->type=ConcatStrings(3,(yyvsp[-5])," ",(yyvsp[-4]));
2534 |                   if(!in_header && !in_structunion) SeenStructUnionEnd();
2535 |                   (yyval)=ConcatStrings(7,(yyvsp[-5])," ",(yyvsp[-4])," ",(yyvsp[-3]),(yyvsp[-1]),(yyvsp[0])); }
2536 | #line 2537 "y.tab.c" /* yacc.c:1646  */
2537 |     break;
2538 | 
2539 |   case 119:
2540 | #line 537 "./parse.y" /* yacc.c:1646  */
2541 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2542 | #line 2543 "y.tab.c" /* yacc.c:1646  */
2543 |     break;
2544 | 
2545 |   case 120:
2546 | #line 542 "./parse.y" /* yacc.c:1646  */
2547 |     { if(!in_header) SeenStructUnionComp((yyvsp[0]),in_structunion); }
2548 | #line 2549 "y.tab.c" /* yacc.c:1646  */
2549 |     break;
2550 | 
2551 |   case 121:
2552 | #line 544 "./parse.y" /* yacc.c:1646  */
2553 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); if(!in_header) SeenStructUnionComp((yyvsp[-2]),in_structunion); }
2554 | #line 2555 "y.tab.c" /* yacc.c:1646  */
2555 |     break;
2556 | 
2557 |   case 123:
2558 | #line 553 "./parse.y" /* yacc.c:1646  */
2559 |     { (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2560 | #line 2561 "y.tab.c" /* yacc.c:1646  */
2561 |     break;
2562 | 
2563 |   case 128:
2564 | #line 570 "./parse.y" /* yacc.c:1646  */
2565 |     { push();
2566 |                   if(!in_header)
2567 |                     {
2568 |                      if(in_structunion) SeenStructUnionComp((yyvsp[-1]),in_structunion);
2569 |                      else               SeenStructUnionStart((yyvsp[-1]));
2570 |                     }
2571 |                   in_structunion++; }
2572 | #line 2573 "y.tab.c" /* yacc.c:1646  */
2573 |     break;
2574 | 
2575 |   case 129:
2576 | #line 578 "./parse.y" /* yacc.c:1646  */
2577 |     { pop(); in_structunion--;
2578 |                   if(!in_structunion && !current->type) current->type=ConcatStrings(2,(yyvsp[-4])," {...}");
2579 |                   if(!in_header && !in_structunion && in_typedef) SeenStructUnionEnd();
2580 |                   (yyval)=ConcatStrings(5,(yyvsp[-4])," ",(yyvsp[-3]),(yyvsp[-1]),(yyvsp[0])); }
2581 | #line 2582 "y.tab.c" /* yacc.c:1646  */
2582 |     break;
2583 | 
2584 |   case 130:
2585 | #line 583 "./parse.y" /* yacc.c:1646  */
2586 |     { push();
2587 |                   if(!in_header)
2588 |                     {
2589 |                      if(in_structunion) SeenStructUnionComp(ConcatStrings(3,(yyvsp[-2])," ",(yyvsp[-1])),in_structunion);
2590 |                      else               SeenStructUnionStart(ConcatStrings(3,(yyvsp[-2])," ",(yyvsp[-1])));
2591 |                     }
2592 |                   in_structunion++; }
2593 | #line 2594 "y.tab.c" /* yacc.c:1646  */
2594 |     break;
2595 | 
2596 |   case 131:
2597 | #line 591 "./parse.y" /* yacc.c:1646  */
2598 |     { pop(); in_structunion--;
2599 |                   if(!in_structunion && !current->type) current->type=ConcatStrings(3,(yyvsp[-5])," ",(yyvsp[-4]));
2600 |                   if(!in_header && !in_structunion) SeenStructUnionEnd();
2601 |                   (yyval)=ConcatStrings(7,(yyvsp[-5])," ",(yyvsp[-4])," ",(yyvsp[-3]),(yyvsp[-1]),(yyvsp[0])); }
2602 | #line 2603 "y.tab.c" /* yacc.c:1646  */
2603 |     break;
2604 | 
2605 |   case 132:
2606 | #line 599 "./parse.y" /* yacc.c:1646  */
2607 |     { (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2608 | #line 2609 "y.tab.c" /* yacc.c:1646  */
2609 |     break;
2610 | 
2611 |   case 137:
2612 | #line 616 "./parse.y" /* yacc.c:1646  */
2613 |     { push();
2614 |                   if(!in_header)
2615 |                     {
2616 |                      if(in_structunion) SeenStructUnionComp((yyvsp[-1]),in_structunion);
2617 |                      else               SeenStructUnionStart((yyvsp[-1]));
2618 |                     }
2619 |                   in_structunion++; }
2620 | #line 2621 "y.tab.c" /* yacc.c:1646  */
2621 |     break;
2622 | 
2623 |   case 138:
2624 | #line 624 "./parse.y" /* yacc.c:1646  */
2625 |     { pop(); in_structunion--;
2626 |                   if(!in_structunion && !current->type) current->type=ConcatStrings(2,(yyvsp[-4])," {...}");
2627 |                   if(!in_header && !in_structunion && in_typedef) SeenStructUnionEnd();
2628 |                   (yyval)=ConcatStrings(5,(yyvsp[-4])," ",(yyvsp[-3]),(yyvsp[-1]),(yyvsp[0])); }
2629 | #line 2630 "y.tab.c" /* yacc.c:1646  */
2630 |     break;
2631 | 
2632 |   case 139:
2633 | #line 629 "./parse.y" /* yacc.c:1646  */
2634 |     { push();
2635 |                   if(!in_header)
2636 |                     {
2637 |                      if(in_structunion) SeenStructUnionComp(ConcatStrings(3,(yyvsp[-2])," ",(yyvsp[-1])),in_structunion);
2638 |                      else               SeenStructUnionStart(ConcatStrings(3,(yyvsp[-2])," ",(yyvsp[-1])));
2639 |                     }
2640 |                   in_structunion++; }
2641 | #line 2642 "y.tab.c" /* yacc.c:1646  */
2642 |     break;
2643 | 
2644 |   case 140:
2645 | #line 637 "./parse.y" /* yacc.c:1646  */
2646 |     { pop(); in_structunion--;
2647 |                   if(!in_structunion && !current->type) current->type=ConcatStrings(3,(yyvsp[-5])," ",(yyvsp[-4]));
2648 |                   if(!in_header && !in_structunion) SeenStructUnionEnd();
2649 |                   (yyval)=ConcatStrings(7,(yyvsp[-5])," ",(yyvsp[-4])," ",(yyvsp[-3]),(yyvsp[-1]),(yyvsp[0])); }
2650 | #line 2651 "y.tab.c" /* yacc.c:1646  */
2651 |     break;
2652 | 
2653 |   case 141:
2654 | #line 645 "./parse.y" /* yacc.c:1646  */
2655 |     { (yyval)=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2656 | #line 2657 "y.tab.c" /* yacc.c:1646  */
2657 |     break;
2658 | 
2659 |   case 147:
2660 | #line 663 "./parse.y" /* yacc.c:1646  */
2661 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
2662 | #line 2663 "y.tab.c" /* yacc.c:1646  */
2663 |     break;
2664 | 
2665 |   case 149:
2666 | #line 669 "./parse.y" /* yacc.c:1646  */
2667 |     { (yyval) = ConcatStrings(3, (yyvsp[-1]), " ", (yyvsp[0]));
2668 |                   if(!in_header) SeenStructUnionComp((yyvsp[-1]),in_structunion); }
2669 | #line 2670 "y.tab.c" /* yacc.c:1646  */
2670 |     break;
2671 | 
2672 |   case 150:
2673 | #line 672 "./parse.y" /* yacc.c:1646  */
2674 |     { (yyval) = ConcatStrings(3, (yyvsp[-1]), " ", (yyvsp[0]));
2675 |                   if(!in_header) SeenStructUnionComp((yyvsp[-1]),in_structunion); }
2676 | #line 2677 "y.tab.c" /* yacc.c:1646  */
2677 |     break;
2678 | 
2679 |   case 152:
2680 | #line 679 "./parse.y" /* yacc.c:1646  */
2681 |     { comp_type=(yyvsp[0]); }
2682 | #line 2683 "y.tab.c" /* yacc.c:1646  */
2683 |     break;
2684 | 
2685 |   case 153:
2686 | #line 681 "./parse.y" /* yacc.c:1646  */
2687 |     { (yyval)=ConcatStrings(3,(yyvsp[-3]),(yyvsp[-1]),(yyvsp[0])); reset(); in_type_spec=0; }
2688 | #line 2689 "y.tab.c" /* yacc.c:1646  */
2689 |     break;
2690 | 
2691 |   case 154:
2692 | #line 683 "./parse.y" /* yacc.c:1646  */
2693 |     { comp_type=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2694 | #line 2695 "y.tab.c" /* yacc.c:1646  */
2695 |     break;
2696 | 
2697 |   case 155:
2698 | #line 685 "./parse.y" /* yacc.c:1646  */
2699 |     { (yyval)=ConcatStrings(4,(yyvsp[-4]),(yyvsp[-3]),(yyvsp[-1]),(yyvsp[0])); reset(); in_type_spec=0; }
2700 | #line 2701 "y.tab.c" /* yacc.c:1646  */
2701 |     break;
2702 | 
2703 |   case 156:
2704 | #line 687 "./parse.y" /* yacc.c:1646  */
2705 |     { comp_type=ConcatStrings(3,(yyvsp[-1])," ",(yyvsp[0])); }
2706 | #line 2707 "y.tab.c" /* yacc.c:1646  */
2707 |     break;
2708 | 
2709 |   case 157:
2710 | #line 689 "./parse.y" /* yacc.c:1646  */
2711 |     { (yyval)=ConcatStrings(4,(yyvsp[-4]),(yyvsp[-3]),(yyvsp[-1]),(yyvsp[0])); reset(); in_type_spec=0; }
2712 | #line 2713 "y.tab.c" /* yacc.c:1646  */
2713 |     break;
2714 | 
2715 |   case 158:
2716 | #line 694 "./parse.y" /* yacc.c:1646  */
2717 |     { if(!in_header) SeenStructUnionComp(ConcatStrings(2,comp_type,(yyvsp[0])),in_structunion); }
2718 | #line 2719 "y.tab.c" /* yacc.c:1646  */
2719 |     break;
2720 | 
2721 |   case 159:
2722 | #line 696 "./parse.y" /* yacc.c:1646  */
2723 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0]));
2724 |                   if(!in_header) SeenStructUnionComp(ConcatStrings(2,comp_type,(yyvsp[0])),in_structunion); }
2725 | #line 2726 "y.tab.c" /* yacc.c:1646  */
2726 |     break;
2727 | 
2728 |   case 162:
2729 | #line 707 "./parse.y" /* yacc.c:1646  */
2730 |     { if(in_function==2 && !in_structunion) { DownScope(); pop(); in_function=0; } }
2731 | #line 2732 "y.tab.c" /* yacc.c:1646  */
2732 |     break;
2733 | 
2734 |   case 163:
2735 | #line 712 "./parse.y" /* yacc.c:1646  */
2736 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
2737 | #line 2738 "y.tab.c" /* yacc.c:1646  */
2738 |     break;
2739 | 
2740 |   case 164:
2741 | #line 714 "./parse.y" /* yacc.c:1646  */
2742 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2743 | #line 2744 "y.tab.c" /* yacc.c:1646  */
2744 |     break;
2745 | 
2746 |   case 168:
2747 | #line 732 "./parse.y" /* yacc.c:1646  */
2748 |     { pop(); in_funcbody=1; in_function=0; }
2749 | #line 2750 "y.tab.c" /* yacc.c:1646  */
2750 |     break;
2751 | 
2752 |   case 169:
2753 | #line 734 "./parse.y" /* yacc.c:1646  */
2754 |     { in_funcbody=in_function=0; DownScope(); SeenFunctionDefinition(NULL); }
2755 | #line 2756 "y.tab.c" /* yacc.c:1646  */
2756 |     break;
2757 | 
2758 |   case 170:
2759 | #line 739 "./parse.y" /* yacc.c:1646  */
2760 |     { char *func_type,*fname=strstr((yyvsp[0]),(current-1)->name),*parenth=strstr((yyvsp[0]),"(");
2761 |                   if(parenth>fname)
2762 |                      {parenth[0]=0;func_type=ConcatStrings(3,(current-1)->qual,(current-1)->type,(yyvsp[0]));}
2763 |                   else
2764 |                     {
2765 |                      int open=1;
2766 |                      char *argbeg=strstr(&parenth[1],"("),*argend;
2767 |                      argbeg[1]=0;
2768 |                      for(argend=argbeg+2;*argend;argend++)
2769 |                        {
2770 |                         if(*argend=='(') open++;
2771 |                         if(*argend==')') open--;
2772 |                         if(!open) break;
2773 |                        }
2774 |                      func_type=ConcatStrings(4,(current-1)->qual,(current-1)->type,(yyvsp[0]),argend);
2775 |                     }
2776 |                   SeenFunctionDefinition(func_type);
2777 |                   common_comment=NULL;
2778 |                 }
2779 | #line 2780 "y.tab.c" /* yacc.c:1646  */
2780 |     break;
2781 | 
2782 |   case 172:
2783 | #line 763 "./parse.y" /* yacc.c:1646  */
2784 |     { (yyval)=ConcatStrings(3,current->qual,current->type,(yyvsp[0])); }
2785 | #line 2786 "y.tab.c" /* yacc.c:1646  */
2786 |     break;
2787 | 
2788 |   case 174:
2789 | #line 766 "./parse.y" /* yacc.c:1646  */
2790 |     { (yyval)=ConcatStrings(3,current->qual,current->type,(yyvsp[-1])); }
2791 | #line 2792 "y.tab.c" /* yacc.c:1646  */
2792 |     break;
2793 | 
2794 |   case 175:
2795 | #line 773 "./parse.y" /* yacc.c:1646  */
2796 |     { if(!in_structunion) { push(); in_function=2; } }
2797 | #line 2798 "y.tab.c" /* yacc.c:1646  */
2798 |     break;
2799 | 
2800 |   case 178:
2801 | #line 780 "./parse.y" /* yacc.c:1646  */
2802 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
2803 | #line 2804 "y.tab.c" /* yacc.c:1646  */
2804 |     break;
2805 | 
2806 |   case 179:
2807 | #line 782 "./parse.y" /* yacc.c:1646  */
2808 |     { (yyval)=ConcatStrings(2,(yyvsp[-3]),(yyvsp[-1])); }
2809 | #line 2810 "y.tab.c" /* yacc.c:1646  */
2810 |     break;
2811 | 
2812 |   case 180:
2813 | #line 787 "./parse.y" /* yacc.c:1646  */
2814 |     { if(!in_structunion)
2815 |                   { push(); if(in_function==0) UpScope();
2816 |                     if(in_function==0 && !in_funcdef) in_function=1; if(in_function!=3) in_funcdef++; } }
2817 | #line 2818 "y.tab.c" /* yacc.c:1646  */
2818 |     break;
2819 | 
2820 |   case 181:
2821 | #line 791 "./parse.y" /* yacc.c:1646  */
2822 |     { if(!in_structunion)
2823 |                     { pop();  if(in_function!=3) in_funcdef--; if(in_funcdef==0) in_function=3; }
2824 |                   (yyval)=ConcatStrings(4,(yyvsp[-4]),(yyvsp[-3]),(yyvsp[-1]),(yyvsp[0])); }
2825 | #line 2826 "y.tab.c" /* yacc.c:1646  */
2826 |     break;
2827 | 
2828 |   case 182:
2829 | #line 798 "./parse.y" /* yacc.c:1646  */
2830 |     {
2831 |                   if(!in_funcdef && !in_function && !in_funcbody && !in_structunion) SeenFunctionDeclaration(current->name,SCOPE);
2832 |                   in_type_spec=0;
2833 |                 }
2834 | #line 2835 "y.tab.c" /* yacc.c:1646  */
2835 |     break;
2836 | 
2837 |   case 183:
2838 | #line 806 "./parse.y" /* yacc.c:1646  */
2839 |     { if(in_function==1 && in_funcdef==1 && !in_structunion) SeenFunctionArg("void","void");
2840 |                   if(in_structunion) (yyval)=NULL; else (yyval)="void"; }
2841 | #line 2842 "y.tab.c" /* yacc.c:1646  */
2842 |     break;
2843 | 
2844 |   case 186:
2845 | #line 814 "./parse.y" /* yacc.c:1646  */
2846 |     { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) { SeenFunctionArg((yyvsp[0]),NULL); SeenScopeVariable((yyvsp[0])); } }
2847 | #line 2848 "y.tab.c" /* yacc.c:1646  */
2848 |     break;
2849 | 
2850 |   case 187:
2851 | #line 816 "./parse.y" /* yacc.c:1646  */
2852 |     { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) { SeenFunctionArg((yyvsp[0]),NULL); SeenScopeVariable((yyvsp[0])); }
2853 |                   (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2854 | #line 2855 "y.tab.c" /* yacc.c:1646  */
2855 |     break;
2856 | 
2857 |   case 189:
2858 | #line 823 "./parse.y" /* yacc.c:1646  */
2859 |     { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) SeenFunctionArg((yyvsp[0]),(yyvsp[0]));
2860 |                   (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2861 | #line 2862 "y.tab.c" /* yacc.c:1646  */
2862 |     break;
2863 | 
2864 |   case 190:
2865 | #line 829 "./parse.y" /* yacc.c:1646  */
2866 |     { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) SeenFunctionArg(strcmp("void",(yyvsp[0]))?current->name:"void",(yyvsp[0]));
2867 |                   in_type_spec=0; }
2868 | #line 2869 "y.tab.c" /* yacc.c:1646  */
2869 |     break;
2870 | 
2871 |   case 191:
2872 | #line 832 "./parse.y" /* yacc.c:1646  */
2873 |     { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) SeenFunctionArg(current->name,(yyvsp[0]));
2874 |                   in_type_spec=0; (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2875 | #line 2876 "y.tab.c" /* yacc.c:1646  */
2876 |     break;
2877 | 
2878 |   case 192:
2879 | #line 838 "./parse.y" /* yacc.c:1646  */
2880 |     { in_type_spec=0; (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
2881 | #line 2882 "y.tab.c" /* yacc.c:1646  */
2882 |     break;
2883 | 
2884 |   case 193:
2885 | #line 840 "./parse.y" /* yacc.c:1646  */
2886 |     { in_type_spec=0; }
2887 | #line 2888 "y.tab.c" /* yacc.c:1646  */
2888 |     break;
2889 | 
2890 |   case 194:
2891 | #line 842 "./parse.y" /* yacc.c:1646  */
2892 |     { in_type_spec=0; (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
2893 | #line 2894 "y.tab.c" /* yacc.c:1646  */
2894 |     break;
2895 | 
2896 |   case 207:
2897 | #line 866 "./parse.y" /* yacc.c:1646  */
2898 |     { UpScope(); reset(); }
2899 | #line 2900 "y.tab.c" /* yacc.c:1646  */
2900 |     break;
2901 | 
2902 |   case 208:
2903 | #line 868 "./parse.y" /* yacc.c:1646  */
2904 |     { DownScope(); }
2905 | #line 2906 "y.tab.c" /* yacc.c:1646  */
2906 |     break;
2907 | 
2908 |   case 215:
2909 | #line 885 "./parse.y" /* yacc.c:1646  */
2910 |     { scope=0; reset(); common_comment=NULL; in_typedef=0; }
2911 | #line 2912 "y.tab.c" /* yacc.c:1646  */
2912 |     break;
2913 | 
2914 |   case 224:
2915 | #line 917 "./parse.y" /* yacc.c:1646  */
2916 |     { UpScope(); reset(); }
2917 | #line 2918 "y.tab.c" /* yacc.c:1646  */
2918 |     break;
2919 | 
2920 |   case 225:
2921 | #line 919 "./parse.y" /* yacc.c:1646  */
2922 |     { DownScope(); }
2923 | #line 2924 "y.tab.c" /* yacc.c:1646  */
2924 |     break;
2925 | 
2926 |   case 235:
2927 | #line 936 "./parse.y" /* yacc.c:1646  */
2928 |     { in_type_spec=0; }
2929 | #line 2930 "y.tab.c" /* yacc.c:1646  */
2930 |     break;
2931 | 
2932 |   case 236:
2933 | #line 938 "./parse.y" /* yacc.c:1646  */
2934 |     { in_type_spec=0; }
2935 | #line 2936 "y.tab.c" /* yacc.c:1646  */
2936 |     break;
2937 | 
2938 |   case 256:
2939 | #line 1011 "./parse.y" /* yacc.c:1646  */
2940 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2941 | #line 2942 "y.tab.c" /* yacc.c:1646  */
2942 |     break;
2943 | 
2944 |   case 273:
2945 | #line 1042 "./parse.y" /* yacc.c:1646  */
2946 |     { (yyval)=ConcatStrings(5,(yyvsp[-4]),(yyvsp[-3]),(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2947 | #line 2948 "y.tab.c" /* yacc.c:1646  */
2948 |     break;
2949 | 
2950 |   case 274:
2951 | #line 1044 "./parse.y" /* yacc.c:1646  */
2952 |     { (yyval)=ConcatStrings(4,(yyvsp[-3]),(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2953 | #line 2954 "y.tab.c" /* yacc.c:1646  */
2954 |     break;
2955 | 
2956 |   case 276:
2957 | #line 1052 "./parse.y" /* yacc.c:1646  */
2958 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2959 | #line 2960 "y.tab.c" /* yacc.c:1646  */
2960 |     break;
2961 | 
2962 |   case 278:
2963 | #line 1060 "./parse.y" /* yacc.c:1646  */
2964 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2965 | #line 2966 "y.tab.c" /* yacc.c:1646  */
2966 |     break;
2967 | 
2968 |   case 280:
2969 | #line 1068 "./parse.y" /* yacc.c:1646  */
2970 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2971 | #line 2972 "y.tab.c" /* yacc.c:1646  */
2972 |     break;
2973 | 
2974 |   case 282:
2975 | #line 1076 "./parse.y" /* yacc.c:1646  */
2976 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2977 | #line 2978 "y.tab.c" /* yacc.c:1646  */
2978 |     break;
2979 | 
2980 |   case 284:
2981 | #line 1084 "./parse.y" /* yacc.c:1646  */
2982 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2983 | #line 2984 "y.tab.c" /* yacc.c:1646  */
2984 |     break;
2985 | 
2986 |   case 286:
2987 | #line 1092 "./parse.y" /* yacc.c:1646  */
2988 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2989 | #line 2990 "y.tab.c" /* yacc.c:1646  */
2990 |     break;
2991 | 
2992 |   case 290:
2993 | #line 1105 "./parse.y" /* yacc.c:1646  */
2994 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
2995 | #line 2996 "y.tab.c" /* yacc.c:1646  */
2996 |     break;
2997 | 
2998 |   case 296:
2999 | #line 1120 "./parse.y" /* yacc.c:1646  */
3000 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
3001 | #line 3002 "y.tab.c" /* yacc.c:1646  */
3002 |     break;
3003 | 
3004 |   case 300:
3005 | #line 1133 "./parse.y" /* yacc.c:1646  */
3006 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
3007 | #line 3008 "y.tab.c" /* yacc.c:1646  */
3008 |     break;
3009 | 
3010 |   case 304:
3011 | #line 1146 "./parse.y" /* yacc.c:1646  */
3012 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
3013 | #line 3014 "y.tab.c" /* yacc.c:1646  */
3014 |     break;
3015 | 
3016 |   case 320:
3017 | #line 1177 "./parse.y" /* yacc.c:1646  */
3018 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
3019 | #line 3020 "y.tab.c" /* yacc.c:1646  */
3020 |     break;
3021 | 
3022 |   case 321:
3023 | #line 1182 "./parse.y" /* yacc.c:1646  */
3024 |     { (yyval)=ConcatStrings(4,(yyvsp[-3]),(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
3025 | #line 3026 "y.tab.c" /* yacc.c:1646  */
3026 |     break;
3027 | 
3028 |   case 324:
3029 | #line 1192 "./parse.y" /* yacc.c:1646  */
3030 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
3031 | #line 3032 "y.tab.c" /* yacc.c:1646  */
3032 |     break;
3033 | 
3034 |   case 327:
3035 | #line 1205 "./parse.y" /* yacc.c:1646  */
3036 |     { (yyval)=ConcatStrings(4,(yyvsp[-3]),(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
3037 | #line 3038 "y.tab.c" /* yacc.c:1646  */
3038 |     break;
3039 | 
3040 |   case 328:
3041 | #line 1207 "./parse.y" /* yacc.c:1646  */
3042 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
3043 | #line 3044 "y.tab.c" /* yacc.c:1646  */
3044 |     break;
3045 | 
3046 |   case 329:
3047 | #line 1212 "./parse.y" /* yacc.c:1646  */
3048 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
3049 | #line 3050 "y.tab.c" /* yacc.c:1646  */
3050 |     break;
3051 | 
3052 |   case 330:
3053 | #line 1217 "./parse.y" /* yacc.c:1646  */
3054 |     { (yyval)=ConcatStrings(2,(yyvsp[-1]),(yyvsp[0])); }
3055 | #line 3056 "y.tab.c" /* yacc.c:1646  */
3056 |     break;
3057 | 
3058 |   case 333:
3059 | #line 1226 "./parse.y" /* yacc.c:1646  */
3060 |     { if(!IsAScopeVariable((yyvsp[0]))) SeenFunctionCall((yyvsp[0])); }
3061 | #line 3062 "y.tab.c" /* yacc.c:1646  */
3062 |     break;
3063 | 
3064 |   case 349:
3065 | #line 1270 "./parse.y" /* yacc.c:1646  */
3066 |     { CheckFunctionVariableRef((yyvsp[0]),in_funcbody); }
3067 | #line 3068 "y.tab.c" /* yacc.c:1646  */
3068 |     break;
3069 | 
3070 |   case 355:
3071 | #line 1283 "./parse.y" /* yacc.c:1646  */
3072 |     { (yyval)=ConcatStrings(3,(yyvsp[-2]),(yyvsp[-1]),(yyvsp[0])); }
3073 | #line 3074 "y.tab.c" /* yacc.c:1646  */
3074 |     break;
3075 | 
3076 |   case 356:
3077 | #line 1284 "./parse.y" /* yacc.c:1646  */
3078 |     { push(); }
3079 | #line 3080 "y.tab.c" /* yacc.c:1646  */
3080 |     break;
3081 | 
3082 |   case 357:
3083 | #line 1284 "./parse.y" /* yacc.c:1646  */
3084 |     { pop(); }
3085 | #line 3086 "y.tab.c" /* yacc.c:1646  */
3086 |     break;
3087 | 
3088 | 
3089 | #line 3090 "y.tab.c" /* yacc.c:1646  */
3090 |       default: break;
3091 |     }
3092 |   /* User semantic actions sometimes alter yychar, and that requires
3093 |      that yytoken be updated with the new translation.  We take the
3094 |      approach of translating immediately before every use of yytoken.
3095 |      One alternative is translating here after every semantic action,
3096 |      but that translation would be missed if the semantic action invokes
3097 |      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
3098 |      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
3099 |      incorrect destructor might then be invoked immediately.  In the
3100 |      case of YYERROR or YYBACKUP, subsequent parser actions might lead
3101 |      to an incorrect destructor call or verbose syntax error message
3102 |      before the lookahead is translated.  */
3103 |   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3104 | 
3105 |   YYPOPSTACK (yylen);
3106 |   yylen = 0;
3107 |   YY_STACK_PRINT (yyss, yyssp);
3108 | 
3109 |   *++yyvsp = yyval;
3110 | 
3111 |   /* Now 'shift' the result of the reduction.  Determine what state
3112 |      that goes to, based on the state we popped back to and the rule
3113 |      number reduced by.  */
3114 | 
3115 |   yyn = yyr1[yyn];
3116 | 
3117 |   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3118 |   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3119 |     yystate = yytable[yystate];
3120 |   else
3121 |     yystate = yydefgoto[yyn - YYNTOKENS];
3122 | 
3123 |   goto yynewstate;
3124 | 
3125 | 
3126 | /*--------------------------------------.
3127 | | yyerrlab -- here on detecting error.  |
3128 | `--------------------------------------*/
3129 | yyerrlab:
3130 |   /* Make sure we have latest lookahead translation.  See comments at
3131 |      user semantic actions for why this is necessary.  */
3132 |   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
3133 | 
3134 |   /* If not already recovering from an error, report this error.  */
3135 |   if (!yyerrstatus)
3136 |     {
3137 |       ++yynerrs;
3138 | #if ! YYERROR_VERBOSE
3139 |       yyerror (YY_("syntax error"));
3140 | #else
3141 | # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
3142 |                                         yyssp, yytoken)
3143 |       {
3144 |         char const *yymsgp = YY_("syntax error");
3145 |         int yysyntax_error_status;
3146 |         yysyntax_error_status = YYSYNTAX_ERROR;
3147 |         if (yysyntax_error_status == 0)
3148 |           yymsgp = yymsg;
3149 |         else if (yysyntax_error_status == 1)
3150 |           {
3151 |             if (yymsg != yymsgbuf)
3152 |               YYSTACK_FREE (yymsg);
3153 |             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
3154 |             if (!yymsg)
3155 |               {
3156 |                 yymsg = yymsgbuf;
3157 |                 yymsg_alloc = sizeof yymsgbuf;
3158 |                 yysyntax_error_status = 2;
3159 |               }
3160 |             else
3161 |               {
3162 |                 yysyntax_error_status = YYSYNTAX_ERROR;
3163 |                 yymsgp = yymsg;
3164 |               }
3165 |           }
3166 |         yyerror (yymsgp);
3167 |         if (yysyntax_error_status == 2)
3168 |           goto yyexhaustedlab;
3169 |       }
3170 | # undef YYSYNTAX_ERROR
3171 | #endif
3172 |     }
3173 | 
3174 | 
3175 | 
3176 |   if (yyerrstatus == 3)
3177 |     {
3178 |       /* If just tried and failed to reuse lookahead token after an
3179 |          error, discard it.  */
3180 | 
3181 |       if (yychar <= YYEOF)
3182 |         {
3183 |           /* Return failure if at end of input.  */
3184 |           if (yychar == YYEOF)
3185 |             YYABORT;
3186 |         }
3187 |       else
3188 |         {
3189 |           yydestruct ("Error: discarding",
3190 |                       yytoken, &yylval);
3191 |           yychar = YYEMPTY;
3192 |         }
3193 |     }
3194 | 
3195 |   /* Else will try to reuse lookahead token after shifting the error
3196 |      token.  */
3197 |   goto yyerrlab1;
3198 | 
3199 | 
3200 | /*---------------------------------------------------.
3201 | | yyerrorlab -- error raised explicitly by YYERROR.  |
3202 | `---------------------------------------------------*/
3203 | yyerrorlab:
3204 | 
3205 |   /* Pacify compilers like GCC when the user code never invokes
3206 |      YYERROR and the label yyerrorlab therefore never appears in user
3207 |      code.  */
3208 |   if (/*CONSTCOND*/ 0)
3209 |      goto yyerrorlab;
3210 | 
3211 |   /* Do not reclaim the symbols of the rule whose action triggered
3212 |      this YYERROR.  */
3213 |   YYPOPSTACK (yylen);
3214 |   yylen = 0;
3215 |   YY_STACK_PRINT (yyss, yyssp);
3216 |   yystate = *yyssp;
3217 |   goto yyerrlab1;
3218 | 
3219 | 
3220 | /*-------------------------------------------------------------.
3221 | | yyerrlab1 -- common code for both syntax error and YYERROR.  |
3222 | `-------------------------------------------------------------*/
3223 | yyerrlab1:
3224 |   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
3225 | 
3226 |   for (;;)
3227 |     {
3228 |       yyn = yypact[yystate];
3229 |       if (!yypact_value_is_default (yyn))
3230 |         {
3231 |           yyn += YYTERROR;
3232 |           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3233 |             {
3234 |               yyn = yytable[yyn];
3235 |               if (0 < yyn)
3236 |                 break;
3237 |             }
3238 |         }
3239 | 
3240 |       /* Pop the current state because it cannot handle the error token.  */
3241 |       if (yyssp == yyss)
3242 |         YYABORT;
3243 | 
3244 | 
3245 |       yydestruct ("Error: popping",
3246 |                   yystos[yystate], yyvsp);
3247 |       YYPOPSTACK (1);
3248 |       yystate = *yyssp;
3249 |       YY_STACK_PRINT (yyss, yyssp);
3250 |     }
3251 | 
3252 |   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3253 |   *++yyvsp = yylval;
3254 |   YY_IGNORE_MAYBE_UNINITIALIZED_END
3255 | 
3256 | 
3257 |   /* Shift the error token.  */
3258 |   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3259 | 
3260 |   yystate = yyn;
3261 |   goto yynewstate;
3262 | 
3263 | 
3264 | /*-------------------------------------.
3265 | | yyacceptlab -- YYACCEPT comes here.  |
3266 | `-------------------------------------*/
3267 | yyacceptlab:
3268 |   yyresult = 0;
3269 |   goto yyreturn;
3270 | 
3271 | /*-----------------------------------.
3272 | | yyabortlab -- YYABORT comes here.  |
3273 | `-----------------------------------*/
3274 | yyabortlab:
3275 |   yyresult = 1;
3276 |   goto yyreturn;
3277 | 
3278 | #if !defined yyoverflow || YYERROR_VERBOSE
3279 | /*-------------------------------------------------.
3280 | | yyexhaustedlab -- memory exhaustion comes here.  |
3281 | `-------------------------------------------------*/
3282 | yyexhaustedlab:
3283 |   yyerror (YY_("memory exhausted"));
3284 |   yyresult = 2;
3285 |   /* Fall through.  */
3286 | #endif
3287 | 
3288 | yyreturn:
3289 |   if (yychar != YYEMPTY)
3290 |     {
3291 |       /* Make sure we have latest lookahead translation.  See comments at
3292 |          user semantic actions for why this is necessary.  */
3293 |       yytoken = YYTRANSLATE (yychar);
3294 |       yydestruct ("Cleanup: discarding lookahead",
3295 |                   yytoken, &yylval);
3296 |     }
3297 |   /* Do not reclaim the symbols of the rule whose action triggered
3298 |      this YYABORT or YYACCEPT.  */
3299 |   YYPOPSTACK (yylen);
3300 |   YY_STACK_PRINT (yyss, yyssp);
3301 |   while (yyssp != yyss)
3302 |     {
3303 |       yydestruct ("Cleanup: popping",
3304 |                   yystos[*yyssp], yyvsp);
3305 |       YYPOPSTACK (1);
3306 |     }
3307 | #ifndef yyoverflow
3308 |   if (yyss != yyssa)
3309 |     YYSTACK_FREE (yyss);
3310 | #endif
3311 | #if YYERROR_VERBOSE
3312 |   if (yymsg != yymsgbuf)
3313 |     YYSTACK_FREE (yymsg);
3314 | #endif
3315 |   return yyresult;
3316 | }
3317 | #line 1343 "./parse.y" /* yacc.c:1906  */
3318 | 
3319 | 
3320 | #if YYDEBUG
3321 | 
3322 | static int   last_yylex[11];
3323 | static char *last_yylval[11];
3324 | static int count=0,modcount=0;
3325 | 
3326 | #endif /* YYDEBUG */
3327 | 
3328 | 
3329 |  /*++++++++++++++++++++++++++++++++++++++
3330 |   Stop parsing the current file, due to an error.
3331 | 
3332 |   char *s The error message to print out.
3333 |   ++++++++++++++++++++++++++++++++++++++*/
3334 | 
3335 | static void yyerror( const char *s )
3336 | {
3337 | #if YYDEBUG
3338 |  int i;
3339 | #endif
3340 | 
3341 |  fflush(stdout);
3342 |  fprintf(stderr,"%s:%d: cxref: %s\n\n",parse_file,parse_line,s);
3343 | 
3344 | #if YYDEBUG
3345 | 
3346 |  fprintf(stderr,"The previous 10, current and next 10 symbols are:\n");
3347 | 
3348 |  for(i=count>10?count-11:0,modcount=i%11;i<count-1;i++,modcount=i%11)
3349 | #ifdef YYBISON
3350 |     fprintf(stderr,"%3d | %3d : %16s : %s\n",i+1-count,last_yylex[modcount],yytname[YYTRANSLATE(last_yylex[modcount])],last_yylval[modcount]);
3351 | #else
3352 |     fprintf(stderr,"%3d | %3d : %s\n",i+1-count,last_yylex[modcount],last_yylval[modcount]);
3353 | #endif
3354 | 
3355 | #ifdef YYBISON
3356 |  fprintf(stderr,"  0 | %3d : %16s : %s\n",yychar,yytname[YYTRANSLATE(yychar)],yylval);
3357 | #else
3358 |  fprintf(stderr,"  0 | %3d : %s\n",yychar,yylval);
3359 | #endif
3360 | 
3361 |  for(i=0;i<10;i++)
3362 |    {
3363 |     yychar=yylex();
3364 |     if(!yychar)
3365 |       {fprintf(stderr,"END OF FILE\n");break;}
3366 | #ifdef YYBISON
3367 |     fprintf(stderr,"%3d | %3d : %16s : %s\n",i+1,yychar,yytname[YYTRANSLATE(yychar)],yylval);
3368 | #else
3369 |     fprintf(stderr,"%3d | %3d : %s\n",i+1,yychar,yylval);
3370 | #endif
3371 |    }
3372 | 
3373 |  fprintf(stderr,"\n");
3374 | 
3375 | #endif /* YYDEBUG */
3376 | 
3377 |  /* Finish off the input. */
3378 | 
3379 | #undef yylex
3380 | 
3381 |  if(yychar)
3382 |     while((yychar=yylex()));
3383 | }
3384 | 
3385 | 
3386 |  /*++++++++++++++++++++++++++++++++++++++
3387 |   Call the lexer, the feedback from the parser to the lexer is applied here.
3388 | 
3389 |   int cxref_yylex Returns the value from the lexer, modified due to parser feedback.
3390 |   ++++++++++++++++++++++++++++++++++++++*/
3391 | 
3392 | static int cxref_yylex(void)
3393 | {
3394 |  static int last_yyl=0;
3395 |  int yyl=yylex();
3396 | 
3397 |  if(yyl==TYPE_NAME)
3398 |     if(in_type_spec || (in_structunion && last_yyl=='}') || last_yyl==TYPE_NAME ||
3399 |        last_yyl==GOTO ||
3400 |        last_yyl==CHAR || last_yyl==SHORT || last_yyl==INT || last_yyl==LONG ||
3401 |        last_yyl==SIGNED || last_yyl==UNSIGNED ||
3402 |        last_yyl==FLOAT || last_yyl==DOUBLE ||
3403 |        last_yyl==BOOL)
3404 |        yyl=IDENTIFIER;
3405 | 
3406 |  last_yyl=yyl;
3407 | 
3408 | #if YYDEBUG
3409 | 
3410 |  last_yylex [modcount]=yyl;
3411 |  last_yylval[modcount]=yylval;
3412 | 
3413 |  if(yyl)
3414 |    {
3415 |     count++;
3416 |     modcount=count%11;
3417 |    }
3418 |  else
3419 |    {
3420 |     count=0;
3421 |     modcount=0;
3422 |    }
3423 | 
3424 | #if YYDEBUG == 2
3425 | 
3426 |  if(yyl)
3427 | #ifdef YYBISON
3428 |     printf("#parse.y# %6d | %16s:%4d | %3d : %16s : %s\n",count,parse_file,parse_line,yyl,yytname[YYTRANSLATE(yyl)],yylval);
3429 | #else
3430 |     printf("#parse.y# %6d | %16s:%4d | %3d : %s\n",count,parse_file,parse_line,yyl,yylval);
3431 | #endif /* YYBISON */
3432 |  else
3433 |     printf("#parse.y# %6d | %16s:%4d | END OF FILE\n",count,parse_file,parse_line);
3434 | 
3435 |  fflush(stdout);
3436 | 
3437 | #endif /* YYDEBUG==2 */
3438 | 
3439 | #endif /* YYDEBUG */
3440 | 
3441 |  return(yyl);
3442 | }