Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/binutils/rcparse.c
Line
Count
Source (jump to first uncovered line)
1
/* A Bison parser, made by GNU Bison 3.5.1.  */
2
3
/* Bison implementation for Yacc-like parsers in C
4
5
   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
6
   Inc.
7
8
   This program is free software: you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation, either version 3 of the License, or
11
   (at your option) any later version.
12
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
18
   You should have received a copy of the GNU General Public License
19
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21
/* As a special exception, you may create a larger work that contains
22
   part or all of the Bison parser skeleton and distribute that work
23
   under terms of your choice, so long as that work isn't itself a
24
   parser generator using the skeleton or a modified version thereof
25
   as a parser skeleton.  Alternatively, if you modify or redistribute
26
   the parser skeleton itself, you may (at your option) remove this
27
   special exception, which will cause the skeleton and the resulting
28
   Bison output files to be licensed under the GNU General Public
29
   License without this special exception.
30
31
   This special exception was added by the Free Software Foundation in
32
   version 2.2 of Bison.  */
33
34
/* C LALR(1) parser skeleton written by Richard Stallman, by
35
   simplifying the original so-called "semantic" parser.  */
36
37
/* All symbols defined below should begin with yy or YY, to avoid
38
   infringing on user name space.  This should be done even for local
39
   variables, as they might otherwise be expanded by user macros.
40
   There are some unavoidable exceptions within include files to
41
   define necessary library symbols; they are noted "INFRINGES ON
42
   USER NAME SPACE" below.  */
43
44
/* Undocumented macros, especially those whose name start with YY_,
45
   are private implementation details.  Do not rely on them.  */
46
47
/* Identify Bison output.  */
48
#define YYBISON 1
49
50
/* Bison version.  */
51
#define YYBISON_VERSION "3.5.1"
52
53
/* Skeleton name.  */
54
#define YYSKELETON_NAME "yacc.c"
55
56
/* Pure parsers.  */
57
#define YYPURE 0
58
59
/* Push parsers.  */
60
#define YYPUSH 0
61
62
/* Pull parsers.  */
63
#define YYPULL 1
64
65
66
67
68
/* First part of user prologue.  */
69
#line 1 "rcparse.y"
70
 /* rcparse.y -- parser for Windows rc files
71
   Copyright (C) 1997-2024 Free Software Foundation, Inc.
72
   Written by Ian Lance Taylor, Cygnus Support.
73
   Extended by Kai Tietz, Onevision.
74
75
   This file is part of GNU Binutils.
76
77
   This program is free software; you can redistribute it and/or modify
78
   it under the terms of the GNU General Public License as published by
79
   the Free Software Foundation; either version 3 of the License, or
80
   (at your option) any later version.
81
82
   This program is distributed in the hope that it will be useful,
83
   but WITHOUT ANY WARRANTY; without even the implied warranty of
84
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
85
   GNU General Public License for more details.
86
87
   You should have received a copy of the GNU General Public License
88
   along with this program; if not, write to the Free Software
89
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
90
   02110-1301, USA.  */
91
92
93
/* This is a parser for Windows rc files.  It is based on the parser
94
   by Gunther Ebert <gunther.ebert@ixos-leipzig.de>.  */
95
96
#include "sysdep.h"
97
#include "bfd.h"
98
#include "bucomm.h"
99
#include "libiberty.h"
100
#include "windres.h"
101
#include "safe-ctype.h"
102
103
/* The current language.  */
104
105
static unsigned short language;
106
107
/* The resource information during a sub statement.  */
108
109
static rc_res_res_info sub_res_info;
110
111
/* Dialog information.  This is built by the nonterminals styles and
112
   controls.  */
113
114
static rc_dialog dialog;
115
116
/* This is used when building a style.  It is modified by the
117
   nonterminal styleexpr.  */
118
119
static unsigned long style;
120
121
/* These are used when building a control.  They are set before using
122
   control_params.  */
123
124
static rc_uint_type base_style;
125
static rc_uint_type default_style;
126
static rc_res_id class;
127
static rc_res_id res_text_field;
128
static unichar null_unichar;
129
130
/* This is used for COMBOBOX, LISTBOX and EDITTEXT which
131
   do not allow resource 'text' field in control definition. */
132
static const rc_res_id res_null_text = { 1, {{0, &null_unichar}}};
133
134
135
#line 136 "rcparse.c"
136
137
# ifndef YY_CAST
138
#  ifdef __cplusplus
139
#   define YY_CAST(Type, Val) static_cast<Type> (Val)
140
#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
141
#  else
142
#   define YY_CAST(Type, Val) ((Type) (Val))
143
#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
144
#  endif
145
# endif
146
# ifndef YY_NULLPTR
147
#  if defined __cplusplus
148
#   if 201103L <= __cplusplus
149
#    define YY_NULLPTR nullptr
150
#   else
151
#    define YY_NULLPTR 0
152
#   endif
153
#  else
154
#   define YY_NULLPTR ((void*)0)
155
#  endif
156
# endif
157
158
/* Enabling verbose error messages.  */
159
#ifdef YYERROR_VERBOSE
160
# undef YYERROR_VERBOSE
161
# define YYERROR_VERBOSE 1
162
#else
163
# define YYERROR_VERBOSE 0
164
#endif
165
166
/* Use api.header.include to #include this header
167
   instead of duplicating it here.  */
168
#ifndef YY_YY_RCPARSE_H_INCLUDED
169
# define YY_YY_RCPARSE_H_INCLUDED
170
/* Debug traces.  */
171
#ifndef YYDEBUG
172
# define YYDEBUG 0
173
#endif
174
#if YYDEBUG
175
extern int yydebug;
176
#endif
177
178
/* Token type.  */
179
#ifndef YYTOKENTYPE
180
# define YYTOKENTYPE
181
  enum yytokentype
182
  {
183
    BEG = 258,
184
    END = 259,
185
    ACCELERATORS = 260,
186
    VIRTKEY = 261,
187
    ASCII = 262,
188
    NOINVERT = 263,
189
    SHIFT = 264,
190
    CONTROL = 265,
191
    ALT = 266,
192
    BITMAP = 267,
193
    CURSOR = 268,
194
    DIALOG = 269,
195
    DIALOGEX = 270,
196
    EXSTYLE = 271,
197
    CAPTION = 272,
198
    CLASS = 273,
199
    STYLE = 274,
200
    AUTO3STATE = 275,
201
    AUTOCHECKBOX = 276,
202
    AUTORADIOBUTTON = 277,
203
    CHECKBOX = 278,
204
    COMBOBOX = 279,
205
    CTEXT = 280,
206
    DEFPUSHBUTTON = 281,
207
    EDITTEXT = 282,
208
    GROUPBOX = 283,
209
    LISTBOX = 284,
210
    LTEXT = 285,
211
    PUSHBOX = 286,
212
    PUSHBUTTON = 287,
213
    RADIOBUTTON = 288,
214
    RTEXT = 289,
215
    SCROLLBAR = 290,
216
    STATE3 = 291,
217
    USERBUTTON = 292,
218
    BEDIT = 293,
219
    HEDIT = 294,
220
    IEDIT = 295,
221
    FONT = 296,
222
    ICON = 297,
223
    ANICURSOR = 298,
224
    ANIICON = 299,
225
    DLGINCLUDE = 300,
226
    DLGINIT = 301,
227
    FONTDIR = 302,
228
    HTML = 303,
229
    MANIFEST = 304,
230
    PLUGPLAY = 305,
231
    VXD = 306,
232
    TOOLBAR = 307,
233
    BUTTON = 308,
234
    LANGUAGE = 309,
235
    CHARACTERISTICS = 310,
236
    VERSIONK = 311,
237
    MENU = 312,
238
    MENUEX = 313,
239
    MENUITEM = 314,
240
    SEPARATOR = 315,
241
    POPUP = 316,
242
    CHECKED = 317,
243
    GRAYED = 318,
244
    HELP = 319,
245
    INACTIVE = 320,
246
    OWNERDRAW = 321,
247
    MENUBARBREAK = 322,
248
    MENUBREAK = 323,
249
    MESSAGETABLE = 324,
250
    RCDATA = 325,
251
    STRINGTABLE = 326,
252
    VERSIONINFO = 327,
253
    FILEVERSION = 328,
254
    PRODUCTVERSION = 329,
255
    FILEFLAGSMASK = 330,
256
    FILEFLAGS = 331,
257
    FILEOS = 332,
258
    FILETYPE = 333,
259
    FILESUBTYPE = 334,
260
    BLOCKSTRINGFILEINFO = 335,
261
    BLOCKVARFILEINFO = 336,
262
    VALUE = 337,
263
    BLOCK = 338,
264
    MOVEABLE = 339,
265
    FIXED = 340,
266
    PURE = 341,
267
    IMPURE = 342,
268
    PRELOAD = 343,
269
    LOADONCALL = 344,
270
    DISCARDABLE = 345,
271
    NOT = 346,
272
    QUOTEDUNISTRING = 347,
273
    QUOTEDSTRING = 348,
274
    STRING = 349,
275
    NUMBER = 350,
276
    SIZEDUNISTRING = 351,
277
    SIZEDSTRING = 352,
278
    IGNORED_TOKEN = 353,
279
    NEG = 354
280
  };
281
#endif
282
/* Tokens.  */
283
#define BEG 258
284
#define END 259
285
#define ACCELERATORS 260
286
#define VIRTKEY 261
287
#define ASCII 262
288
#define NOINVERT 263
289
#define SHIFT 264
290
#define CONTROL 265
291
#define ALT 266
292
#define BITMAP 267
293
#define CURSOR 268
294
#define DIALOG 269
295
#define DIALOGEX 270
296
#define EXSTYLE 271
297
#define CAPTION 272
298
#define CLASS 273
299
#define STYLE 274
300
#define AUTO3STATE 275
301
#define AUTOCHECKBOX 276
302
#define AUTORADIOBUTTON 277
303
#define CHECKBOX 278
304
#define COMBOBOX 279
305
#define CTEXT 280
306
#define DEFPUSHBUTTON 281
307
#define EDITTEXT 282
308
#define GROUPBOX 283
309
#define LISTBOX 284
310
#define LTEXT 285
311
#define PUSHBOX 286
312
#define PUSHBUTTON 287
313
#define RADIOBUTTON 288
314
#define RTEXT 289
315
#define SCROLLBAR 290
316
#define STATE3 291
317
#define USERBUTTON 292
318
#define BEDIT 293
319
#define HEDIT 294
320
#define IEDIT 295
321
#define FONT 296
322
#define ICON 297
323
#define ANICURSOR 298
324
#define ANIICON 299
325
#define DLGINCLUDE 300
326
#define DLGINIT 301
327
#define FONTDIR 302
328
#define HTML 303
329
#define MANIFEST 304
330
#define PLUGPLAY 305
331
#define VXD 306
332
#define TOOLBAR 307
333
#define BUTTON 308
334
#define LANGUAGE 309
335
#define CHARACTERISTICS 310
336
#define VERSIONK 311
337
#define MENU 312
338
#define MENUEX 313
339
#define MENUITEM 314
340
#define SEPARATOR 315
341
#define POPUP 316
342
#define CHECKED 317
343
#define GRAYED 318
344
#define HELP 319
345
#define INACTIVE 320
346
#define OWNERDRAW 321
347
#define MENUBARBREAK 322
348
#define MENUBREAK 323
349
#define MESSAGETABLE 324
350
#define RCDATA 325
351
#define STRINGTABLE 326
352
#define VERSIONINFO 327
353
#define FILEVERSION 328
354
#define PRODUCTVERSION 329
355
#define FILEFLAGSMASK 330
356
#define FILEFLAGS 331
357
#define FILEOS 332
358
#define FILETYPE 333
359
#define FILESUBTYPE 334
360
#define BLOCKSTRINGFILEINFO 335
361
#define BLOCKVARFILEINFO 336
362
#define VALUE 337
363
#define BLOCK 338
364
#define MOVEABLE 339
365
#define FIXED 340
366
#define PURE 341
367
#define IMPURE 342
368
#define PRELOAD 343
369
#define LOADONCALL 344
370
#define DISCARDABLE 345
371
#define NOT 346
372
#define QUOTEDUNISTRING 347
373
#define QUOTEDSTRING 348
374
#define STRING 349
375
#define NUMBER 350
376
#define SIZEDUNISTRING 351
377
#define SIZEDSTRING 352
378
#define IGNORED_TOKEN 353
379
#define NEG 354
380
381
/* Value type.  */
382
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
383
union YYSTYPE
384
{
385
#line 68 "rcparse.y"
386
387
  rc_accelerator acc;
388
  rc_accelerator *pacc;
389
  rc_dialog_control *dialog_control;
390
  rc_menuitem *menuitem;
391
  struct
392
  {
393
    rc_rcdata_item *first;
394
    rc_rcdata_item *last;
395
  } rcdata;
396
  rc_rcdata_item *rcdata_item;
397
  rc_fixed_versioninfo *fixver;
398
  rc_ver_info *verinfo;
399
  rc_ver_stringtable *verstringtable;
400
  rc_ver_stringinfo *verstring;
401
  rc_ver_varinfo *vervar;
402
  rc_toolbar_item *toobar_item;
403
  rc_res_id id;
404
  rc_res_res_info res_info;
405
  struct
406
  {
407
    rc_uint_type on;
408
    rc_uint_type off;
409
  } memflags;
410
  struct
411
  {
412
    rc_uint_type val;
413
    /* Nonzero if this number was explicitly specified as long.  */
414
    int dword;
415
  } i;
416
  rc_uint_type il;
417
  rc_uint_type is;
418
  const char *s;
419
  struct
420
  {
421
    rc_uint_type length;
422
    const char *s;
423
  } ss;
424
  unichar *uni;
425
  struct
426
  {
427
    rc_uint_type length;
428
    const unichar *s;
429
  } suni;
430
431
#line 432 "rcparse.c"
432
433
};
434
typedef union YYSTYPE YYSTYPE;
435
# define YYSTYPE_IS_TRIVIAL 1
436
# define YYSTYPE_IS_DECLARED 1
437
#endif
438
439
440
extern YYSTYPE yylval;
441
442
int yyparse (void);
443
444
#endif /* !YY_YY_RCPARSE_H_INCLUDED  */
445
446
447
448
#ifdef short
449
# undef short
450
#endif
451
452
/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
453
   <limits.h> and (if available) <stdint.h> are included
454
   so that the code can choose integer types of a good width.  */
455
456
#ifndef __PTRDIFF_MAX__
457
# include <limits.h> /* INFRINGES ON USER NAME SPACE */
458
# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
459
#  include <stdint.h> /* INFRINGES ON USER NAME SPACE */
460
#  define YY_STDINT_H
461
# endif
462
#endif
463
464
/* Narrow types that promote to a signed type and that can represent a
465
   signed or unsigned integer of at least N bits.  In tables they can
466
   save space and decrease cache pressure.  Promoting to a signed type
467
   helps avoid bugs in integer arithmetic.  */
468
469
#ifdef __INT_LEAST8_MAX__
470
typedef __INT_LEAST8_TYPE__ yytype_int8;
471
#elif defined YY_STDINT_H
472
typedef int_least8_t yytype_int8;
473
#else
474
typedef signed char yytype_int8;
475
#endif
476
477
#ifdef __INT_LEAST16_MAX__
478
typedef __INT_LEAST16_TYPE__ yytype_int16;
479
#elif defined YY_STDINT_H
480
typedef int_least16_t yytype_int16;
481
#else
482
typedef short yytype_int16;
483
#endif
484
485
#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
486
typedef __UINT_LEAST8_TYPE__ yytype_uint8;
487
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
488
       && UINT_LEAST8_MAX <= INT_MAX)
489
typedef uint_least8_t yytype_uint8;
490
#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
491
typedef unsigned char yytype_uint8;
492
#else
493
typedef short yytype_uint8;
494
#endif
495
496
#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
497
typedef __UINT_LEAST16_TYPE__ yytype_uint16;
498
#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
499
       && UINT_LEAST16_MAX <= INT_MAX)
500
typedef uint_least16_t yytype_uint16;
501
#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
502
typedef unsigned short yytype_uint16;
503
#else
504
typedef int yytype_uint16;
505
#endif
506
507
#ifndef YYPTRDIFF_T
508
# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
509
#  define YYPTRDIFF_T __PTRDIFF_TYPE__
510
#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
511
# elif defined PTRDIFF_MAX
512
#  ifndef ptrdiff_t
513
#   include <stddef.h> /* INFRINGES ON USER NAME SPACE */
514
#  endif
515
#  define YYPTRDIFF_T ptrdiff_t
516
#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
517
# else
518
#  define YYPTRDIFF_T long
519
#  define YYPTRDIFF_MAXIMUM LONG_MAX
520
# endif
521
#endif
522
523
#ifndef YYSIZE_T
524
# ifdef __SIZE_TYPE__
525
#  define YYSIZE_T __SIZE_TYPE__
526
# elif defined size_t
527
#  define YYSIZE_T size_t
528
# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
529
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
530
#  define YYSIZE_T size_t
531
# else
532
#  define YYSIZE_T unsigned
533
# endif
534
#endif
535
536
#define YYSIZE_MAXIMUM                                  \
537
  YY_CAST (YYPTRDIFF_T,                                 \
538
           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
539
            ? YYPTRDIFF_MAXIMUM                         \
540
            : YY_CAST (YYSIZE_T, -1)))
541
542
#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
543
544
/* Stored state numbers (used for stacks). */
545
typedef yytype_int16 yy_state_t;
546
547
/* State numbers in computations.  */
548
typedef int yy_state_fast_t;
549
550
#ifndef YY_
551
# if defined YYENABLE_NLS && YYENABLE_NLS
552
#  if ENABLE_NLS
553
#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
554
#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
555
#  endif
556
# endif
557
# ifndef YY_
558
#  define YY_(Msgid) Msgid
559
# endif
560
#endif
561
562
#ifndef YY_ATTRIBUTE_PURE
563
# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
564
#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
565
# else
566
#  define YY_ATTRIBUTE_PURE
567
# endif
568
#endif
569
570
#ifndef YY_ATTRIBUTE_UNUSED
571
# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
572
#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
573
# else
574
#  define YY_ATTRIBUTE_UNUSED
575
# endif
576
#endif
577
578
/* Suppress unused-variable warnings by "using" E.  */
579
#if ! defined lint || defined __GNUC__
580
0
# define YYUSE(E) ((void) (E))
581
#else
582
# define YYUSE(E) /* empty */
583
#endif
584
585
#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
586
/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
587
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                            \
588
    _Pragma ("GCC diagnostic push")                                     \
589
    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
590
    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
591
# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
592
    _Pragma ("GCC diagnostic pop")
593
#else
594
# define YY_INITIAL_VALUE(Value) Value
595
#endif
596
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
597
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
598
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
599
#endif
600
#ifndef YY_INITIAL_VALUE
601
# define YY_INITIAL_VALUE(Value) /* Nothing. */
602
#endif
603
604
#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
605
# define YY_IGNORE_USELESS_CAST_BEGIN                          \
606
    _Pragma ("GCC diagnostic push")                            \
607
    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
608
# define YY_IGNORE_USELESS_CAST_END            \
609
    _Pragma ("GCC diagnostic pop")
610
#endif
611
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
612
# define YY_IGNORE_USELESS_CAST_BEGIN
613
# define YY_IGNORE_USELESS_CAST_END
614
#endif
615
616
617
#define YY_ASSERT(E) ((void) (0 && (E)))
618
619
#if ! defined yyoverflow || YYERROR_VERBOSE
620
621
/* The parser invokes alloca or malloc; define the necessary symbols.  */
622
623
# ifdef YYSTACK_USE_ALLOCA
624
#  if YYSTACK_USE_ALLOCA
625
#   ifdef __GNUC__
626
#    define YYSTACK_ALLOC __builtin_alloca
627
#   elif defined __BUILTIN_VA_ARG_INCR
628
#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
629
#   elif defined _AIX
630
#    define YYSTACK_ALLOC __alloca
631
#   elif defined _MSC_VER
632
#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
633
#    define alloca _alloca
634
#   else
635
#    define YYSTACK_ALLOC alloca
636
#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
637
#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
638
      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
639
#     ifndef EXIT_SUCCESS
640
#      define EXIT_SUCCESS 0
641
#     endif
642
#    endif
643
#   endif
644
#  endif
645
# endif
646
647
# ifdef YYSTACK_ALLOC
648
   /* Pacify GCC's 'empty if-body' warning.  */
649
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
650
#  ifndef YYSTACK_ALLOC_MAXIMUM
651
    /* The OS might guarantee only one guard page at the bottom of the stack,
652
       and a page size can be as small as 4096 bytes.  So we cannot safely
653
       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
654
       to allow for a few compiler-allocated temporary stack slots.  */
655
#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
656
#  endif
657
# else
658
#  define YYSTACK_ALLOC YYMALLOC
659
#  define YYSTACK_FREE YYFREE
660
#  ifndef YYSTACK_ALLOC_MAXIMUM
661
#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
662
#  endif
663
#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
664
       && ! ((defined YYMALLOC || defined malloc) \
665
             && (defined YYFREE || defined free)))
666
#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
667
#   ifndef EXIT_SUCCESS
668
#    define EXIT_SUCCESS 0
669
#   endif
670
#  endif
671
#  ifndef YYMALLOC
672
#   define YYMALLOC malloc
673
#   if ! defined malloc && ! defined EXIT_SUCCESS
674
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
675
#   endif
676
#  endif
677
#  ifndef YYFREE
678
#   define YYFREE free
679
#   if ! defined free && ! defined EXIT_SUCCESS
680
void free (void *); /* INFRINGES ON USER NAME SPACE */
681
#   endif
682
#  endif
683
# endif
684
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
685
686
687
#if (! defined yyoverflow \
688
     && (! defined __cplusplus \
689
         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
690
691
/* A type that is properly aligned for any stack member.  */
692
union yyalloc
693
{
694
  yy_state_t yyss_alloc;
695
  YYSTYPE yyvs_alloc;
696
};
697
698
/* The size of the maximum gap between one aligned stack and the next.  */
699
# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
700
701
/* The size of an array large to enough to hold all stacks, each with
702
   N elements.  */
703
# define YYSTACK_BYTES(N) \
704
     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
705
      + YYSTACK_GAP_MAXIMUM)
706
707
# define YYCOPY_NEEDED 1
708
709
/* Relocate STACK from its old location to the new one.  The
710
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
711
   elements in the stack, and YYPTR gives the new location of the
712
   stack.  Advance YYPTR to a properly aligned location for the next
713
   stack.  */
714
# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
715
    do                                                                  \
716
      {                                                                 \
717
        YYPTRDIFF_T yynewbytes;                                         \
718
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
719
        Stack = &yyptr->Stack_alloc;                                    \
720
        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
721
        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
722
      }                                                                 \
723
    while (0)
724
725
#endif
726
727
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
728
/* Copy COUNT objects from SRC to DST.  The source and destination do
729
   not overlap.  */
730
# ifndef YYCOPY
731
#  if defined __GNUC__ && 1 < __GNUC__
732
#   define YYCOPY(Dst, Src, Count) \
733
      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
734
#  else
735
#   define YYCOPY(Dst, Src, Count)              \
736
      do                                        \
737
        {                                       \
738
          YYPTRDIFF_T yyi;                      \
739
          for (yyi = 0; yyi < (Count); yyi++)   \
740
            (Dst)[yyi] = (Src)[yyi];            \
741
        }                                       \
742
      while (0)
743
#  endif
744
# endif
745
#endif /* !YYCOPY_NEEDED */
746
747
/* YYFINAL -- State number of the termination state.  */
748
#define YYFINAL  2
749
/* YYLAST -- Last index in YYTABLE.  */
750
#define YYLAST   842
751
752
/* YYNTOKENS -- Number of terminals.  */
753
#define YYNTOKENS  113
754
/* YYNNTS -- Number of nonterminals.  */
755
#define YYNNTS  102
756
/* YYNRULES -- Number of rules.  */
757
#define YYNRULES  278
758
/* YYNSTATES -- Number of states.  */
759
#define YYNSTATES  522
760
761
#define YYUNDEFTOK  2
762
#define YYMAXUTOK   354
763
764
765
/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
766
   as returned by yylex, with out-of-bounds checking.  */
767
#define YYTRANSLATE(YYX)                                                \
768
  (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
769
770
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
771
   as returned by yylex.  */
772
static const yytype_int8 yytranslate[] =
773
{
774
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
775
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
776
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
777
       2,     2,     2,     2,     2,     2,     2,   106,   101,     2,
778
     111,   112,   104,   102,   109,   103,     2,   105,     2,     2,
779
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
780
       2,   110,     2,     2,     2,     2,     2,     2,     2,     2,
781
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
782
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
783
       2,     2,     2,     2,   100,     2,     2,     2,     2,     2,
784
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
785
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
786
       2,     2,     2,     2,    99,     2,   107,     2,     2,     2,
787
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
788
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
789
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
790
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
791
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
792
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
793
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
794
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
795
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
796
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
797
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
798
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
799
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
800
       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
801
      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
802
      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
803
      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
804
      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
805
      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
806
      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
807
      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
808
      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
809
      95,    96,    97,    98,   108
810
};
811
812
#if YYDEBUG
813
  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
814
static const yytype_int16 yyrline[] =
815
{
816
       0,   178,   178,   180,   181,   182,   183,   184,   185,   186,
817
     187,   188,   189,   190,   191,   192,   193,   194,   200,   211,
818
     214,   235,   240,   252,   272,   282,   286,   291,   298,   302,
819
     307,   311,   315,   319,   328,   340,   354,   352,   379,   377,
820
     406,   404,   436,   439,   445,   447,   453,   457,   462,   466,
821
     470,   483,   498,   513,   528,   532,   536,   540,   546,   548,
822
     560,   559,   572,   571,   584,   583,   596,   595,   611,   610,
823
     623,   622,   636,   647,   657,   656,   669,   668,   681,   680,
824
     693,   692,   705,   704,   719,   724,   730,   736,   743,   742,
825
     758,   757,   770,   769,   782,   781,   793,   792,   805,   804,
826
     817,   816,   829,   828,   841,   840,   854,   852,   873,   884,
827
     895,   907,   918,   921,   925,   930,   940,   943,   953,   952,
828
     959,   958,   965,   964,   972,   984,   997,  1006,  1017,  1020,
829
    1037,  1041,  1045,  1053,  1056,  1060,  1067,  1071,  1075,  1079,
830
    1083,  1087,  1091,  1095,  1104,  1115,  1118,  1135,  1139,  1143,
831
    1147,  1151,  1155,  1159,  1163,  1173,  1186,  1186,  1198,  1202,
832
    1209,  1217,  1225,  1233,  1242,  1251,  1260,  1270,  1269,  1274,
833
    1276,  1281,  1286,  1294,  1298,  1303,  1308,  1313,  1318,  1323,
834
    1328,  1333,  1338,  1349,  1356,  1366,  1372,  1373,  1392,  1417,
835
    1428,  1433,  1440,  1447,  1452,  1457,  1462,  1467,  1482,  1485,
836
    1489,  1497,  1500,  1508,  1511,  1519,  1522,  1531,  1536,  1545,
837
    1549,  1559,  1564,  1568,  1579,  1585,  1591,  1596,  1601,  1612,
838
    1617,  1629,  1634,  1646,  1651,  1656,  1661,  1666,  1671,  1676,
839
    1686,  1690,  1698,  1703,  1718,  1722,  1731,  1735,  1747,  1752,
840
    1768,  1772,  1784,  1788,  1810,  1814,  1818,  1822,  1829,  1833,
841
    1843,  1846,  1855,  1864,  1873,  1877,  1881,  1886,  1891,  1896,
842
    1901,  1906,  1911,  1916,  1921,  1926,  1937,  1946,  1957,  1961,
843
    1965,  1970,  1975,  1980,  1986,  1991,  1996,  2001,  2006
844
};
845
#endif
846
847
#if YYDEBUG || YYERROR_VERBOSE || 0
848
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
849
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
850
static const char *const yytname[] =
851
{
852
  "$end", "error", "$undefined", "BEG", "END", "ACCELERATORS", "VIRTKEY",
853
  "ASCII", "NOINVERT", "SHIFT", "CONTROL", "ALT", "BITMAP", "CURSOR",
854
  "DIALOG", "DIALOGEX", "EXSTYLE", "CAPTION", "CLASS", "STYLE",
855
  "AUTO3STATE", "AUTOCHECKBOX", "AUTORADIOBUTTON", "CHECKBOX", "COMBOBOX",
856
  "CTEXT", "DEFPUSHBUTTON", "EDITTEXT", "GROUPBOX", "LISTBOX", "LTEXT",
857
  "PUSHBOX", "PUSHBUTTON", "RADIOBUTTON", "RTEXT", "SCROLLBAR", "STATE3",
858
  "USERBUTTON", "BEDIT", "HEDIT", "IEDIT", "FONT", "ICON", "ANICURSOR",
859
  "ANIICON", "DLGINCLUDE", "DLGINIT", "FONTDIR", "HTML", "MANIFEST",
860
  "PLUGPLAY", "VXD", "TOOLBAR", "BUTTON", "LANGUAGE", "CHARACTERISTICS",
861
  "VERSIONK", "MENU", "MENUEX", "MENUITEM", "SEPARATOR", "POPUP",
862
  "CHECKED", "GRAYED", "HELP", "INACTIVE", "OWNERDRAW", "MENUBARBREAK",
863
  "MENUBREAK", "MESSAGETABLE", "RCDATA", "STRINGTABLE", "VERSIONINFO",
864
  "FILEVERSION", "PRODUCTVERSION", "FILEFLAGSMASK", "FILEFLAGS", "FILEOS",
865
  "FILETYPE", "FILESUBTYPE", "BLOCKSTRINGFILEINFO", "BLOCKVARFILEINFO",
866
  "VALUE", "BLOCK", "MOVEABLE", "FIXED", "PURE", "IMPURE", "PRELOAD",
867
  "LOADONCALL", "DISCARDABLE", "NOT", "QUOTEDUNISTRING", "QUOTEDSTRING",
868
  "STRING", "NUMBER", "SIZEDUNISTRING", "SIZEDSTRING", "IGNORED_TOKEN",
869
  "'|'", "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'", "'~'", "NEG",
870
  "','", "'='", "'('", "')'", "$accept", "input", "accelerator",
871
  "acc_entries", "acc_entry", "acc_event", "acc_options", "acc_option",
872
  "bitmap", "cursor", "dialog", "$@1", "$@2", "$@3", "exstyle", "styles",
873
  "controls", "control", "$@4", "$@5", "$@6", "$@7", "$@8", "$@9", "$@10",
874
  "$@11", "$@12", "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19",
875
  "$@20", "$@21", "$@22", "$@23", "$@24", "control_params", "cresid",
876
  "optresidc", "resid", "opt_control_data", "control_styleexpr", "$@25",
877
  "icon_styleexpr", "$@26", "control_params_styleexpr", "$@27", "font",
878
  "icon", "language", "menu", "menuitems", "menuitem", "menuitem_flags",
879
  "menuitem_flag", "menuex", "menuexitems", "menuexitem", "messagetable",
880
  "optrcdata_data", "$@28", "optrcdata_data_int", "rcdata_data",
881
  "stringtable", "$@29", "string_data", "rcdata_id", "user", "toolbar",
882
  "toolbar_data", "versioninfo", "fixedverinfo", "verblocks",
883
  "verstringtables", "vervals", "vertrans", "id", "resname", "resref",
884
  "suboptions", "memflags_move_discard", "memflags_move", "memflag",
885
  "file_name", "res_unicode_string_concat", "res_unicode_string",
886
  "res_unicode_sizedstring", "res_unicode_sizedstring_concat",
887
  "sizedstring", "sizedunistring", "styleexpr", "parennumber",
888
  "optcnumexpr", "cnumexpr", "numexpr", "sizednumexpr", "cposnumexpr",
889
  "posnumexpr", "sizedposnumexpr", YY_NULLPTR
890
};
891
#endif
892
893
# ifdef YYPRINT
894
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
895
   (internal) symbol number NUM (which must be that of a token).  */
896
static const yytype_int16 yytoknum[] =
897
{
898
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
899
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
900
     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
901
     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
902
     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
903
     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
904
     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
905
     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
906
     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
907
     345,   346,   347,   348,   349,   350,   351,   352,   353,   124,
908
      94,    38,    43,    45,    42,    47,    37,   126,   354,    44,
909
      61,    40,    41
910
};
911
# endif
912
913
#define YYPACT_NINF (-328)
914
915
#define yypact_value_is_default(Yyn) \
916
  ((Yyn) == YYPACT_NINF)
917
918
#define YYTABLE_NINF (-233)
919
920
#define yytable_value_is_error(Yyn) \
921
  0
922
923
  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
924
     STATE-NUM.  */
925
static const yytype_int16 yypact[] =
926
{
927
    -328,    74,  -328,   302,  -328,  -328,  -328,  -328,  -328,  -328,
928
     302,   302,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,
929
    -328,  -328,  -328,  -328,  -328,  -328,   465,  -328,  -328,  -328,
930
     513,  -328,   302,   302,   302,   -80,   583,   209,  -328,   654,
931
    -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,
932
    -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,
933
    -328,  -328,  -328,   302,   302,   302,   302,   302,   302,   302,
934
     302,  -328,  -328,   703,   302,  -328,   302,   302,   302,   302,
935
     302,   302,   302,   302,  -328,   302,   302,   302,  -328,  -328,
936
    -328,  -328,  -328,  -328,  -328,  -328,  -328,   258,   732,   732,
937
     405,   405,   732,   732,   443,   265,   338,   732,   287,   190,
938
     619,   234,   327,   181,   181,  -328,  -328,  -328,  -328,  -328,
939
     619,   234,   327,   181,   181,  -328,  -328,  -328,  -328,   -80,
940
    -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,   -76,
941
     104,   104,  -328,  -328,   -80,  -328,  -328,  -328,  -328,   302,
942
     302,   302,   302,   302,   302,   302,  -328,  -328,    18,  -328,
943
      23,   302,   -80,   -80,    94,   155,   169,    -1,   -80,   -80,
944
    -328,  -328,  -328,  -328,  -328,   133,   498,  -328,  -328,   -32,
945
    -328,  -328,  -328,    56,  -328,  -328,   -80,   -80,  -328,  -328,
946
     -50,   -17,  -328,  -328,   -25,   -17,  -328,  -328,   132,   171,
947
     -80,  -328,   -80,  -328,  -328,  -328,  -328,    75,    90,    99,
948
     583,    -9,  -328,    -9,    90,    99,   104,    81,   -80,   -80,
949
      13,  -328,    70,  -328,   -17,  -328,    70,    30,  -328,   118,
950
     -80,   -80,   498,  -328,  -328,    -9,  -328,  -328,   831,  -328,
951
     -80,  -328,   360,  -328,  -328,  -328,   141,   -80,  -328,     1,
952
      28,   -17,  -328,  -328,    90,    99,   583,  -328,  -328,  -328,
953
    -328,  -328,  -328,    45,  -328,  -328,  -328,  -328,  -328,   158,
954
    -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,   500,
955
    -328,   -80,   174,  -328,     6,  -328,   198,   -17,   831,  -328,
956
     485,   566,  -328,   178,  -328,  -328,  -328,   179,  -328,   -80,
957
    -328,     3,  -328,  -328,   302,   -17,   360,   -67,   302,   302,
958
     302,   302,   360,  -328,   570,  -328,  -328,   182,   210,    16,
959
    -328,   -80,   634,  -328,   -17,  -328,   -17,    49,   -33,  -328,
960
     302,   143,  -328,   139,   -80,  -328,  -328,  -328,   671,  -328,
961
    -328,  -328,  -328,   -17,  -328,  -328,   389,   389,   389,   389,
962
     389,  -328,   389,   389,  -328,   389,  -328,   389,   389,   389,
963
     389,   389,  -328,   389,   360,   389,   389,   389,   360,  -328,
964
    -328,   137,    80,   -17,  -328,  -328,   708,   194,   164,   302,
965
     150,   -17,  -328,  -328,  -328,  -328,  -328,   302,  -328,  -328,
966
     302,  -328,   302,  -328,  -328,  -328,  -328,  -328,   302,  -328,
967
     151,   302,   160,  -328,  -328,  -328,   302,  -328,   -33,  -328,
968
      70,  -328,  -328,   -17,   161,  -328,   302,   302,   302,   302,
969
    -328,   -80,   302,   302,  -328,   302,  -328,   302,   302,   302,
970
     302,   302,  -328,   302,  -328,   163,  -328,   302,   302,   302,
971
     -80,  -328,   -80,   -17,   389,   172,  -328,  -328,  -328,  -328,
972
     -80,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,
973
     302,  -328,  -328,  -328,   -80,   -80,  -328,  -328,   -80,   -80,
974
     180,    10,  -328,   -67,   -80,   -80,   302,  -328,  -328,   -80,
975
     143,   -80,    15,   191,   298,    22,   -80,  -328,  -328,   -80,
976
     302,  -328,  -328,  -328,   -80,   -80,   -67,   300,   -80,   200,
977
     -67,   300,   -80,   300,   -80,   143,  -328,   300,   302,   143,
978
    -328,   300,  -328,   300,  -328,   201,  -328,  -328,  -328,   -67,
979
     -52,  -328
980
};
981
982
  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
983
     Performed when YYTABLE does not specify something else to do.  Zero
984
     means the default is an error.  */
985
static const yytype_int16 yydefact[] =
986
{
987
       2,     0,     1,     0,   214,   234,   235,   210,   268,    17,
988
       0,     0,     3,     4,     5,     6,     7,     8,     9,    10,
989
      11,    12,    13,    15,    14,    16,     0,   208,   209,   207,
990
     267,   254,     0,     0,     0,     0,   253,     0,   270,     0,
991
     214,   221,   219,   221,   221,   219,   219,   181,   182,   179,
992
     180,   174,   176,   177,   178,   214,   214,   214,   221,   175,
993
     190,   214,   173,     0,     0,     0,     0,     0,     0,     0,
994
       0,   257,   256,     0,     0,   126,     0,     0,     0,     0,
995
       0,     0,     0,     0,   167,     0,     0,     0,   223,   224,
996
     225,   226,   227,   228,   229,   215,   269,     0,     0,     0,
997
      42,    42,     0,     0,     0,     0,     0,     0,     0,     0,
998
     278,   277,   276,   274,   275,   271,   272,   273,   255,   252,
999
     265,   264,   263,   261,   262,   258,   259,   260,   169,     0,
1000
     216,   218,    19,   230,   231,   222,    34,   220,    35,     0,
1001
       0,     0,   124,   125,     0,   128,   145,   155,   198,     0,
1002
       0,     0,     0,     0,     0,     0,   156,   184,     0,   217,
1003
       0,     0,     0,     0,     0,     0,     0,     0,   250,   250,
1004
     193,   194,   195,   196,   197,     0,   158,   172,   168,     0,
1005
      18,    23,    20,     0,    24,    43,     0,     0,   186,   127,
1006
       0,     0,   129,   144,     0,     0,   146,   189,     0,     0,
1007
     250,   251,   250,   183,   242,   240,   157,   159,   160,   161,
1008
     162,     0,   238,   170,   237,   236,     0,    21,     0,     0,
1009
       0,   131,     0,   232,   133,   150,   147,     0,   201,     0,
1010
     250,   250,   166,   241,   243,   171,   239,   266,     0,    36,
1011
      38,   185,     0,   188,   233,   133,     0,   148,   145,     0,
1012
       0,     0,   191,   192,   163,   164,   165,    28,    29,    30,
1013
      31,    32,    33,    22,    25,    44,    44,    40,   187,   130,
1014
     128,   142,   136,   137,   138,   139,   143,   140,   141,     0,
1015
     135,   250,     0,   145,     0,   199,     0,   205,     0,    27,
1016
       0,     0,    44,     0,   134,   149,   151,     0,   145,   250,
1017
     203,     0,    26,    58,     0,     0,     0,     0,     0,     0,
1018
       0,     0,     0,    58,     0,   132,   152,     0,     0,     0,
1019
     200,     0,     0,    48,    45,    46,    49,   209,     0,   248,
1020
       0,    47,   244,     0,     0,    55,    57,    54,     0,    58,
1021
     153,   145,   202,     0,   206,    37,   112,   112,   112,   112,
1022
     112,    70,   112,   112,    78,   112,    90,   112,   112,   112,
1023
     112,   112,   102,   112,     0,   112,   112,   112,     0,    59,
1024
     245,     0,     0,     0,    56,    39,     0,     0,     0,     0,
1025
       0,   115,   114,    60,    62,    64,    68,     0,    74,    76,
1026
       0,    80,     0,    92,    94,    96,    98,   100,     0,   104,
1027
     212,     0,     0,    66,    82,    88,     0,   249,     0,   246,
1028
      50,    41,   154,     0,     0,   113,     0,     0,     0,     0,
1029
      71,     0,     0,     0,    79,     0,    91,     0,     0,     0,
1030
       0,     0,   103,     0,   213,     0,   211,     0,     0,     0,
1031
       0,   247,    51,   204,     0,     0,    61,    63,    65,    69,
1032
       0,    75,    77,    81,    93,    95,    97,    99,   101,   105,
1033
       0,    67,    83,    89,     0,    52,   111,   118,     0,     0,
1034
       0,   116,    53,     0,     0,     0,     0,   156,    84,     0,
1035
     119,     0,   116,     0,     0,   116,     0,   122,   108,   250,
1036
       0,   117,   120,    85,   250,   250,     0,   116,   251,     0,
1037
       0,   116,   251,   116,   251,   123,   109,   116,     0,   121,
1038
      86,   116,    72,   116,   110,     0,    87,    73,   106,     0,
1039
     250,   107
1040
};
1041
1042
  /* YYPGOTO[NTERM-NUM].  */
1043
static const yytype_int16 yypgoto[] =
1044
{
1045
    -328,  -328,  -328,  -328,  -328,  -328,  -328,  -225,  -328,  -328,
1046
    -328,  -328,  -328,  -328,   214,  -252,  -290,  -328,  -328,  -328,
1047
    -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,
1048
    -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,   212,
1049
    -328,   434,  -128,   267,  -328,  -328,  -328,  -328,  -328,  -328,
1050
    -328,  -328,  -328,  -328,    48,  -328,    77,    44,  -328,  -198,
1051
    -328,  -328,  -153,  -328,  -328,  -328,  -328,  -328,  -328,  -328,
1052
    -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,  -328,   -24,
1053
    -228,   -43,   345,   131,   208,   729,   268,  -179,     5,  -187,
1054
     119,  -146,  -115,  -101,  -327,  -161,   -30,    -3,    26,  -328,
1055
      20,  -328
1056
};
1057
1058
  /* YYDEFGOTO[NTERM-NUM].  */
1059
static const yytype_int16 yydefgoto[] =
1060
{
1061
      -1,     1,    12,   160,   182,   183,   263,   264,    13,    14,
1062
      15,   265,   266,   292,   140,   290,   322,   369,   416,   417,
1063
     418,   437,   419,   387,   422,   423,   390,   425,   438,   439,
1064
     392,   427,   428,   429,   430,   431,   398,   433,   519,   420,
1065
     445,   379,   380,   478,   468,   473,   494,   500,   489,   496,
1066
      16,    17,    18,    19,   165,   192,   246,   280,    20,   166,
1067
     196,    21,   175,   176,   206,   207,    22,   128,   158,    61,
1068
      23,    24,   220,    25,   108,   167,   250,   319,   301,    26,
1069
      27,   401,    37,    99,    98,    95,   136,   381,   223,   212,
1070
     213,   214,   215,   331,   332,   200,   201,   421,    36,   217,
1071
     382,    30
1072
};
1073
1074
  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
1075
     positive, shift that token.  If negative, reduce the rule whose
1076
     number is the opposite.  If YYTABLE_NINF, syntax error.  */
1077
static const yytype_int16 yytable[] =
1078
{
1079
      35,   370,    62,   197,   283,    75,    28,   320,   202,   298,
1080
     221,   222,   224,   477,   291,   226,   227,   241,   477,   177,
1081
     342,    29,   178,   338,   328,   477,   236,   180,   329,    74,
1082
     208,    28,   285,   248,   161,   225,    38,    39,   289,   230,
1083
     314,   231,     5,     6,   330,   409,    29,   372,   236,   376,
1084
     282,   257,   258,   259,   260,   261,   262,    74,    71,    72,
1085
      73,   209,   329,   302,   204,   205,   242,     5,     6,   252,
1086
     253,   119,   287,   243,     2,     5,     6,   211,   330,   198,
1087
     199,   441,   129,   130,   131,   297,   254,   204,   205,   110,
1088
     111,   112,   113,   114,   115,   116,   117,   188,   343,   159,
1089
     317,   144,   120,   121,   122,   123,   124,   125,   126,   127,
1090
      74,   286,    74,    31,   164,    74,   181,   255,     8,    74,
1091
     295,    32,     5,     6,   487,    33,   324,   326,     3,    34,
1092
      10,   492,   186,   187,    11,   228,   400,   203,   318,    74,
1093
     400,  -232,  -232,   377,   270,     4,   168,   169,   170,   171,
1094
     172,   173,   174,   271,   288,   179,   218,   219,   185,   189,
1095
     162,   163,     5,     6,   378,   216,     5,     6,     7,     8,
1096
     271,   408,     9,   193,   229,   329,   102,   103,   296,    74,
1097
     184,    10,   315,   316,   232,    11,   340,   233,   239,   240,
1098
     238,   330,   245,   156,   410,   234,   247,   249,   412,     8,
1099
     251,   300,   210,   272,   273,   274,   275,   276,   277,   278,
1100
     267,    10,    84,   341,   190,    11,   191,   281,   268,   284,
1101
     272,   273,   274,   275,   276,   277,   278,   244,   194,   244,
1102
     195,   244,   244,   194,   443,   195,   237,   190,   194,   191,
1103
     195,   194,   372,   195,    85,    86,    87,    28,   373,   407,
1104
     279,   100,   101,   194,   299,   195,     5,     6,   256,   415,
1105
     434,   132,    29,    85,    86,    87,   107,   279,   145,   436,
1106
     444,   321,   460,   413,    88,    89,    90,    91,    92,    93,
1107
      94,   467,   325,   133,   134,    81,    82,    83,   337,   476,
1108
     148,   344,   244,    88,    89,    90,    91,    92,    93,    94,
1109
     490,   323,   491,   477,   374,   333,   334,   335,   336,   508,
1110
     518,   327,    85,    86,    87,   141,   466,    28,   293,    85,
1111
      86,    87,   269,   294,   484,   406,    29,   371,   497,   244,
1112
     235,   244,    29,   501,   503,    78,    79,    80,    81,    82,
1113
      83,   146,    88,    89,    90,    91,    92,    93,    94,    88,
1114
      89,    90,    91,    92,    93,    94,     0,     0,     0,   521,
1115
     149,   150,   151,   152,   153,   154,   155,   138,     0,    28,
1116
     142,   143,   480,    28,     0,   147,   414,   157,     0,     0,
1117
     442,     0,     0,   244,   402,    97,   244,     0,   402,     0,
1118
       0,   450,    85,    86,    87,   505,     0,    31,   435,   509,
1119
     104,   105,   106,   440,     0,    32,   109,     0,     0,    33,
1120
     464,     0,   465,    34,     0,   244,     0,     0,   520,     0,
1121
     469,   139,    88,    89,    90,    91,    92,    93,    94,    79,
1122
      80,    81,    82,    83,   471,   472,     0,     0,   474,   475,
1123
       0,   479,     0,     0,   481,   482,     0,     0,   244,   485,
1124
       0,   486,     5,     6,     7,     8,   495,   470,     0,   498,
1125
       0,     0,     0,     0,   502,   504,     0,    10,   507,     0,
1126
      40,    11,   511,   483,   513,     0,     0,    41,    42,    43,
1127
      44,     5,     6,     0,     8,     0,     0,   499,   303,    88,
1128
      89,    90,    91,    92,    93,    94,    10,    85,    86,    87,
1129
      11,   304,   305,   306,   307,   515,    45,    46,    47,    48,
1130
      49,    50,   271,    51,    52,    53,    54,    55,     0,     0,
1131
       0,     0,    56,    57,     0,     0,   308,    88,    89,    90,
1132
      91,    92,    93,    94,    58,    59,     0,    60,    31,   309,
1133
     310,   311,   312,     0,     0,     0,    32,     0,     0,     0,
1134
      33,     0,     0,     0,    34,     0,     0,     5,     6,     7,
1135
       8,     0,   272,   273,   274,   275,   276,   277,   278,   313,
1136
       0,     0,    10,   339,     0,     0,    11,     0,     0,     0,
1137
       0,     0,   304,   305,   306,   307,   304,   305,   306,   307,
1138
       0,     0,     0,    31,   204,   205,     0,     0,     0,     0,
1139
       0,    32,   424,     0,   426,    33,     0,   308,     0,    34,
1140
     432,   308,    63,    64,    65,    66,    67,    68,    69,    70,
1141
     309,   310,   311,   312,   309,   310,   311,   312,   446,   447,
1142
     448,   449,     0,     0,   451,   452,     0,   453,   345,   454,
1143
     455,   456,   457,   458,   346,   459,     0,     0,     0,   461,
1144
     462,   463,     0,     0,   347,   348,   349,   350,   351,   352,
1145
     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
1146
     363,   364,   365,   366,   367,   375,   368,     0,     0,     0,
1147
       0,   346,    76,    77,    78,    79,    80,    81,    82,    83,
1148
       0,   347,   348,   349,   350,   351,   352,   353,   354,   355,
1149
     356,   357,   358,   359,   360,   361,   362,   363,   364,   365,
1150
     366,   367,   411,   368,     0,     0,     0,     0,   346,    77,
1151
      78,    79,    80,    81,    82,    83,     0,     0,   347,   348,
1152
     349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
1153
     359,   360,   361,   362,   363,   364,   365,   366,   367,   488,
1154
     368,     0,   493,    76,    77,    78,    79,    80,    81,    82,
1155
      83,     0,     0,     0,   506,     0,    96,     0,   510,     0,
1156
     512,     0,     0,     0,   514,     0,     0,     0,   516,     0,
1157
     517,   383,   384,   385,   386,     0,   388,   389,     0,   391,
1158
       0,   393,   394,   395,   396,   397,     0,   399,     0,   403,
1159
     404,   405,    76,    77,    78,    79,    80,    81,    82,    83,
1160
       0,     0,     0,     0,     0,   118,    88,    89,    90,    91,
1161
      92,    93,    94,     0,     0,   133,   134,   135,   137,   135,
1162
     135,   137,   137,     0,     0,     0,   135,   257,   258,   259,
1163
     260,   261,   262
1164
};
1165
1166
static const yytype_int16 yycheck[] =
1167
{
1168
       3,   328,    26,     4,     3,    35,     1,     4,   169,     3,
1169
      60,   190,   191,     3,   266,   194,   195,     4,     3,     1,
1170
       4,     1,     4,   313,    91,     3,   213,     4,    95,   109,
1171
     176,    26,     4,     3,   110,    60,    10,    11,   263,   200,
1172
     292,   202,    92,    93,   111,   372,    26,    99,   235,   339,
1173
     248,     6,     7,     8,     9,    10,    11,   109,    32,    33,
1174
      34,   176,    95,   288,    96,    97,    53,    92,    93,   230,
1175
     231,    74,   251,    60,     0,    92,    93,   109,   111,    80,
1176
      81,   408,    85,    86,    87,   283,   232,    96,    97,    63,
1177
      64,    65,    66,    67,    68,    69,    70,     3,    82,   129,
1178
     298,   104,    76,    77,    78,    79,    80,    81,    82,    83,
1179
     109,    83,   109,    95,   144,   109,    93,   232,    95,   109,
1180
     281,   103,    92,    93,   109,   107,   305,   306,    54,   111,
1181
     107,   109,   162,   163,   111,     3,   364,     4,   299,   109,
1182
     368,    92,    93,   341,     3,    71,   149,   150,   151,   152,
1183
     153,   154,   155,    12,   109,   158,   186,   187,   161,     4,
1184
     140,   141,    92,    93,   343,   109,    92,    93,    94,    95,
1185
      12,    91,    98,     4,     3,    95,    45,    46,     4,   109,
1186
     160,   107,     4,     4,   109,   111,     4,    97,   218,   219,
1187
     109,   111,   222,     3,   373,    96,   226,   227,     4,    95,
1188
      82,     3,   176,    62,    63,    64,    65,    66,    67,    68,
1189
     240,   107,     3,     3,    59,   111,    61,   247,   242,   249,
1190
      62,    63,    64,    65,    66,    67,    68,   222,    59,   224,
1191
      61,   226,   227,    59,   413,    61,   216,    59,    59,    61,
1192
      61,    59,    99,    61,    54,    55,    56,   242,   109,   112,
1193
     109,    43,    44,    59,   284,    61,    92,    93,   232,   109,
1194
     109,     3,   242,    54,    55,    56,    58,   109,     3,   109,
1195
     109,   301,   109,   109,    84,    85,    86,    87,    88,    89,
1196
      90,   109,   306,    93,    94,   104,   105,   106,   312,   109,
1197
       3,   321,   287,    84,    85,    86,    87,    88,    89,    90,
1198
     109,   304,     4,     3,   334,   308,   309,   310,   311,   109,
1199
     109,   306,    54,    55,    56,   101,   444,   312,   270,    54,
1200
      55,    56,   245,   279,   477,   368,   306,   330,   489,   324,
1201
     211,   326,   312,   494,   495,   101,   102,   103,   104,   105,
1202
     106,     3,    84,    85,    86,    87,    88,    89,    90,    84,
1203
      85,    86,    87,    88,    89,    90,    -1,    -1,    -1,   520,
1204
      73,    74,    75,    76,    77,    78,    79,    99,    -1,   364,
1205
     102,   103,   473,   368,    -1,   107,   379,   109,    -1,    -1,
1206
     410,    -1,    -1,   378,   364,    40,   381,    -1,   368,    -1,
1207
      -1,   421,    54,    55,    56,   496,    -1,    95,   401,   500,
1208
      55,    56,    57,   406,    -1,   103,    61,    -1,    -1,   107,
1209
     440,    -1,   442,   111,    -1,   410,    -1,    -1,   519,    -1,
1210
     450,    16,    84,    85,    86,    87,    88,    89,    90,   102,
1211
     103,   104,   105,   106,   464,   465,    -1,    -1,   468,   469,
1212
      -1,   471,    -1,    -1,   474,   475,    -1,    -1,   443,   479,
1213
      -1,   481,    92,    93,    94,    95,   486,   460,    -1,   489,
1214
      -1,    -1,    -1,    -1,   494,   495,    -1,   107,   498,    -1,
1215
       5,   111,   502,   476,   504,    -1,    -1,    12,    13,    14,
1216
      15,    92,    93,    -1,    95,    -1,    -1,   490,     3,    84,
1217
      85,    86,    87,    88,    89,    90,   107,    54,    55,    56,
1218
     111,    16,    17,    18,    19,   508,    41,    42,    43,    44,
1219
      45,    46,    12,    48,    49,    50,    51,    52,    -1,    -1,
1220
      -1,    -1,    57,    58,    -1,    -1,    41,    84,    85,    86,
1221
      87,    88,    89,    90,    69,    70,    -1,    72,    95,    54,
1222
      55,    56,    57,    -1,    -1,    -1,   103,    -1,    -1,    -1,
1223
     107,    -1,    -1,    -1,   111,    -1,    -1,    92,    93,    94,
1224
      95,    -1,    62,    63,    64,    65,    66,    67,    68,     3,
1225
      -1,    -1,   107,     3,    -1,    -1,   111,    -1,    -1,    -1,
1226
      -1,    -1,    16,    17,    18,    19,    16,    17,    18,    19,
1227
      -1,    -1,    -1,    95,    96,    97,    -1,    -1,    -1,    -1,
1228
      -1,   103,   390,    -1,   392,   107,    -1,    41,    -1,   111,
1229
     398,    41,    99,   100,   101,   102,   103,   104,   105,   106,
1230
      54,    55,    56,    57,    54,    55,    56,    57,   416,   417,
1231
     418,   419,    -1,    -1,   422,   423,    -1,   425,     4,   427,
1232
     428,   429,   430,   431,    10,   433,    -1,    -1,    -1,   437,
1233
     438,   439,    -1,    -1,    20,    21,    22,    23,    24,    25,
1234
      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
1235
      36,    37,    38,    39,    40,     4,    42,    -1,    -1,    -1,
1236
      -1,    10,    99,   100,   101,   102,   103,   104,   105,   106,
1237
      -1,    20,    21,    22,    23,    24,    25,    26,    27,    28,
1238
      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
1239
      39,    40,     4,    42,    -1,    -1,    -1,    -1,    10,   100,
1240
     101,   102,   103,   104,   105,   106,    -1,    -1,    20,    21,
1241
      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
1242
      32,    33,    34,    35,    36,    37,    38,    39,    40,   482,
1243
      42,    -1,   485,    99,   100,   101,   102,   103,   104,   105,
1244
     106,    -1,    -1,    -1,   497,    -1,   112,    -1,   501,    -1,
1245
     503,    -1,    -1,    -1,   507,    -1,    -1,    -1,   511,    -1,
1246
     513,   347,   348,   349,   350,    -1,   352,   353,    -1,   355,
1247
      -1,   357,   358,   359,   360,   361,    -1,   363,    -1,   365,
1248
     366,   367,    99,   100,   101,   102,   103,   104,   105,   106,
1249
      -1,    -1,    -1,    -1,    -1,   112,    84,    85,    86,    87,
1250
      88,    89,    90,    -1,    -1,    93,    94,    98,    99,   100,
1251
     101,   102,   103,    -1,    -1,    -1,   107,     6,     7,     8,
1252
       9,    10,    11
1253
};
1254
1255
  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1256
     symbol of state STATE-NUM.  */
1257
static const yytype_uint8 yystos[] =
1258
{
1259
       0,   114,     0,    54,    71,    92,    93,    94,    95,    98,
1260
     107,   111,   115,   121,   122,   123,   163,   164,   165,   166,
1261
     171,   174,   179,   183,   184,   186,   192,   193,   201,   213,
1262
     214,    95,   103,   107,   111,   210,   211,   195,   211,   211,
1263
       5,    12,    13,    14,    15,    41,    42,    43,    44,    45,
1264
      46,    48,    49,    50,    51,    52,    57,    58,    69,    70,
1265
      72,   182,   192,    99,   100,   101,   102,   103,   104,   105,
1266
     106,   211,   211,   211,   109,   209,    99,   100,   101,   102,
1267
     103,   104,   105,   106,     3,    54,    55,    56,    84,    85,
1268
      86,    87,    88,    89,    90,   198,   112,   195,   197,   196,
1269
     197,   197,   196,   196,   195,   195,   195,   197,   187,   195,
1270
     211,   211,   211,   211,   211,   211,   211,   211,   112,   210,
1271
     211,   211,   211,   211,   211,   211,   211,   211,   180,   210,
1272
     210,   210,     3,    93,    94,   198,   199,   198,   199,    16,
1273
     127,   127,   199,   199,   210,     3,     3,   199,     3,    73,
1274
      74,    75,    76,    77,    78,    79,     3,   199,   181,   209,
1275
     116,   110,   213,   213,   209,   167,   172,   188,   210,   210,
1276
     210,   210,   210,   210,   210,   175,   176,     1,     4,   210,
1277
       4,    93,   117,   118,   213,   210,   209,   209,     3,     4,
1278
      59,    61,   168,     4,    59,    61,   173,     4,    80,    81,
1279
     208,   209,   208,     4,    96,    97,   177,   178,   204,   205,
1280
     211,   109,   202,   203,   204,   205,   109,   212,   209,   209,
1281
     185,    60,   200,   201,   200,    60,   200,   200,     3,     3,
1282
     208,   208,   109,    97,    96,   203,   202,   213,   109,   209,
1283
     209,     4,    53,    60,   201,   209,   169,   209,     3,   209,
1284
     189,    82,   208,   208,   204,   205,   211,     6,     7,     8,
1285
       9,    10,    11,   119,   120,   124,   125,   209,   192,   169,
1286
       3,    12,    62,    63,    64,    65,    66,    67,    68,   109,
1287
     170,   209,   172,     3,   209,     4,    83,   200,   109,   120,
1288
     128,   128,   126,   167,   170,   208,     4,   172,     3,   209,
1289
       3,   191,   120,     3,    16,    17,    18,    19,    41,    54,
1290
      55,    56,    57,     3,   128,     4,     4,   172,   208,   190,
1291
       4,   209,   129,   210,   200,   192,   200,   201,    91,    95,
1292
     111,   206,   207,   210,   210,   210,   210,   192,   129,     3,
1293
       4,     3,     4,    82,   209,     4,    10,    20,    21,    22,
1294
      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
1295
      33,    34,    35,    36,    37,    38,    39,    40,    42,   130,
1296
     207,   210,    99,   109,   209,     4,   129,   172,   200,   154,
1297
     155,   200,   213,   154,   154,   154,   154,   136,   154,   154,
1298
     139,   154,   143,   154,   154,   154,   154,   154,   149,   154,
1299
     193,   194,   213,   154,   154,   154,   194,   112,    91,   207,
1300
     200,     4,     4,   109,   210,   109,   131,   132,   133,   135,
1301
     152,   210,   137,   138,   152,   140,   152,   144,   145,   146,
1302
     147,   148,   152,   150,   109,   210,   109,   134,   141,   142,
1303
     210,   207,   209,   200,   109,   153,   152,   152,   152,   152,
1304
     209,   152,   152,   152,   152,   152,   152,   152,   152,   152,
1305
     109,   152,   152,   152,   209,   209,   155,   109,   157,   209,
1306
     210,   209,   209,   158,   209,   209,   109,     3,   156,   209,
1307
     206,   209,   209,   210,   175,   209,   209,   109,   156,   161,
1308
     109,     4,   109,   156,   159,   209,   162,   208,   209,   210,
1309
     160,   208,   209,   208,   209,   206,   156,   209,   109,   206,
1310
     156,   209,   156,   209,   156,   210,   156,   156,   109,   151,
1311
     206,   208
1312
};
1313
1314
  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1315
static const yytype_uint8 yyr1[] =
1316
{
1317
       0,   113,   114,   114,   114,   114,   114,   114,   114,   114,
1318
     114,   114,   114,   114,   114,   114,   114,   114,   115,   116,
1319
     116,   117,   117,   118,   118,   119,   119,   119,   120,   120,
1320
     120,   120,   120,   120,   121,   122,   124,   123,   125,   123,
1321
     126,   123,   127,   127,   128,   128,   128,   128,   128,   128,
1322
     128,   128,   128,   128,   128,   128,   128,   128,   129,   129,
1323
     131,   130,   132,   130,   133,   130,   134,   130,   135,   130,
1324
     136,   130,   130,   130,   137,   130,   138,   130,   139,   130,
1325
     140,   130,   141,   130,   130,   130,   130,   130,   142,   130,
1326
     143,   130,   144,   130,   145,   130,   146,   130,   147,   130,
1327
     148,   130,   149,   130,   150,   130,   151,   130,   152,   152,
1328
     152,   153,   154,   154,   155,   155,   156,   156,   158,   157,
1329
     160,   159,   162,   161,   163,   164,   165,   166,   167,   167,
1330
     168,   168,   168,   169,   169,   169,   170,   170,   170,   170,
1331
     170,   170,   170,   170,   171,   172,   172,   173,   173,   173,
1332
     173,   173,   173,   173,   173,   174,   176,   175,   177,   177,
1333
     178,   178,   178,   178,   178,   178,   178,   180,   179,   181,
1334
     181,   181,   181,   182,   182,   182,   182,   182,   182,   182,
1335
     182,   182,   182,   183,   183,   184,   185,   185,   185,   186,
1336
     187,   187,   187,   187,   187,   187,   187,   187,   188,   188,
1337
     188,   189,   189,   190,   190,   191,   191,   192,   192,   193,
1338
     193,   194,   194,   194,   195,   195,   195,   195,   195,   196,
1339
     196,   197,   197,   198,   198,   198,   198,   198,   198,   198,
1340
     199,   199,   200,   200,   201,   201,   202,   202,   203,   203,
1341
     204,   204,   205,   205,   206,   206,   206,   206,   207,   207,
1342
     208,   208,   209,   210,   211,   211,   211,   211,   211,   211,
1343
     211,   211,   211,   211,   211,   211,   212,   213,   214,   214,
1344
     214,   214,   214,   214,   214,   214,   214,   214,   214
1345
};
1346
1347
  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
1348
static const yytype_int8 yyr2[] =
1349
{
1350
       0,     2,     0,     2,     2,     2,     2,     2,     2,     2,
1351
       2,     2,     2,     2,     2,     2,     2,     2,     6,     0,
1352
       2,     2,     4,     1,     1,     1,     3,     2,     1,     1,
1353
       1,     1,     1,     1,     4,     4,     0,    13,     0,    13,
1354
       0,    14,     0,     3,     0,     3,     3,     3,     3,     3,
1355
       5,     6,     7,     8,     3,     3,     4,     3,     0,     2,
1356
       0,     4,     0,     4,     0,     4,     0,     4,     0,     4,
1357
       0,     3,    11,    12,     0,     4,     0,     4,     0,     3,
1358
       0,     4,     0,     4,     6,     8,    10,    11,     0,     4,
1359
       0,     3,     0,     4,     0,     4,     0,     4,     0,     4,
1360
       0,     4,     0,     3,     0,     4,     0,    15,     6,     8,
1361
       9,     2,     0,     2,     1,     1,     0,     3,     0,     3,
1362
       0,     3,     0,     3,     4,     4,     3,     6,     0,     2,
1363
       4,     2,     6,     0,     3,     2,     1,     1,     1,     1,
1364
       1,     1,     1,     1,     6,     0,     2,     2,     3,     5,
1365
       2,     5,     6,     7,     9,     4,     0,     2,     0,     1,
1366
       1,     1,     1,     3,     3,     3,     2,     0,     6,     0,
1367
       3,     4,     2,     1,     1,     1,     1,     1,     1,     1,
1368
       1,     1,     1,     6,     4,     8,     0,     3,     2,     6,
1369
       0,     6,     6,     3,     3,     3,     3,     3,     0,     5,
1370
       7,     0,     5,     0,     5,     0,     3,     1,     1,     1,
1371
       1,     2,     1,     2,     0,     2,     3,     4,     3,     0,
1372
       2,     0,     2,     1,     1,     1,     1,     1,     1,     1,
1373
       1,     1,     1,     2,     1,     1,     1,     1,     1,     2,
1374
       1,     2,     1,     2,     1,     2,     3,     4,     1,     3,
1375
       0,     1,     2,     1,     1,     3,     2,     2,     3,     3,
1376
       3,     3,     3,     3,     3,     3,     2,     1,     1,     3,
1377
       2,     3,     3,     3,     3,     3,     3,     3,     3
1378
};
1379
1380
1381
#define yyerrok         (yyerrstatus = 0)
1382
#define yyclearin       (yychar = YYEMPTY)
1383
#define YYEMPTY         (-2)
1384
#define YYEOF           0
1385
1386
#define YYACCEPT        goto yyacceptlab
1387
#define YYABORT         goto yyabortlab
1388
#define YYERROR         goto yyerrorlab
1389
1390
1391
#define YYRECOVERING()  (!!yyerrstatus)
1392
1393
#define YYBACKUP(Token, Value)                                    \
1394
  do                                                              \
1395
    if (yychar == YYEMPTY)                                        \
1396
      {                                                           \
1397
        yychar = (Token);                                         \
1398
        yylval = (Value);                                         \
1399
        YYPOPSTACK (yylen);                                       \
1400
        yystate = *yyssp;                                         \
1401
        goto yybackup;                                            \
1402
      }                                                           \
1403
    else                                                          \
1404
      {                                                           \
1405
        yyerror (YY_("syntax error: cannot back up")); \
1406
        YYERROR;                                                  \
1407
      }                                                           \
1408
  while (0)
1409
1410
/* Error token number */
1411
#define YYTERROR        1
1412
#define YYERRCODE       256
1413
1414
1415
1416
/* Enable debugging if requested.  */
1417
#if YYDEBUG
1418
1419
# ifndef YYFPRINTF
1420
#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1421
#  define YYFPRINTF fprintf
1422
# endif
1423
1424
# define YYDPRINTF(Args)                        \
1425
do {                                            \
1426
  if (yydebug)                                  \
1427
    YYFPRINTF Args;                             \
1428
} while (0)
1429
1430
/* This macro is provided for backward compatibility. */
1431
#ifndef YY_LOCATION_PRINT
1432
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1433
#endif
1434
1435
1436
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
1437
do {                                                                      \
1438
  if (yydebug)                                                            \
1439
    {                                                                     \
1440
      YYFPRINTF (stderr, "%s ", Title);                                   \
1441
      yy_symbol_print (stderr,                                            \
1442
                  Type, Value); \
1443
      YYFPRINTF (stderr, "\n");                                           \
1444
    }                                                                     \
1445
} while (0)
1446
1447
1448
/*-----------------------------------.
1449
| Print this symbol's value on YYO.  |
1450
`-----------------------------------*/
1451
1452
static void
1453
yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
1454
{
1455
  FILE *yyoutput = yyo;
1456
  YYUSE (yyoutput);
1457
  if (!yyvaluep)
1458
    return;
1459
# ifdef YYPRINT
1460
  if (yytype < YYNTOKENS)
1461
    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
1462
# endif
1463
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1464
  YYUSE (yytype);
1465
  YY_IGNORE_MAYBE_UNINITIALIZED_END
1466
}
1467
1468
1469
/*---------------------------.
1470
| Print this symbol on YYO.  |
1471
`---------------------------*/
1472
1473
static void
1474
yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
1475
{
1476
  YYFPRINTF (yyo, "%s %s (",
1477
             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1478
1479
  yy_symbol_value_print (yyo, yytype, yyvaluep);
1480
  YYFPRINTF (yyo, ")");
1481
}
1482
1483
/*------------------------------------------------------------------.
1484
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1485
| TOP (included).                                                   |
1486
`------------------------------------------------------------------*/
1487
1488
static void
1489
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
1490
{
1491
  YYFPRINTF (stderr, "Stack now");
1492
  for (; yybottom <= yytop; yybottom++)
1493
    {
1494
      int yybot = *yybottom;
1495
      YYFPRINTF (stderr, " %d", yybot);
1496
    }
1497
  YYFPRINTF (stderr, "\n");
1498
}
1499
1500
# define YY_STACK_PRINT(Bottom, Top)                            \
1501
do {                                                            \
1502
  if (yydebug)                                                  \
1503
    yy_stack_print ((Bottom), (Top));                           \
1504
} while (0)
1505
1506
1507
/*------------------------------------------------.
1508
| Report that the YYRULE is going to be reduced.  |
1509
`------------------------------------------------*/
1510
1511
static void
1512
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
1513
{
1514
  int yylno = yyrline[yyrule];
1515
  int yynrhs = yyr2[yyrule];
1516
  int yyi;
1517
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1518
             yyrule - 1, yylno);
1519
  /* The symbols being reduced.  */
1520
  for (yyi = 0; yyi < yynrhs; yyi++)
1521
    {
1522
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
1523
      yy_symbol_print (stderr,
1524
                       yystos[+yyssp[yyi + 1 - yynrhs]],
1525
                       &yyvsp[(yyi + 1) - (yynrhs)]
1526
                                              );
1527
      YYFPRINTF (stderr, "\n");
1528
    }
1529
}
1530
1531
# define YY_REDUCE_PRINT(Rule)          \
1532
do {                                    \
1533
  if (yydebug)                          \
1534
    yy_reduce_print (yyssp, yyvsp, Rule); \
1535
} while (0)
1536
1537
/* Nonzero means print parse trace.  It is left uninitialized so that
1538
   multiple parsers can coexist.  */
1539
int yydebug;
1540
#else /* !YYDEBUG */
1541
# define YYDPRINTF(Args)
1542
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1543
# define YY_STACK_PRINT(Bottom, Top)
1544
# define YY_REDUCE_PRINT(Rule)
1545
#endif /* !YYDEBUG */
1546
1547
1548
/* YYINITDEPTH -- initial size of the parser's stacks.  */
1549
#ifndef YYINITDEPTH
1550
# define YYINITDEPTH 200
1551
#endif
1552
1553
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1554
   if the built-in stack extension method is used).
1555
1556
   Do not make this value too large; the results are undefined if
1557
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1558
   evaluated with infinite-precision integer arithmetic.  */
1559
1560
#ifndef YYMAXDEPTH
1561
# define YYMAXDEPTH 10000
1562
#endif
1563
1564
1565
#if YYERROR_VERBOSE
1566
1567
# ifndef yystrlen
1568
#  if defined __GLIBC__ && defined _STRING_H
1569
#   define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
1570
#  else
1571
/* Return the length of YYSTR.  */
1572
static YYPTRDIFF_T
1573
yystrlen (const char *yystr)
1574
{
1575
  YYPTRDIFF_T yylen;
1576
  for (yylen = 0; yystr[yylen]; yylen++)
1577
    continue;
1578
  return yylen;
1579
}
1580
#  endif
1581
# endif
1582
1583
# ifndef yystpcpy
1584
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1585
#   define yystpcpy stpcpy
1586
#  else
1587
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1588
   YYDEST.  */
1589
static char *
1590
yystpcpy (char *yydest, const char *yysrc)
1591
{
1592
  char *yyd = yydest;
1593
  const char *yys = yysrc;
1594
1595
  while ((*yyd++ = *yys++) != '\0')
1596
    continue;
1597
1598
  return yyd - 1;
1599
}
1600
#  endif
1601
# endif
1602
1603
# ifndef yytnamerr
1604
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1605
   quotes and backslashes, so that it's suitable for yyerror.  The
1606
   heuristic is that double-quoting is unnecessary unless the string
1607
   contains an apostrophe, a comma, or backslash (other than
1608
   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1609
   null, do not copy; instead, return the length of what the result
1610
   would have been.  */
1611
static YYPTRDIFF_T
1612
yytnamerr (char *yyres, const char *yystr)
1613
{
1614
  if (*yystr == '"')
1615
    {
1616
      YYPTRDIFF_T yyn = 0;
1617
      char const *yyp = yystr;
1618
1619
      for (;;)
1620
        switch (*++yyp)
1621
          {
1622
          case '\'':
1623
          case ',':
1624
            goto do_not_strip_quotes;
1625
1626
          case '\\':
1627
            if (*++yyp != '\\')
1628
              goto do_not_strip_quotes;
1629
            else
1630
              goto append;
1631
1632
          append:
1633
          default:
1634
            if (yyres)
1635
              yyres[yyn] = *yyp;
1636
            yyn++;
1637
            break;
1638
1639
          case '"':
1640
            if (yyres)
1641
              yyres[yyn] = '\0';
1642
            return yyn;
1643
          }
1644
    do_not_strip_quotes: ;
1645
    }
1646
1647
  if (yyres)
1648
    return yystpcpy (yyres, yystr) - yyres;
1649
  else
1650
    return yystrlen (yystr);
1651
}
1652
# endif
1653
1654
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1655
   about the unexpected token YYTOKEN for the state stack whose top is
1656
   YYSSP.
1657
1658
   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
1659
   not large enough to hold the message.  In that case, also set
1660
   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
1661
   required number of bytes is too large to store.  */
1662
static int
1663
yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
1664
                yy_state_t *yyssp, int yytoken)
1665
{
1666
  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1667
  /* Internationalized format string. */
1668
  const char *yyformat = YY_NULLPTR;
1669
  /* Arguments of yyformat: reported tokens (one for the "unexpected",
1670
     one per "expected"). */
1671
  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1672
  /* Actual size of YYARG. */
1673
  int yycount = 0;
1674
  /* Cumulated lengths of YYARG.  */
1675
  YYPTRDIFF_T yysize = 0;
1676
1677
  /* There are many possibilities here to consider:
1678
     - If this state is a consistent state with a default action, then
1679
       the only way this function was invoked is if the default action
1680
       is an error action.  In that case, don't check for expected
1681
       tokens because there are none.
1682
     - The only way there can be no lookahead present (in yychar) is if
1683
       this state is a consistent state with a default action.  Thus,
1684
       detecting the absence of a lookahead is sufficient to determine
1685
       that there is no unexpected or expected token to report.  In that
1686
       case, just report a simple "syntax error".
1687
     - Don't assume there isn't a lookahead just because this state is a
1688
       consistent state with a default action.  There might have been a
1689
       previous inconsistent state, consistent state with a non-default
1690
       action, or user semantic action that manipulated yychar.
1691
     - Of course, the expected token list depends on states to have
1692
       correct lookahead information, and it depends on the parser not
1693
       to perform extra reductions after fetching a lookahead from the
1694
       scanner and before detecting a syntax error.  Thus, state merging
1695
       (from LALR or IELR) and default reductions corrupt the expected
1696
       token list.  However, the list is correct for canonical LR with
1697
       one exception: it will still contain any token that will not be
1698
       accepted due to an error action in a later state.
1699
  */
1700
  if (yytoken != YYEMPTY)
1701
    {
1702
      int yyn = yypact[+*yyssp];
1703
      YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1704
      yysize = yysize0;
1705
      yyarg[yycount++] = yytname[yytoken];
1706
      if (!yypact_value_is_default (yyn))
1707
        {
1708
          /* Start YYX at -YYN if negative to avoid negative indexes in
1709
             YYCHECK.  In other words, skip the first -YYN actions for
1710
             this state because they are default actions.  */
1711
          int yyxbegin = yyn < 0 ? -yyn : 0;
1712
          /* Stay within bounds of both yycheck and yytname.  */
1713
          int yychecklim = YYLAST - yyn + 1;
1714
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1715
          int yyx;
1716
1717
          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1718
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1719
                && !yytable_value_is_error (yytable[yyx + yyn]))
1720
              {
1721
                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1722
                  {
1723
                    yycount = 1;
1724
                    yysize = yysize0;
1725
                    break;
1726
                  }
1727
                yyarg[yycount++] = yytname[yyx];
1728
                {
1729
                  YYPTRDIFF_T yysize1
1730
                    = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1731
                  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1732
                    yysize = yysize1;
1733
                  else
1734
                    return 2;
1735
                }
1736
              }
1737
        }
1738
    }
1739
1740
  switch (yycount)
1741
    {
1742
# define YYCASE_(N, S)                      \
1743
      case N:                               \
1744
        yyformat = S;                       \
1745
      break
1746
    default: /* Avoid compiler warnings. */
1747
      YYCASE_(0, YY_("syntax error"));
1748
      YYCASE_(1, YY_("syntax error, unexpected %s"));
1749
      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1750
      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1751
      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1752
      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1753
# undef YYCASE_
1754
    }
1755
1756
  {
1757
    /* Don't count the "%s"s in the final size, but reserve room for
1758
       the terminator.  */
1759
    YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
1760
    if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1761
      yysize = yysize1;
1762
    else
1763
      return 2;
1764
  }
1765
1766
  if (*yymsg_alloc < yysize)
1767
    {
1768
      *yymsg_alloc = 2 * yysize;
1769
      if (! (yysize <= *yymsg_alloc
1770
             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1771
        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1772
      return 1;
1773
    }
1774
1775
  /* Avoid sprintf, as that infringes on the user's name space.
1776
     Don't have undefined behavior even if the translation
1777
     produced a string with the wrong number of "%s"s.  */
1778
  {
1779
    char *yyp = *yymsg;
1780
    int yyi = 0;
1781
    while ((*yyp = *yyformat) != '\0')
1782
      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1783
        {
1784
          yyp += yytnamerr (yyp, yyarg[yyi++]);
1785
          yyformat += 2;
1786
        }
1787
      else
1788
        {
1789
          ++yyp;
1790
          ++yyformat;
1791
        }
1792
  }
1793
  return 0;
1794
}
1795
#endif /* YYERROR_VERBOSE */
1796
1797
/*-----------------------------------------------.
1798
| Release the memory associated to this symbol.  |
1799
`-----------------------------------------------*/
1800
1801
static void
1802
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1803
0
{
1804
0
  YYUSE (yyvaluep);
1805
0
  if (!yymsg)
1806
0
    yymsg = "Deleting";
1807
0
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1808
1809
0
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1810
0
  YYUSE (yytype);
1811
0
  YY_IGNORE_MAYBE_UNINITIALIZED_END
1812
0
}
1813
1814
1815
1816
1817
/* The lookahead symbol.  */
1818
int yychar;
1819
1820
/* The semantic value of the lookahead symbol.  */
1821
YYSTYPE yylval;
1822
/* Number of syntax errors so far.  */
1823
int yynerrs;
1824
1825
1826
/*----------.
1827
| yyparse.  |
1828
`----------*/
1829
1830
int
1831
yyparse (void)
1832
{
1833
    yy_state_fast_t yystate;
1834
    /* Number of tokens to shift before error messages enabled.  */
1835
    int yyerrstatus;
1836
1837
    /* The stacks and their tools:
1838
       'yyss': related to states.
1839
       'yyvs': related to semantic values.
1840
1841
       Refer to the stacks through separate pointers, to allow yyoverflow
1842
       to reallocate them elsewhere.  */
1843
1844
    /* The state stack.  */
1845
    yy_state_t yyssa[YYINITDEPTH];
1846
    yy_state_t *yyss;
1847
    yy_state_t *yyssp;
1848
1849
    /* The semantic value stack.  */
1850
    YYSTYPE yyvsa[YYINITDEPTH];
1851
    YYSTYPE *yyvs;
1852
    YYSTYPE *yyvsp;
1853
1854
    YYPTRDIFF_T yystacksize;
1855
1856
  int yyn;
1857
  int yyresult;
1858
  /* Lookahead token as an internal (translated) token number.  */
1859
  int yytoken = 0;
1860
  /* The variables used to return semantic value and location from the
1861
     action routines.  */
1862
  YYSTYPE yyval;
1863
1864
#if YYERROR_VERBOSE
1865
  /* Buffer for error messages, and its allocated size.  */
1866
  char yymsgbuf[128];
1867
  char *yymsg = yymsgbuf;
1868
  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
1869
#endif
1870
1871
#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1872
1873
  /* The number of symbols on the RHS of the reduced rule.
1874
     Keep to zero when no symbol should be popped.  */
1875
  int yylen = 0;
1876
1877
  yyssp = yyss = yyssa;
1878
  yyvsp = yyvs = yyvsa;
1879
  yystacksize = YYINITDEPTH;
1880
1881
  YYDPRINTF ((stderr, "Starting parse\n"));
1882
1883
  yystate = 0;
1884
  yyerrstatus = 0;
1885
  yynerrs = 0;
1886
  yychar = YYEMPTY; /* Cause a token to be read.  */
1887
  goto yysetstate;
1888
1889
1890
/*------------------------------------------------------------.
1891
| yynewstate -- push a new state, which is found in yystate.  |
1892
`------------------------------------------------------------*/
1893
yynewstate:
1894
  /* In all cases, when you get here, the value and location stacks
1895
     have just been pushed.  So pushing a state here evens the stacks.  */
1896
  yyssp++;
1897
1898
1899
/*--------------------------------------------------------------------.
1900
| yysetstate -- set current state (the top of the stack) to yystate.  |
1901
`--------------------------------------------------------------------*/
1902
yysetstate:
1903
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1904
  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1905
  YY_IGNORE_USELESS_CAST_BEGIN
1906
  *yyssp = YY_CAST (yy_state_t, yystate);
1907
  YY_IGNORE_USELESS_CAST_END
1908
1909
  if (yyss + yystacksize - 1 <= yyssp)
1910
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
1911
    goto yyexhaustedlab;
1912
#else
1913
    {
1914
      /* Get the current used size of the three stacks, in elements.  */
1915
      YYPTRDIFF_T yysize = yyssp - yyss + 1;
1916
1917
# if defined yyoverflow
1918
      {
1919
        /* Give user a chance to reallocate the stack.  Use copies of
1920
           these so that the &'s don't force the real ones into
1921
           memory.  */
1922
        yy_state_t *yyss1 = yyss;
1923
        YYSTYPE *yyvs1 = yyvs;
1924
1925
        /* Each stack pointer address is followed by the size of the
1926
           data in use in that stack, in bytes.  This used to be a
1927
           conditional around just the two extra args, but that might
1928
           be undefined if yyoverflow is a macro.  */
1929
        yyoverflow (YY_("memory exhausted"),
1930
                    &yyss1, yysize * YYSIZEOF (*yyssp),
1931
                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
1932
                    &yystacksize);
1933
        yyss = yyss1;
1934
        yyvs = yyvs1;
1935
      }
1936
# else /* defined YYSTACK_RELOCATE */
1937
      /* Extend the stack our own way.  */
1938
      if (YYMAXDEPTH <= yystacksize)
1939
        goto yyexhaustedlab;
1940
      yystacksize *= 2;
1941
      if (YYMAXDEPTH < yystacksize)
1942
        yystacksize = YYMAXDEPTH;
1943
1944
      {
1945
        yy_state_t *yyss1 = yyss;
1946
        union yyalloc *yyptr =
1947
          YY_CAST (union yyalloc *,
1948
                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1949
        if (! yyptr)
1950
          goto yyexhaustedlab;
1951
        YYSTACK_RELOCATE (yyss_alloc, yyss);
1952
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1953
# undef YYSTACK_RELOCATE
1954
        if (yyss1 != yyssa)
1955
          YYSTACK_FREE (yyss1);
1956
      }
1957
# endif
1958
1959
      yyssp = yyss + yysize - 1;
1960
      yyvsp = yyvs + yysize - 1;
1961
1962
      YY_IGNORE_USELESS_CAST_BEGIN
1963
      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1964
                  YY_CAST (long, yystacksize)));
1965
      YY_IGNORE_USELESS_CAST_END
1966
1967
      if (yyss + yystacksize - 1 <= yyssp)
1968
        YYABORT;
1969
    }
1970
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1971
1972
  if (yystate == YYFINAL)
1973
    YYACCEPT;
1974
1975
  goto yybackup;
1976
1977
1978
/*-----------.
1979
| yybackup.  |
1980
`-----------*/
1981
yybackup:
1982
  /* Do appropriate processing given the current state.  Read a
1983
     lookahead token if we need one and don't already have one.  */
1984
1985
  /* First try to decide what to do without reference to lookahead token.  */
1986
  yyn = yypact[yystate];
1987
  if (yypact_value_is_default (yyn))
1988
    goto yydefault;
1989
1990
  /* Not known => get a lookahead token if don't already have one.  */
1991
1992
  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1993
  if (yychar == YYEMPTY)
1994
    {
1995
      YYDPRINTF ((stderr, "Reading a token: "));
1996
      yychar = yylex ();
1997
    }
1998
1999
  if (yychar <= YYEOF)
2000
    {
2001
      yychar = yytoken = YYEOF;
2002
      YYDPRINTF ((stderr, "Now at end of input.\n"));
2003
    }
2004
  else
2005
    {
2006
      yytoken = YYTRANSLATE (yychar);
2007
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2008
    }
2009
2010
  /* If the proper action on seeing token YYTOKEN is to reduce or to
2011
     detect an error, take that action.  */
2012
  yyn += yytoken;
2013
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2014
    goto yydefault;
2015
  yyn = yytable[yyn];
2016
  if (yyn <= 0)
2017
    {
2018
      if (yytable_value_is_error (yyn))
2019
        goto yyerrlab;
2020
      yyn = -yyn;
2021
      goto yyreduce;
2022
    }
2023
2024
  /* Count tokens shifted since error; after three, turn off error
2025
     status.  */
2026
  if (yyerrstatus)
2027
    yyerrstatus--;
2028
2029
  /* Shift the lookahead token.  */
2030
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2031
  yystate = yyn;
2032
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2033
  *++yyvsp = yylval;
2034
  YY_IGNORE_MAYBE_UNINITIALIZED_END
2035
2036
  /* Discard the shifted token.  */
2037
  yychar = YYEMPTY;
2038
  goto yynewstate;
2039
2040
2041
/*-----------------------------------------------------------.
2042
| yydefault -- do the default action for the current state.  |
2043
`-----------------------------------------------------------*/
2044
yydefault:
2045
  yyn = yydefact[yystate];
2046
  if (yyn == 0)
2047
    goto yyerrlab;
2048
  goto yyreduce;
2049
2050
2051
/*-----------------------------.
2052
| yyreduce -- do a reduction.  |
2053
`-----------------------------*/
2054
yyreduce:
2055
  /* yyn is the number of a rule to reduce with.  */
2056
  yylen = yyr2[yyn];
2057
2058
  /* If YYLEN is nonzero, implement the default value of the action:
2059
     '$$ = $1'.
2060
2061
     Otherwise, the following line sets YYVAL to garbage.
2062
     This behavior is undocumented and Bison
2063
     users should not rely upon it.  Assigning to YYVAL
2064
     unconditionally makes the parser a bit smaller, and it avoids a
2065
     GCC warning that YYVAL may be used uninitialized.  */
2066
  yyval = yyvsp[1-yylen];
2067
2068
2069
  YY_REDUCE_PRINT (yyn);
2070
  switch (yyn)
2071
    {
2072
  case 18:
2073
#line 201 "rcparse.y"
2074
          {
2075
      define_accelerator ((yyvsp[-5].id), &(yyvsp[-3].res_info), (yyvsp[-1].pacc));
2076
      if (yychar != YYEMPTY)
2077
        YYERROR;
2078
      rcparse_discard_strings ();
2079
    }
2080
#line 2081 "rcparse.c"
2081
    break;
2082
2083
  case 19:
2084
#line 211 "rcparse.y"
2085
          {
2086
      (yyval.pacc) = NULL;
2087
    }
2088
#line 2089 "rcparse.c"
2089
    break;
2090
2091
  case 20:
2092
#line 215 "rcparse.y"
2093
          {
2094
      rc_accelerator *a;
2095
2096
      a = (rc_accelerator *) res_alloc (sizeof *a);
2097
      *a = (yyvsp[0].acc);
2098
      if ((yyvsp[-1].pacc) == NULL)
2099
        (yyval.pacc) = a;
2100
      else
2101
        {
2102
    rc_accelerator **pp;
2103
2104
    for (pp = &(yyvsp[-1].pacc)->next; *pp != NULL; pp = &(*pp)->next)
2105
      ;
2106
    *pp = a;
2107
    (yyval.pacc) = (yyvsp[-1].pacc);
2108
        }
2109
    }
2110
#line 2111 "rcparse.c"
2111
    break;
2112
2113
  case 21:
2114
#line 236 "rcparse.y"
2115
          {
2116
      (yyval.acc) = (yyvsp[-1].acc);
2117
      (yyval.acc).id = (yyvsp[0].il);
2118
    }
2119
#line 2120 "rcparse.c"
2120
    break;
2121
2122
  case 22:
2123
#line 241 "rcparse.y"
2124
          {
2125
      (yyval.acc) = (yyvsp[-3].acc);
2126
      (yyval.acc).id = (yyvsp[-2].il);
2127
      (yyval.acc).flags |= (yyvsp[0].is);
2128
      if (((yyval.acc).flags & ACC_VIRTKEY) == 0
2129
    && ((yyval.acc).flags & (ACC_SHIFT | ACC_CONTROL)) != 0)
2130
        rcparse_warning (_("inappropriate modifiers for non-VIRTKEY"));
2131
    }
2132
#line 2133 "rcparse.c"
2133
    break;
2134
2135
  case 23:
2136
#line 253 "rcparse.y"
2137
          {
2138
      const char *s = (yyvsp[0].s);
2139
      char ch;
2140
2141
      (yyval.acc).next = NULL;
2142
      (yyval.acc).id = 0;
2143
      ch = *s;
2144
      if (ch != '^')
2145
        (yyval.acc).flags = 0;
2146
      else
2147
        {
2148
    (yyval.acc).flags = ACC_CONTROL | ACC_VIRTKEY;
2149
    ++s;
2150
    ch = TOUPPER (s[0]);
2151
        }
2152
      (yyval.acc).key = ch;
2153
      if (s[1] != '\0')
2154
        rcparse_warning (_("accelerator should only be one character"));
2155
    }
2156
#line 2157 "rcparse.c"
2157
    break;
2158
2159
  case 24:
2160
#line 273 "rcparse.y"
2161
          {
2162
      (yyval.acc).next = NULL;
2163
      (yyval.acc).flags = 0;
2164
      (yyval.acc).id = 0;
2165
      (yyval.acc).key = (yyvsp[0].il);
2166
    }
2167
#line 2168 "rcparse.c"
2168
    break;
2169
2170
  case 25:
2171
#line 283 "rcparse.y"
2172
          {
2173
      (yyval.is) = (yyvsp[0].is);
2174
    }
2175
#line 2176 "rcparse.c"
2176
    break;
2177
2178
  case 26:
2179
#line 287 "rcparse.y"
2180
          {
2181
      (yyval.is) = (yyvsp[-2].is) | (yyvsp[0].is);
2182
    }
2183
#line 2184 "rcparse.c"
2184
    break;
2185
2186
  case 27:
2187
#line 292 "rcparse.y"
2188
          {
2189
      (yyval.is) = (yyvsp[-1].is) | (yyvsp[0].is);
2190
    }
2191
#line 2192 "rcparse.c"
2192
    break;
2193
2194
  case 28:
2195
#line 299 "rcparse.y"
2196
          {
2197
      (yyval.is) = ACC_VIRTKEY;
2198
    }
2199
#line 2200 "rcparse.c"
2200
    break;
2201
2202
  case 29:
2203
#line 303 "rcparse.y"
2204
          {
2205
      /* This is just the absence of VIRTKEY.  */
2206
      (yyval.is) = 0;
2207
    }
2208
#line 2209 "rcparse.c"
2209
    break;
2210
2211
  case 30:
2212
#line 308 "rcparse.y"
2213
          {
2214
      (yyval.is) = ACC_NOINVERT;
2215
    }
2216
#line 2217 "rcparse.c"
2217
    break;
2218
2219
  case 31:
2220
#line 312 "rcparse.y"
2221
          {
2222
      (yyval.is) = ACC_SHIFT;
2223
    }
2224
#line 2225 "rcparse.c"
2225
    break;
2226
2227
  case 32:
2228
#line 316 "rcparse.y"
2229
          {
2230
      (yyval.is) = ACC_CONTROL;
2231
    }
2232
#line 2233 "rcparse.c"
2233
    break;
2234
2235
  case 33:
2236
#line 320 "rcparse.y"
2237
          {
2238
      (yyval.is) = ACC_ALT;
2239
    }
2240
#line 2241 "rcparse.c"
2241
    break;
2242
2243
  case 34:
2244
#line 329 "rcparse.y"
2245
          {
2246
      define_bitmap ((yyvsp[-3].id), &(yyvsp[-1].res_info), (yyvsp[0].s));
2247
      if (yychar != YYEMPTY)
2248
        YYERROR;
2249
      rcparse_discard_strings ();
2250
    }
2251
#line 2252 "rcparse.c"
2252
    break;
2253
2254
  case 35:
2255
#line 341 "rcparse.y"
2256
          {
2257
      define_cursor ((yyvsp[-3].id), &(yyvsp[-1].res_info), (yyvsp[0].s));
2258
      if (yychar != YYEMPTY)
2259
        YYERROR;
2260
      rcparse_discard_strings ();
2261
    }
2262
#line 2263 "rcparse.c"
2263
    break;
2264
2265
  case 36:
2266
#line 354 "rcparse.y"
2267
            {
2268
        memset (&dialog, 0, sizeof dialog);
2269
        dialog.x = (yyvsp[-3].il);
2270
        dialog.y = (yyvsp[-2].il);
2271
        dialog.width = (yyvsp[-1].il);
2272
        dialog.height = (yyvsp[0].il);
2273
        dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
2274
        dialog.exstyle = (yyvsp[-4].il);
2275
        dialog.menu.named = 1;
2276
        dialog.class.named = 1;
2277
        dialog.font = NULL;
2278
        dialog.ex = NULL;
2279
        dialog.controls = NULL;
2280
        sub_res_info = (yyvsp[-5].res_info);
2281
        style = 0;
2282
      }
2283
#line 2284 "rcparse.c"
2284
    break;
2285
2286
  case 37:
2287
#line 371 "rcparse.y"
2288
          {
2289
      define_dialog ((yyvsp[-12].id), &sub_res_info, &dialog);
2290
      if (yychar != YYEMPTY)
2291
        YYERROR;
2292
      rcparse_discard_strings ();
2293
    }
2294
#line 2295 "rcparse.c"
2295
    break;
2296
2297
  case 38:
2298
#line 379 "rcparse.y"
2299
            {
2300
        memset (&dialog, 0, sizeof dialog);
2301
        dialog.x = (yyvsp[-3].il);
2302
        dialog.y = (yyvsp[-2].il);
2303
        dialog.width = (yyvsp[-1].il);
2304
        dialog.height = (yyvsp[0].il);
2305
        dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
2306
        dialog.exstyle = (yyvsp[-4].il);
2307
        dialog.menu.named = 1;
2308
        dialog.class.named = 1;
2309
        dialog.font = NULL;
2310
        dialog.ex = ((rc_dialog_ex *)
2311
         res_alloc (sizeof (rc_dialog_ex)));
2312
        memset (dialog.ex, 0, sizeof (rc_dialog_ex));
2313
        dialog.controls = NULL;
2314
        sub_res_info = (yyvsp[-5].res_info);
2315
        style = 0;
2316
      }
2317
#line 2318 "rcparse.c"
2318
    break;
2319
2320
  case 39:
2321
#line 398 "rcparse.y"
2322
          {
2323
      define_dialog ((yyvsp[-12].id), &sub_res_info, &dialog);
2324
      if (yychar != YYEMPTY)
2325
        YYERROR;
2326
      rcparse_discard_strings ();
2327
    }
2328
#line 2329 "rcparse.c"
2329
    break;
2330
2331
  case 40:
2332
#line 406 "rcparse.y"
2333
            {
2334
        memset (&dialog, 0, sizeof dialog);
2335
        dialog.x = (yyvsp[-4].il);
2336
        dialog.y = (yyvsp[-3].il);
2337
        dialog.width = (yyvsp[-2].il);
2338
        dialog.height = (yyvsp[-1].il);
2339
        dialog.style = WS_POPUP | WS_BORDER | WS_SYSMENU;
2340
        dialog.exstyle = (yyvsp[-5].il);
2341
        dialog.menu.named = 1;
2342
        dialog.class.named = 1;
2343
        dialog.font = NULL;
2344
        dialog.ex = ((rc_dialog_ex *)
2345
         res_alloc (sizeof (rc_dialog_ex)));
2346
        memset (dialog.ex, 0, sizeof (rc_dialog_ex));
2347
        dialog.ex->help = (yyvsp[0].il);
2348
        dialog.controls = NULL;
2349
        sub_res_info = (yyvsp[-6].res_info);
2350
        style = 0;
2351
      }
2352
#line 2353 "rcparse.c"
2353
    break;
2354
2355
  case 41:
2356
#line 426 "rcparse.y"
2357
          {
2358
      define_dialog ((yyvsp[-13].id), &sub_res_info, &dialog);
2359
      if (yychar != YYEMPTY)
2360
        YYERROR;
2361
      rcparse_discard_strings ();
2362
    }
2363
#line 2364 "rcparse.c"
2364
    break;
2365
2366
  case 42:
2367
#line 436 "rcparse.y"
2368
          {
2369
      (yyval.il) = 0;
2370
    }
2371
#line 2372 "rcparse.c"
2372
    break;
2373
2374
  case 43:
2375
#line 440 "rcparse.y"
2376
          {
2377
      (yyval.il) = (yyvsp[0].il);
2378
    }
2379
#line 2380 "rcparse.c"
2380
    break;
2381
2382
  case 45:
2383
#line 448 "rcparse.y"
2384
          {
2385
      dialog.style |= WS_CAPTION;
2386
      style |= WS_CAPTION;
2387
      dialog.caption = (yyvsp[0].uni);
2388
    }
2389
#line 2390 "rcparse.c"
2390
    break;
2391
2392
  case 46:
2393
#line 454 "rcparse.y"
2394
          {
2395
      dialog.class = (yyvsp[0].id);
2396
    }
2397
#line 2398 "rcparse.c"
2398
    break;
2399
2400
  case 47:
2401
#line 459 "rcparse.y"
2402
          {
2403
      dialog.style = style;
2404
    }
2405
#line 2406 "rcparse.c"
2406
    break;
2407
2408
  case 48:
2409
#line 463 "rcparse.y"
2410
          {
2411
      dialog.exstyle = (yyvsp[0].il);
2412
    }
2413
#line 2414 "rcparse.c"
2414
    break;
2415
2416
  case 49:
2417
#line 467 "rcparse.y"
2418
          {
2419
      res_unistring_to_id (& dialog.class, (yyvsp[0].uni));
2420
    }
2421
#line 2422 "rcparse.c"
2422
    break;
2423
2424
  case 50:
2425
#line 471 "rcparse.y"
2426
          {
2427
      dialog.style |= DS_SETFONT;
2428
      style |= DS_SETFONT;
2429
      dialog.pointsize = (yyvsp[-2].il);
2430
      dialog.font = (yyvsp[0].uni);
2431
      if (dialog.ex != NULL)
2432
        {
2433
    dialog.ex->weight = 0;
2434
    dialog.ex->italic = 0;
2435
    dialog.ex->charset = 1;
2436
        }
2437
    }
2438
#line 2439 "rcparse.c"
2439
    break;
2440
2441
  case 51:
2442
#line 484 "rcparse.y"
2443
          {
2444
      dialog.style |= DS_SETFONT;
2445
      style |= DS_SETFONT;
2446
      dialog.pointsize = (yyvsp[-3].il);
2447
      dialog.font = (yyvsp[-1].uni);
2448
      if (dialog.ex == NULL)
2449
        rcparse_warning (_("extended FONT requires DIALOGEX"));
2450
      else
2451
        {
2452
    dialog.ex->weight = (yyvsp[0].il);
2453
    dialog.ex->italic = 0;
2454
    dialog.ex->charset = 1;
2455
        }
2456
    }
2457
#line 2458 "rcparse.c"
2458
    break;
2459
2460
  case 52:
2461
#line 499 "rcparse.y"
2462
          {
2463
      dialog.style |= DS_SETFONT;
2464
      style |= DS_SETFONT;
2465
      dialog.pointsize = (yyvsp[-4].il);
2466
      dialog.font = (yyvsp[-2].uni);
2467
      if (dialog.ex == NULL)
2468
        rcparse_warning (_("extended FONT requires DIALOGEX"));
2469
      else
2470
        {
2471
    dialog.ex->weight = (yyvsp[-1].il);
2472
    dialog.ex->italic = (yyvsp[0].il);
2473
    dialog.ex->charset = 1;
2474
        }
2475
    }
2476
#line 2477 "rcparse.c"
2477
    break;
2478
2479
  case 53:
2480
#line 514 "rcparse.y"
2481
          {
2482
      dialog.style |= DS_SETFONT;
2483
      style |= DS_SETFONT;
2484
      dialog.pointsize = (yyvsp[-5].il);
2485
      dialog.font = (yyvsp[-3].uni);
2486
      if (dialog.ex == NULL)
2487
        rcparse_warning (_("extended FONT requires DIALOGEX"));
2488
      else
2489
        {
2490
    dialog.ex->weight = (yyvsp[-2].il);
2491
    dialog.ex->italic = (yyvsp[-1].il);
2492
    dialog.ex->charset = (yyvsp[0].il);
2493
        }
2494
    }
2495
#line 2496 "rcparse.c"
2496
    break;
2497
2498
  case 54:
2499
#line 529 "rcparse.y"
2500
          {
2501
      dialog.menu = (yyvsp[0].id);
2502
    }
2503
#line 2504 "rcparse.c"
2504
    break;
2505
2506
  case 55:
2507
#line 533 "rcparse.y"
2508
          {
2509
      sub_res_info.characteristics = (yyvsp[0].il);
2510
    }
2511
#line 2512 "rcparse.c"
2512
    break;
2513
2514
  case 56:
2515
#line 537 "rcparse.y"
2516
          {
2517
      sub_res_info.language = (yyvsp[-1].il) | ((yyvsp[0].il) << SUBLANG_SHIFT);
2518
    }
2519
#line 2520 "rcparse.c"
2520
    break;
2521
2522
  case 57:
2523
#line 541 "rcparse.y"
2524
          {
2525
      sub_res_info.version = (yyvsp[0].il);
2526
    }
2527
#line 2528 "rcparse.c"
2528
    break;
2529
2530
  case 59:
2531
#line 549 "rcparse.y"
2532
          {
2533
      rc_dialog_control **pp;
2534
2535
      for (pp = &dialog.controls; *pp != NULL; pp = &(*pp)->next)
2536
        ;
2537
      *pp = (yyvsp[0].dialog_control);
2538
    }
2539
#line 2540 "rcparse.c"
2540
    break;
2541
2542
  case 60:
2543
#line 560 "rcparse.y"
2544
            {
2545
        default_style = BS_AUTO3STATE | WS_TABSTOP;
2546
        base_style = BS_AUTO3STATE;
2547
        class.named = 0;
2548
        class.u.id = CTL_BUTTON;
2549
        res_text_field = (yyvsp[0].id);
2550
      }
2551
#line 2552 "rcparse.c"
2552
    break;
2553
2554
  case 61:
2555
#line 568 "rcparse.y"
2556
          {
2557
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2558
    }
2559
#line 2560 "rcparse.c"
2560
    break;
2561
2562
  case 62:
2563
#line 572 "rcparse.y"
2564
            {
2565
        default_style = BS_AUTOCHECKBOX | WS_TABSTOP;
2566
        base_style = BS_AUTOCHECKBOX | WS_TABSTOP;
2567
        class.named = 0;
2568
        class.u.id = CTL_BUTTON;
2569
        res_text_field = (yyvsp[0].id);
2570
      }
2571
#line 2572 "rcparse.c"
2572
    break;
2573
2574
  case 63:
2575
#line 580 "rcparse.y"
2576
          {
2577
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2578
    }
2579
#line 2580 "rcparse.c"
2580
    break;
2581
2582
  case 64:
2583
#line 584 "rcparse.y"
2584
            {
2585
        default_style = BS_AUTORADIOBUTTON | WS_TABSTOP;
2586
        base_style = BS_AUTORADIOBUTTON;
2587
        class.named = 0;
2588
        class.u.id = CTL_BUTTON;
2589
        res_text_field = (yyvsp[0].id);
2590
      }
2591
#line 2592 "rcparse.c"
2592
    break;
2593
2594
  case 65:
2595
#line 592 "rcparse.y"
2596
          {
2597
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2598
    }
2599
#line 2600 "rcparse.c"
2600
    break;
2601
2602
  case 66:
2603
#line 596 "rcparse.y"
2604
            {
2605
        default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
2606
        base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
2607
        class.named = 0;
2608
        class.u.id = CTL_EDIT;
2609
        res_text_field = (yyvsp[0].id);
2610
      }
2611
#line 2612 "rcparse.c"
2612
    break;
2613
2614
  case 67:
2615
#line 604 "rcparse.y"
2616
          {
2617
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2618
      if (dialog.ex == NULL)
2619
        rcparse_warning (_("BEDIT requires DIALOGEX"));
2620
      res_string_to_id (&(yyval.dialog_control)->class, "BEDIT");
2621
    }
2622
#line 2623 "rcparse.c"
2623
    break;
2624
2625
  case 68:
2626
#line 611 "rcparse.y"
2627
            {
2628
        default_style = BS_CHECKBOX | WS_TABSTOP;
2629
        base_style = BS_CHECKBOX | WS_TABSTOP;
2630
        class.named = 0;
2631
        class.u.id = CTL_BUTTON;
2632
        res_text_field = (yyvsp[0].id);
2633
      }
2634
#line 2635 "rcparse.c"
2635
    break;
2636
2637
  case 69:
2638
#line 619 "rcparse.y"
2639
          {
2640
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2641
    }
2642
#line 2643 "rcparse.c"
2643
    break;
2644
2645
  case 70:
2646
#line 623 "rcparse.y"
2647
            {
2648
        /* This is as per MSDN documentation.  With some (???)
2649
     versions of MS rc.exe their is no default style.  */
2650
        default_style = CBS_SIMPLE | WS_TABSTOP;
2651
        base_style = 0;
2652
        class.named = 0;
2653
        class.u.id = CTL_COMBOBOX;
2654
        res_text_field = res_null_text;
2655
      }
2656
#line 2657 "rcparse.c"
2657
    break;
2658
2659
  case 71:
2660
#line 633 "rcparse.y"
2661
          {
2662
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2663
    }
2664
#line 2665 "rcparse.c"
2665
    break;
2666
2667
  case 72:
2668
#line 638 "rcparse.y"
2669
          {
2670
      (yyval.dialog_control) = define_control ((yyvsp[-9].id), (yyvsp[-8].il), (yyvsp[-5].il), (yyvsp[-4].il), (yyvsp[-3].il), (yyvsp[-2].il), (yyvsp[-7].id), style, (yyvsp[-1].il));
2671
      if ((yyvsp[0].rcdata_item) != NULL)
2672
        {
2673
    if (dialog.ex == NULL)
2674
      rcparse_warning (_("control data requires DIALOGEX"));
2675
    (yyval.dialog_control)->data = (yyvsp[0].rcdata_item);
2676
        }
2677
    }
2678
#line 2679 "rcparse.c"
2679
    break;
2680
2681
  case 73:
2682
#line 649 "rcparse.y"
2683
          {
2684
      (yyval.dialog_control) = define_control ((yyvsp[-10].id), (yyvsp[-9].il), (yyvsp[-6].il), (yyvsp[-5].il), (yyvsp[-4].il), (yyvsp[-3].il), (yyvsp[-8].id), style, (yyvsp[-2].il));
2685
      if (dialog.ex == NULL)
2686
        rcparse_warning (_("help ID requires DIALOGEX"));
2687
      (yyval.dialog_control)->help = (yyvsp[-1].il);
2688
      (yyval.dialog_control)->data = (yyvsp[0].rcdata_item);
2689
    }
2690
#line 2691 "rcparse.c"
2691
    break;
2692
2693
  case 74:
2694
#line 657 "rcparse.y"
2695
            {
2696
        default_style = SS_CENTER | WS_GROUP;
2697
        base_style = SS_CENTER;
2698
        class.named = 0;
2699
        class.u.id = CTL_STATIC;
2700
        res_text_field = (yyvsp[0].id);
2701
      }
2702
#line 2703 "rcparse.c"
2703
    break;
2704
2705
  case 75:
2706
#line 665 "rcparse.y"
2707
          {
2708
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2709
    }
2710
#line 2711 "rcparse.c"
2711
    break;
2712
2713
  case 76:
2714
#line 669 "rcparse.y"
2715
            {
2716
        default_style = BS_DEFPUSHBUTTON | WS_TABSTOP;
2717
        base_style = BS_DEFPUSHBUTTON | WS_TABSTOP;
2718
        class.named = 0;
2719
        class.u.id = CTL_BUTTON;
2720
        res_text_field = (yyvsp[0].id);
2721
      }
2722
#line 2723 "rcparse.c"
2723
    break;
2724
2725
  case 77:
2726
#line 677 "rcparse.y"
2727
          {
2728
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2729
    }
2730
#line 2731 "rcparse.c"
2731
    break;
2732
2733
  case 78:
2734
#line 681 "rcparse.y"
2735
            {
2736
        default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
2737
        base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
2738
        class.named = 0;
2739
        class.u.id = CTL_EDIT;
2740
        res_text_field = res_null_text;
2741
      }
2742
#line 2743 "rcparse.c"
2743
    break;
2744
2745
  case 79:
2746
#line 689 "rcparse.y"
2747
          {
2748
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2749
    }
2750
#line 2751 "rcparse.c"
2751
    break;
2752
2753
  case 80:
2754
#line 693 "rcparse.y"
2755
            {
2756
        default_style = BS_GROUPBOX;
2757
        base_style = BS_GROUPBOX;
2758
        class.named = 0;
2759
        class.u.id = CTL_BUTTON;
2760
        res_text_field = (yyvsp[0].id);
2761
      }
2762
#line 2763 "rcparse.c"
2763
    break;
2764
2765
  case 81:
2766
#line 701 "rcparse.y"
2767
          {
2768
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2769
    }
2770
#line 2771 "rcparse.c"
2771
    break;
2772
2773
  case 82:
2774
#line 705 "rcparse.y"
2775
            {
2776
        default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
2777
        base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
2778
        class.named = 0;
2779
        class.u.id = CTL_EDIT;
2780
        res_text_field = (yyvsp[0].id);
2781
      }
2782
#line 2783 "rcparse.c"
2783
    break;
2784
2785
  case 83:
2786
#line 713 "rcparse.y"
2787
          {
2788
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2789
      if (dialog.ex == NULL)
2790
        rcparse_warning (_("IEDIT requires DIALOGEX"));
2791
      res_string_to_id (&(yyval.dialog_control)->class, "HEDIT");
2792
    }
2793
#line 2794 "rcparse.c"
2794
    break;
2795
2796
  case 84:
2797
#line 720 "rcparse.y"
2798
          {
2799
      (yyval.dialog_control) = define_icon_control ((yyvsp[-4].id), (yyvsp[-3].il), (yyvsp[-2].il), (yyvsp[-1].il), 0, 0, 0, (yyvsp[0].rcdata_item),
2800
              dialog.ex);
2801
          }
2802
#line 2803 "rcparse.c"
2803
    break;
2804
2805
  case 85:
2806
#line 726 "rcparse.y"
2807
          {
2808
      (yyval.dialog_control) = define_icon_control ((yyvsp[-6].id), (yyvsp[-5].il), (yyvsp[-4].il), (yyvsp[-3].il), 0, 0, 0, (yyvsp[0].rcdata_item),
2809
              dialog.ex);
2810
          }
2811
#line 2812 "rcparse.c"
2812
    break;
2813
2814
  case 86:
2815
#line 732 "rcparse.y"
2816
          {
2817
      (yyval.dialog_control) = define_icon_control ((yyvsp[-8].id), (yyvsp[-7].il), (yyvsp[-6].il), (yyvsp[-5].il), style, (yyvsp[-1].il), 0, (yyvsp[0].rcdata_item),
2818
              dialog.ex);
2819
          }
2820
#line 2821 "rcparse.c"
2821
    break;
2822
2823
  case 87:
2824
#line 738 "rcparse.y"
2825
          {
2826
      (yyval.dialog_control) = define_icon_control ((yyvsp[-9].id), (yyvsp[-8].il), (yyvsp[-7].il), (yyvsp[-6].il), style, (yyvsp[-2].il), (yyvsp[-1].il), (yyvsp[0].rcdata_item),
2827
              dialog.ex);
2828
          }
2829
#line 2830 "rcparse.c"
2830
    break;
2831
2832
  case 88:
2833
#line 743 "rcparse.y"
2834
            {
2835
        default_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
2836
        base_style = ES_LEFT | WS_BORDER | WS_TABSTOP;
2837
        class.named = 0;
2838
        class.u.id = CTL_EDIT;
2839
        res_text_field = (yyvsp[0].id);
2840
      }
2841
#line 2842 "rcparse.c"
2842
    break;
2843
2844
  case 89:
2845
#line 751 "rcparse.y"
2846
          {
2847
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2848
      if (dialog.ex == NULL)
2849
        rcparse_warning (_("IEDIT requires DIALOGEX"));
2850
      res_string_to_id (&(yyval.dialog_control)->class, "IEDIT");
2851
    }
2852
#line 2853 "rcparse.c"
2853
    break;
2854
2855
  case 90:
2856
#line 758 "rcparse.y"
2857
            {
2858
        default_style = LBS_NOTIFY | WS_BORDER;
2859
        base_style = LBS_NOTIFY | WS_BORDER;
2860
        class.named = 0;
2861
        class.u.id = CTL_LISTBOX;
2862
        res_text_field = res_null_text;
2863
      }
2864
#line 2865 "rcparse.c"
2865
    break;
2866
2867
  case 91:
2868
#line 766 "rcparse.y"
2869
          {
2870
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2871
    }
2872
#line 2873 "rcparse.c"
2873
    break;
2874
2875
  case 92:
2876
#line 770 "rcparse.y"
2877
            {
2878
        default_style = SS_LEFT | WS_GROUP;
2879
        base_style = SS_LEFT;
2880
        class.named = 0;
2881
        class.u.id = CTL_STATIC;
2882
        res_text_field = (yyvsp[0].id);
2883
      }
2884
#line 2885 "rcparse.c"
2885
    break;
2886
2887
  case 93:
2888
#line 778 "rcparse.y"
2889
          {
2890
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2891
    }
2892
#line 2893 "rcparse.c"
2893
    break;
2894
2895
  case 94:
2896
#line 782 "rcparse.y"
2897
            {
2898
        default_style = BS_PUSHBOX | WS_TABSTOP;
2899
        base_style = BS_PUSHBOX;
2900
        class.named = 0;
2901
        class.u.id = CTL_BUTTON;
2902
      }
2903
#line 2904 "rcparse.c"
2904
    break;
2905
2906
  case 95:
2907
#line 789 "rcparse.y"
2908
          {
2909
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2910
    }
2911
#line 2912 "rcparse.c"
2912
    break;
2913
2914
  case 96:
2915
#line 793 "rcparse.y"
2916
            {
2917
        default_style = BS_PUSHBUTTON | WS_TABSTOP;
2918
        base_style = BS_PUSHBUTTON | WS_TABSTOP;
2919
        class.named = 0;
2920
        class.u.id = CTL_BUTTON;
2921
        res_text_field = (yyvsp[0].id);
2922
      }
2923
#line 2924 "rcparse.c"
2924
    break;
2925
2926
  case 97:
2927
#line 801 "rcparse.y"
2928
          {
2929
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2930
    }
2931
#line 2932 "rcparse.c"
2932
    break;
2933
2934
  case 98:
2935
#line 805 "rcparse.y"
2936
            {
2937
        default_style = BS_RADIOBUTTON | WS_TABSTOP;
2938
        base_style = BS_RADIOBUTTON;
2939
        class.named = 0;
2940
        class.u.id = CTL_BUTTON;
2941
        res_text_field = (yyvsp[0].id);
2942
      }
2943
#line 2944 "rcparse.c"
2944
    break;
2945
2946
  case 99:
2947
#line 813 "rcparse.y"
2948
          {
2949
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2950
    }
2951
#line 2952 "rcparse.c"
2952
    break;
2953
2954
  case 100:
2955
#line 817 "rcparse.y"
2956
            {
2957
        default_style = SS_RIGHT | WS_GROUP;
2958
        base_style = SS_RIGHT;
2959
        class.named = 0;
2960
        class.u.id = CTL_STATIC;
2961
        res_text_field = (yyvsp[0].id);
2962
      }
2963
#line 2964 "rcparse.c"
2964
    break;
2965
2966
  case 101:
2967
#line 825 "rcparse.y"
2968
          {
2969
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2970
    }
2971
#line 2972 "rcparse.c"
2972
    break;
2973
2974
  case 102:
2975
#line 829 "rcparse.y"
2976
            {
2977
        default_style = SBS_HORZ;
2978
        base_style = 0;
2979
        class.named = 0;
2980
        class.u.id = CTL_SCROLLBAR;
2981
        res_text_field = res_null_text;
2982
      }
2983
#line 2984 "rcparse.c"
2984
    break;
2985
2986
  case 103:
2987
#line 837 "rcparse.y"
2988
          {
2989
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
2990
    }
2991
#line 2992 "rcparse.c"
2992
    break;
2993
2994
  case 104:
2995
#line 841 "rcparse.y"
2996
            {
2997
        default_style = BS_3STATE | WS_TABSTOP;
2998
        base_style = BS_3STATE;
2999
        class.named = 0;
3000
        class.u.id = CTL_BUTTON;
3001
        res_text_field = (yyvsp[0].id);
3002
      }
3003
#line 3004 "rcparse.c"
3004
    break;
3005
3006
  case 105:
3007
#line 849 "rcparse.y"
3008
          {
3009
      (yyval.dialog_control) = (yyvsp[0].dialog_control);
3010
    }
3011
#line 3012 "rcparse.c"
3012
    break;
3013
3014
  case 106:
3015
#line 854 "rcparse.y"
3016
            { style = WS_CHILD | WS_VISIBLE; }
3017
#line 3018 "rcparse.c"
3018
    break;
3019
3020
  case 107:
3021
#line 856 "rcparse.y"
3022
          {
3023
      rc_res_id cid;
3024
      cid.named = 0;
3025
      cid.u.id = CTL_BUTTON;
3026
      (yyval.dialog_control) = define_control ((yyvsp[-13].id), (yyvsp[-12].il), (yyvsp[-10].il), (yyvsp[-8].il), (yyvsp[-6].il), (yyvsp[-4].il), cid,
3027
         style, (yyvsp[0].il));
3028
    }
3029
#line 3030 "rcparse.c"
3030
    break;
3031
3032
  case 108:
3033
#line 874 "rcparse.y"
3034
          {
3035
      (yyval.dialog_control) = define_control (res_text_field, (yyvsp[-5].il), (yyvsp[-4].il), (yyvsp[-3].il), (yyvsp[-2].il), (yyvsp[-1].il), class,
3036
         default_style | WS_CHILD | WS_VISIBLE, 0);
3037
      if ((yyvsp[0].rcdata_item) != NULL)
3038
        {
3039
    if (dialog.ex == NULL)
3040
      rcparse_warning (_("control data requires DIALOGEX"));
3041
    (yyval.dialog_control)->data = (yyvsp[0].rcdata_item);
3042
        }
3043
    }
3044
#line 3045 "rcparse.c"
3045
    break;
3046
3047
  case 109:
3048
#line 886 "rcparse.y"
3049
          {
3050
      (yyval.dialog_control) = define_control (res_text_field, (yyvsp[-7].il), (yyvsp[-6].il), (yyvsp[-5].il), (yyvsp[-4].il), (yyvsp[-3].il), class, style, (yyvsp[-1].il));
3051
      if ((yyvsp[0].rcdata_item) != NULL)
3052
        {
3053
    if (dialog.ex == NULL)
3054
      rcparse_warning (_("control data requires DIALOGEX"));
3055
    (yyval.dialog_control)->data = (yyvsp[0].rcdata_item);
3056
        }
3057
    }
3058
#line 3059 "rcparse.c"
3059
    break;
3060
3061
  case 110:
3062
#line 897 "rcparse.y"
3063
          {
3064
      (yyval.dialog_control) = define_control (res_text_field, (yyvsp[-8].il), (yyvsp[-7].il), (yyvsp[-6].il), (yyvsp[-5].il), (yyvsp[-4].il), class, style, (yyvsp[-2].il));
3065
      if (dialog.ex == NULL)
3066
        rcparse_warning (_("help ID requires DIALOGEX"));
3067
      (yyval.dialog_control)->help = (yyvsp[-1].il);
3068
      (yyval.dialog_control)->data = (yyvsp[0].rcdata_item);
3069
    }
3070
#line 3071 "rcparse.c"
3071
    break;
3072
3073
  case 111:
3074
#line 908 "rcparse.y"
3075
          {
3076
      if ((yyvsp[0].id).named)
3077
        res_unistring_to_id (&(yyval.id), (yyvsp[0].id).u.n.name);
3078
      else
3079
        (yyval.id)=(yyvsp[0].id);
3080
    }
3081
#line 3082 "rcparse.c"
3082
    break;
3083
3084
  case 112:
3085
#line 918 "rcparse.y"
3086
          {
3087
      res_string_to_id (&(yyval.id), "");
3088
    }
3089
#line 3090 "rcparse.c"
3090
    break;
3091
3092
  case 113:
3093
#line 921 "rcparse.y"
3094
                    { (yyval.id)=(yyvsp[-1].id); }
3095
#line 3096 "rcparse.c"
3096
    break;
3097
3098
  case 114:
3099
#line 926 "rcparse.y"
3100
          {
3101
      (yyval.id).named = 0;
3102
      (yyval.id).u.id = (yyvsp[0].il);
3103
    }
3104
#line 3105 "rcparse.c"
3105
    break;
3106
3107
  case 115:
3108
#line 931 "rcparse.y"
3109
          {
3110
      (yyval.id).named = 1;
3111
      (yyval.id).u.n.name = (yyvsp[0].uni);
3112
      (yyval.id).u.n.length = unichar_len ((yyvsp[0].uni));
3113
    }
3114
#line 3115 "rcparse.c"
3115
    break;
3116
3117
  case 116:
3118
#line 940 "rcparse.y"
3119
          {
3120
      (yyval.rcdata_item) = NULL;
3121
    }
3122
#line 3123 "rcparse.c"
3123
    break;
3124
3125
  case 117:
3126
#line 944 "rcparse.y"
3127
          {
3128
      (yyval.rcdata_item) = (yyvsp[-1].rcdata).first;
3129
    }
3130
#line 3131 "rcparse.c"
3131
    break;
3132
3133
  case 118:
3134
#line 953 "rcparse.y"
3135
          { style = WS_CHILD | WS_VISIBLE; }
3136
#line 3137 "rcparse.c"
3137
    break;
3138
3139
  case 120:
3140
#line 959 "rcparse.y"
3141
          { style = SS_ICON | WS_CHILD | WS_VISIBLE; }
3142
#line 3143 "rcparse.c"
3143
    break;
3144
3145
  case 122:
3146
#line 965 "rcparse.y"
3147
          { style = base_style | WS_CHILD | WS_VISIBLE; }
3148
#line 3149 "rcparse.c"
3149
    break;
3150
3151
  case 124:
3152
#line 973 "rcparse.y"
3153
          {
3154
      define_font ((yyvsp[-3].id), &(yyvsp[-1].res_info), (yyvsp[0].s));
3155
      if (yychar != YYEMPTY)
3156
        YYERROR;
3157
      rcparse_discard_strings ();
3158
    }
3159
#line 3160 "rcparse.c"
3160
    break;
3161
3162
  case 125:
3163
#line 985 "rcparse.y"
3164
          {
3165
      define_icon ((yyvsp[-3].id), &(yyvsp[-1].res_info), (yyvsp[0].s));
3166
      if (yychar != YYEMPTY)
3167
        YYERROR;
3168
      rcparse_discard_strings ();
3169
    }
3170
#line 3171 "rcparse.c"
3171
    break;
3172
3173
  case 126:
3174
#line 998 "rcparse.y"
3175
          {
3176
      language = (yyvsp[-1].il) | ((yyvsp[0].il) << SUBLANG_SHIFT);
3177
    }
3178
#line 3179 "rcparse.c"
3179
    break;
3180
3181
  case 127:
3182
#line 1007 "rcparse.y"
3183
          {
3184
      define_menu ((yyvsp[-5].id), &(yyvsp[-3].res_info), (yyvsp[-1].menuitem));
3185
      if (yychar != YYEMPTY)
3186
        YYERROR;
3187
      rcparse_discard_strings ();
3188
    }
3189
#line 3190 "rcparse.c"
3190
    break;
3191
3192
  case 128:
3193
#line 1017 "rcparse.y"
3194
          {
3195
      (yyval.menuitem) = NULL;
3196
    }
3197
#line 3198 "rcparse.c"
3198
    break;
3199
3200
  case 129:
3201
#line 1021 "rcparse.y"
3202
          {
3203
      if ((yyvsp[-1].menuitem) == NULL)
3204
        (yyval.menuitem) = (yyvsp[0].menuitem);
3205
      else
3206
        {
3207
    rc_menuitem **pp;
3208
3209
    for (pp = &(yyvsp[-1].menuitem)->next; *pp != NULL; pp = &(*pp)->next)
3210
      ;
3211
    *pp = (yyvsp[0].menuitem);
3212
    (yyval.menuitem) = (yyvsp[-1].menuitem);
3213
        }
3214
    }
3215
#line 3216 "rcparse.c"
3216
    break;
3217
3218
  case 130:
3219
#line 1038 "rcparse.y"
3220
          {
3221
      (yyval.menuitem) = define_menuitem ((yyvsp[-2].uni), (yyvsp[-1].il), (yyvsp[0].is), 0, 0, NULL);
3222
    }
3223
#line 3224 "rcparse.c"
3224
    break;
3225
3226
  case 131:
3227
#line 1042 "rcparse.y"
3228
          {
3229
      (yyval.menuitem) = define_menuitem (NULL, 0, 0, 0, 0, NULL);
3230
    }
3231
#line 3232 "rcparse.c"
3232
    break;
3233
3234
  case 132:
3235
#line 1046 "rcparse.y"
3236
          {
3237
      (yyval.menuitem) = define_menuitem ((yyvsp[-4].uni), 0, (yyvsp[-3].is), 0, 0, (yyvsp[-1].menuitem));
3238
    }
3239
#line 3240 "rcparse.c"
3240
    break;
3241
3242
  case 133:
3243
#line 1053 "rcparse.y"
3244
          {
3245
      (yyval.is) = 0;
3246
    }
3247
#line 3248 "rcparse.c"
3248
    break;
3249
3250
  case 134:
3251
#line 1057 "rcparse.y"
3252
          {
3253
      (yyval.is) = (yyvsp[-2].is) | (yyvsp[0].is);
3254
    }
3255
#line 3256 "rcparse.c"
3256
    break;
3257
3258
  case 135:
3259
#line 1061 "rcparse.y"
3260
          {
3261
      (yyval.is) = (yyvsp[-1].is) | (yyvsp[0].is);
3262
    }
3263
#line 3264 "rcparse.c"
3264
    break;
3265
3266
  case 136:
3267
#line 1068 "rcparse.y"
3268
          {
3269
      (yyval.is) = MENUITEM_CHECKED;
3270
    }
3271
#line 3272 "rcparse.c"
3272
    break;
3273
3274
  case 137:
3275
#line 1072 "rcparse.y"
3276
          {
3277
      (yyval.is) = MENUITEM_GRAYED;
3278
    }
3279
#line 3280 "rcparse.c"
3280
    break;
3281
3282
  case 138:
3283
#line 1076 "rcparse.y"
3284
          {
3285
      (yyval.is) = MENUITEM_HELP;
3286
    }
3287
#line 3288 "rcparse.c"
3288
    break;
3289
3290
  case 139:
3291
#line 1080 "rcparse.y"
3292
          {
3293
      (yyval.is) = MENUITEM_INACTIVE;
3294
    }
3295
#line 3296 "rcparse.c"
3296
    break;
3297
3298
  case 140:
3299
#line 1084 "rcparse.y"
3300
          {
3301
      (yyval.is) = MENUITEM_MENUBARBREAK;
3302
    }
3303
#line 3304 "rcparse.c"
3304
    break;
3305
3306
  case 141:
3307
#line 1088 "rcparse.y"
3308
          {
3309
      (yyval.is) = MENUITEM_MENUBREAK;
3310
    }
3311
#line 3312 "rcparse.c"
3312
    break;
3313
3314
  case 142:
3315
#line 1092 "rcparse.y"
3316
          {
3317
      (yyval.is) = MENUITEM_BITMAP;
3318
    }
3319
#line 3320 "rcparse.c"
3320
    break;
3321
3322
  case 143:
3323
#line 1096 "rcparse.y"
3324
          {
3325
      (yyval.is) = MENUITEM_OWNERDRAW;
3326
    }
3327
#line 3328 "rcparse.c"
3328
    break;
3329
3330
  case 144:
3331
#line 1105 "rcparse.y"
3332
          {
3333
      define_menu ((yyvsp[-5].id), &(yyvsp[-3].res_info), (yyvsp[-1].menuitem));
3334
      if (yychar != YYEMPTY)
3335
        YYERROR;
3336
      rcparse_discard_strings ();
3337
    }
3338
#line 3339 "rcparse.c"
3339
    break;
3340
3341
  case 145:
3342
#line 1115 "rcparse.y"
3343
          {
3344
      (yyval.menuitem) = NULL;
3345
    }
3346
#line 3347 "rcparse.c"
3347
    break;
3348
3349
  case 146:
3350
#line 1119 "rcparse.y"
3351
          {
3352
      if ((yyvsp[-1].menuitem) == NULL)
3353
        (yyval.menuitem) = (yyvsp[0].menuitem);
3354
      else
3355
        {
3356
    rc_menuitem **pp;
3357
3358
    for (pp = &(yyvsp[-1].menuitem)->next; *pp != NULL; pp = &(*pp)->next)
3359
      ;
3360
    *pp = (yyvsp[0].menuitem);
3361
    (yyval.menuitem) = (yyvsp[-1].menuitem);
3362
        }
3363
    }
3364
#line 3365 "rcparse.c"
3365
    break;
3366
3367
  case 147:
3368
#line 1136 "rcparse.y"
3369
          {
3370
      (yyval.menuitem) = define_menuitem ((yyvsp[0].uni), 0, 0, 0, 0, NULL);
3371
    }
3372
#line 3373 "rcparse.c"
3373
    break;
3374
3375
  case 148:
3376
#line 1140 "rcparse.y"
3377
          {
3378
      (yyval.menuitem) = define_menuitem ((yyvsp[-1].uni), (yyvsp[0].il), 0, 0, 0, NULL);
3379
    }
3380
#line 3381 "rcparse.c"
3381
    break;
3382
3383
  case 149:
3384
#line 1144 "rcparse.y"
3385
          {
3386
      (yyval.menuitem) = define_menuitem ((yyvsp[-3].uni), (yyvsp[-2].il), (yyvsp[-1].il), (yyvsp[0].il), 0, NULL);
3387
    }
3388
#line 3389 "rcparse.c"
3389
    break;
3390
3391
  case 150:
3392
#line 1148 "rcparse.y"
3393
          {
3394
      (yyval.menuitem) = define_menuitem (NULL, 0, 0, 0, 0, NULL);
3395
    }
3396
#line 3397 "rcparse.c"
3397
    break;
3398
3399
  case 151:
3400
#line 1152 "rcparse.y"
3401
          {
3402
      (yyval.menuitem) = define_menuitem ((yyvsp[-3].uni), 0, 0, 0, 0, (yyvsp[-1].menuitem));
3403
    }
3404
#line 3405 "rcparse.c"
3405
    break;
3406
3407
  case 152:
3408
#line 1156 "rcparse.y"
3409
          {
3410
      (yyval.menuitem) = define_menuitem ((yyvsp[-4].uni), (yyvsp[-3].il), 0, 0, 0, (yyvsp[-1].menuitem));
3411
    }
3412
#line 3413 "rcparse.c"
3413
    break;
3414
3415
  case 153:
3416
#line 1160 "rcparse.y"
3417
          {
3418
      (yyval.menuitem) = define_menuitem ((yyvsp[-5].uni), (yyvsp[-4].il), (yyvsp[-3].il), 0, 0, (yyvsp[-1].menuitem));
3419
    }
3420
#line 3421 "rcparse.c"
3421
    break;
3422
3423
  case 154:
3424
#line 1165 "rcparse.y"
3425
          {
3426
      (yyval.menuitem) = define_menuitem ((yyvsp[-7].uni), (yyvsp[-6].il), (yyvsp[-5].il), (yyvsp[-4].il), (yyvsp[-3].il), (yyvsp[-1].menuitem));
3427
    }
3428
#line 3429 "rcparse.c"
3429
    break;
3430
3431
  case 155:
3432
#line 1174 "rcparse.y"
3433
          {
3434
      define_messagetable ((yyvsp[-3].id), &(yyvsp[-1].res_info), (yyvsp[0].s));
3435
      if (yychar != YYEMPTY)
3436
        YYERROR;
3437
      rcparse_discard_strings ();
3438
    }
3439
#line 3440 "rcparse.c"
3440
    break;
3441
3442
  case 156:
3443
#line 1186 "rcparse.y"
3444
          {
3445
      rcparse_rcdata ();
3446
    }
3447
#line 3448 "rcparse.c"
3448
    break;
3449
3450
  case 157:
3451
#line 1190 "rcparse.y"
3452
          {
3453
      rcparse_normal ();
3454
      (yyval.rcdata) = (yyvsp[0].rcdata);
3455
    }
3456
#line 3457 "rcparse.c"
3457
    break;
3458
3459
  case 158:
3460
#line 1198 "rcparse.y"
3461
          {
3462
      (yyval.rcdata).first = NULL;
3463
      (yyval.rcdata).last = NULL;
3464
    }
3465
#line 3466 "rcparse.c"
3466
    break;
3467
3468
  case 159:
3469
#line 1203 "rcparse.y"
3470
          {
3471
      (yyval.rcdata) = (yyvsp[0].rcdata);
3472
    }
3473
#line 3474 "rcparse.c"
3474
    break;
3475
3476
  case 160:
3477
#line 1210 "rcparse.y"
3478
          {
3479
      rc_rcdata_item *ri;
3480
3481
      ri = define_rcdata_string ((yyvsp[0].ss).s, (yyvsp[0].ss).length);
3482
      (yyval.rcdata).first = ri;
3483
      (yyval.rcdata).last = ri;
3484
    }
3485
#line 3486 "rcparse.c"
3486
    break;
3487
3488
  case 161:
3489
#line 1218 "rcparse.y"
3490
          {
3491
      rc_rcdata_item *ri;
3492
3493
      ri = define_rcdata_unistring ((yyvsp[0].suni).s, (yyvsp[0].suni).length);
3494
      (yyval.rcdata).first = ri;
3495
      (yyval.rcdata).last = ri;
3496
    }
3497
#line 3498 "rcparse.c"
3498
    break;
3499
3500
  case 162:
3501
#line 1226 "rcparse.y"
3502
          {
3503
      rc_rcdata_item *ri;
3504
3505
      ri = define_rcdata_number ((yyvsp[0].i).val, (yyvsp[0].i).dword);
3506
      (yyval.rcdata).first = ri;
3507
      (yyval.rcdata).last = ri;
3508
    }
3509
#line 3510 "rcparse.c"
3510
    break;
3511
3512
  case 163:
3513
#line 1234 "rcparse.y"
3514
          {
3515
      rc_rcdata_item *ri;
3516
3517
      ri = define_rcdata_string ((yyvsp[0].ss).s, (yyvsp[0].ss).length);
3518
      (yyval.rcdata).first = (yyvsp[-2].rcdata).first;
3519
      (yyvsp[-2].rcdata).last->next = ri;
3520
      (yyval.rcdata).last = ri;
3521
    }
3522
#line 3523 "rcparse.c"
3523
    break;
3524
3525
  case 164:
3526
#line 1243 "rcparse.y"
3527
          {
3528
      rc_rcdata_item *ri;
3529
3530
      ri = define_rcdata_unistring ((yyvsp[0].suni).s, (yyvsp[0].suni).length);
3531
      (yyval.rcdata).first = (yyvsp[-2].rcdata).first;
3532
      (yyvsp[-2].rcdata).last->next = ri;
3533
      (yyval.rcdata).last = ri;
3534
    }
3535
#line 3536 "rcparse.c"
3536
    break;
3537
3538
  case 165:
3539
#line 1252 "rcparse.y"
3540
          {
3541
      rc_rcdata_item *ri;
3542
3543
      ri = define_rcdata_number ((yyvsp[0].i).val, (yyvsp[0].i).dword);
3544
      (yyval.rcdata).first = (yyvsp[-2].rcdata).first;
3545
      (yyvsp[-2].rcdata).last->next = ri;
3546
      (yyval.rcdata).last = ri;
3547
    }
3548
#line 3549 "rcparse.c"
3549
    break;
3550
3551
  case 166:
3552
#line 1261 "rcparse.y"
3553
          {
3554
      (yyval.rcdata)=(yyvsp[-1].rcdata);
3555
    }
3556
#line 3557 "rcparse.c"
3557
    break;
3558
3559
  case 167:
3560
#line 1270 "rcparse.y"
3561
            { sub_res_info = (yyvsp[-1].res_info); rcparse_rcdata (); }
3562
#line 3563 "rcparse.c"
3563
    break;
3564
3565
  case 168:
3566
#line 1271 "rcparse.y"
3567
                            { rcparse_normal (); }
3568
#line 3569 "rcparse.c"
3569
    break;
3570
3571
  case 170:
3572
#line 1277 "rcparse.y"
3573
          {
3574
      define_stringtable (&sub_res_info, (yyvsp[-1].il), (yyvsp[0].suni).s, (yyvsp[0].suni).length);
3575
      rcparse_discard_strings ();
3576
    }
3577
#line 3578 "rcparse.c"
3578
    break;
3579
3580
  case 171:
3581
#line 1282 "rcparse.y"
3582
          {
3583
      define_stringtable (&sub_res_info, (yyvsp[-2].il), (yyvsp[0].suni).s, (yyvsp[0].suni).length);
3584
      rcparse_discard_strings ();
3585
    }
3586
#line 3587 "rcparse.c"
3587
    break;
3588
3589
  case 172:
3590
#line 1287 "rcparse.y"
3591
          {
3592
      rcparse_warning (_("invalid stringtable resource."));
3593
      abort ();
3594
    }
3595
#line 3596 "rcparse.c"
3596
    break;
3597
3598
  case 173:
3599
#line 1295 "rcparse.y"
3600
          {
3601
      (yyval.id)=(yyvsp[0].id);
3602
    }
3603
#line 3604 "rcparse.c"
3604
    break;
3605
3606
  case 174:
3607
#line 1299 "rcparse.y"
3608
        {
3609
    (yyval.id).named = 0;
3610
    (yyval.id).u.id = 23;
3611
  }
3612
#line 3613 "rcparse.c"
3613
    break;
3614
3615
  case 175:
3616
#line 1304 "rcparse.y"
3617
        {
3618
          (yyval.id).named = 0;
3619
          (yyval.id).u.id = RT_RCDATA;
3620
        }
3621
#line 3622 "rcparse.c"
3622
    break;
3623
3624
  case 176:
3625
#line 1309 "rcparse.y"
3626
        {
3627
          (yyval.id).named = 0;
3628
          (yyval.id).u.id = RT_MANIFEST;
3629
        }
3630
#line 3631 "rcparse.c"
3631
    break;
3632
3633
  case 177:
3634
#line 1314 "rcparse.y"
3635
        {
3636
          (yyval.id).named = 0;
3637
          (yyval.id).u.id = RT_PLUGPLAY;
3638
        }
3639
#line 3640 "rcparse.c"
3640
    break;
3641
3642
  case 178:
3643
#line 1319 "rcparse.y"
3644
        {
3645
          (yyval.id).named = 0;
3646
          (yyval.id).u.id = RT_VXD;
3647
        }
3648
#line 3649 "rcparse.c"
3649
    break;
3650
3651
  case 179:
3652
#line 1324 "rcparse.y"
3653
        {
3654
          (yyval.id).named = 0;
3655
          (yyval.id).u.id = RT_DLGINCLUDE;
3656
        }
3657
#line 3658 "rcparse.c"
3658
    break;
3659
3660
  case 180:
3661
#line 1329 "rcparse.y"
3662
        {
3663
          (yyval.id).named = 0;
3664
          (yyval.id).u.id = RT_DLGINIT;
3665
        }
3666
#line 3667 "rcparse.c"
3667
    break;
3668
3669
  case 181:
3670
#line 1334 "rcparse.y"
3671
        {
3672
          (yyval.id).named = 0;
3673
          (yyval.id).u.id = RT_ANICURSOR;
3674
        }
3675
#line 3676 "rcparse.c"
3676
    break;
3677
3678
  case 182:
3679
#line 1339 "rcparse.y"
3680
        {
3681
          (yyval.id).named = 0;
3682
          (yyval.id).u.id = RT_ANIICON;
3683
        }
3684
#line 3685 "rcparse.c"
3685
    break;
3686
3687
  case 183:
3688
#line 1350 "rcparse.y"
3689
          {
3690
      define_user_data ((yyvsp[-5].id), (yyvsp[-4].id), &(yyvsp[-3].res_info), (yyvsp[-1].rcdata).first);
3691
      if (yychar != YYEMPTY)
3692
        YYERROR;
3693
      rcparse_discard_strings ();
3694
    }
3695
#line 3696 "rcparse.c"
3696
    break;
3697
3698
  case 184:
3699
#line 1357 "rcparse.y"
3700
          {
3701
      define_user_file ((yyvsp[-3].id), (yyvsp[-2].id), &(yyvsp[-1].res_info), (yyvsp[0].s));
3702
      if (yychar != YYEMPTY)
3703
        YYERROR;
3704
      rcparse_discard_strings ();
3705
    }
3706
#line 3707 "rcparse.c"
3707
    break;
3708
3709
  case 185:
3710
#line 1367 "rcparse.y"
3711
        {
3712
    define_toolbar ((yyvsp[-7].id), &(yyvsp[-5].res_info), (yyvsp[-4].il), (yyvsp[-3].il), (yyvsp[-1].toobar_item));
3713
  }
3714
#line 3715 "rcparse.c"
3715
    break;
3716
3717
  case 186:
3718
#line 1372 "rcparse.y"
3719
                          { (yyval.toobar_item)= NULL; }
3720
#line 3721 "rcparse.c"
3721
    break;
3722
3723
  case 187:
3724
#line 1374 "rcparse.y"
3725
        {
3726
    rc_toolbar_item *c,*n;
3727
    c = (yyvsp[-2].toobar_item);
3728
    n= (rc_toolbar_item *)
3729
        res_alloc (sizeof (rc_toolbar_item));
3730
    if (c != NULL)
3731
      while (c->next != NULL)
3732
        c = c->next;
3733
    n->prev = c;
3734
    n->next = NULL;
3735
    if (c != NULL)
3736
      c->next = n;
3737
    n->id = (yyvsp[0].id);
3738
    if ((yyvsp[-2].toobar_item) == NULL)
3739
      (yyval.toobar_item) = n;
3740
    else
3741
      (yyval.toobar_item) = (yyvsp[-2].toobar_item);
3742
  }
3743
#line 3744 "rcparse.c"
3744
    break;
3745
3746
  case 188:
3747
#line 1393 "rcparse.y"
3748
        {
3749
    rc_toolbar_item *c,*n;
3750
    c = (yyvsp[-1].toobar_item);
3751
    n= (rc_toolbar_item *)
3752
        res_alloc (sizeof (rc_toolbar_item));
3753
    if (c != NULL)
3754
      while (c->next != NULL)
3755
        c = c->next;
3756
    n->prev = c;
3757
    n->next = NULL;
3758
    if (c != NULL)
3759
      c->next = n;
3760
    n->id.named = 0;
3761
    n->id.u.id = 0;
3762
    if ((yyvsp[-1].toobar_item) == NULL)
3763
      (yyval.toobar_item) = n;
3764
    else
3765
      (yyval.toobar_item) = (yyvsp[-1].toobar_item);
3766
  }
3767
#line 3768 "rcparse.c"
3768
    break;
3769
3770
  case 189:
3771
#line 1418 "rcparse.y"
3772
          {
3773
      define_versioninfo ((yyvsp[-5].id), language, (yyvsp[-3].fixver), (yyvsp[-1].verinfo));
3774
      if (yychar != YYEMPTY)
3775
        YYERROR;
3776
      rcparse_discard_strings ();
3777
    }
3778
#line 3779 "rcparse.c"
3779
    break;
3780
3781
  case 190:
3782
#line 1428 "rcparse.y"
3783
          {
3784
      (yyval.fixver) = ((rc_fixed_versioninfo *)
3785
      res_alloc (sizeof (rc_fixed_versioninfo)));
3786
      memset ((yyval.fixver), 0, sizeof (rc_fixed_versioninfo));
3787
    }
3788
#line 3789 "rcparse.c"
3789
    break;
3790
3791
  case 191:
3792
#line 1435 "rcparse.y"
3793
          {
3794
      (yyvsp[-5].fixver)->file_version_ms = ((yyvsp[-3].il) << 16) | ((yyvsp[-2].il) & 0xffff);
3795
      (yyvsp[-5].fixver)->file_version_ls = ((yyvsp[-1].il) << 16) | ((yyvsp[0].il) & 0xffff);
3796
      (yyval.fixver) = (yyvsp[-5].fixver);
3797
    }
3798
#line 3799 "rcparse.c"
3799
    break;
3800
3801
  case 192:
3802
#line 1442 "rcparse.y"
3803
          {
3804
      (yyvsp[-5].fixver)->product_version_ms = ((yyvsp[-3].il) << 16) | ((yyvsp[-2].il) & 0xffff);
3805
      (yyvsp[-5].fixver)->product_version_ls = ((yyvsp[-1].il) << 16) | ((yyvsp[0].il) & 0xffff);
3806
      (yyval.fixver) = (yyvsp[-5].fixver);
3807
    }
3808
#line 3809 "rcparse.c"
3809
    break;
3810
3811
  case 193:
3812
#line 1448 "rcparse.y"
3813
          {
3814
      (yyvsp[-2].fixver)->file_flags_mask = (yyvsp[0].il);
3815
      (yyval.fixver) = (yyvsp[-2].fixver);
3816
    }
3817
#line 3818 "rcparse.c"
3818
    break;
3819
3820
  case 194:
3821
#line 1453 "rcparse.y"
3822
          {
3823
      (yyvsp[-2].fixver)->file_flags = (yyvsp[0].il);
3824
      (yyval.fixver) = (yyvsp[-2].fixver);
3825
    }
3826
#line 3827 "rcparse.c"
3827
    break;
3828
3829
  case 195:
3830
#line 1458 "rcparse.y"
3831
          {
3832
      (yyvsp[-2].fixver)->file_os = (yyvsp[0].il);
3833
      (yyval.fixver) = (yyvsp[-2].fixver);
3834
    }
3835
#line 3836 "rcparse.c"
3836
    break;
3837
3838
  case 196:
3839
#line 1463 "rcparse.y"
3840
          {
3841
      (yyvsp[-2].fixver)->file_type = (yyvsp[0].il);
3842
      (yyval.fixver) = (yyvsp[-2].fixver);
3843
    }
3844
#line 3845 "rcparse.c"
3845
    break;
3846
3847
  case 197:
3848
#line 1468 "rcparse.y"
3849
          {
3850
      (yyvsp[-2].fixver)->file_subtype = (yyvsp[0].il);
3851
      (yyval.fixver) = (yyvsp[-2].fixver);
3852
    }
3853
#line 3854 "rcparse.c"
3854
    break;
3855
3856
  case 198:
3857
#line 1482 "rcparse.y"
3858
          {
3859
      (yyval.verinfo) = NULL;
3860
    }
3861
#line 3862 "rcparse.c"
3862
    break;
3863
3864
  case 199:
3865
#line 1486 "rcparse.y"
3866
          {
3867
      (yyval.verinfo) = append_ver_stringfileinfo ((yyvsp[-4].verinfo), (yyvsp[-1].verstringtable));
3868
    }
3869
#line 3870 "rcparse.c"
3870
    break;
3871
3872
  case 200:
3873
#line 1490 "rcparse.y"
3874
          {
3875
      (yyval.verinfo) = append_ver_varfileinfo ((yyvsp[-6].verinfo), (yyvsp[-2].uni), (yyvsp[-1].vervar));
3876
    }
3877
#line 3878 "rcparse.c"
3878
    break;
3879
3880
  case 201:
3881
#line 1497 "rcparse.y"
3882
          {
3883
      (yyval.verstringtable) = NULL;
3884
    }
3885
#line 3886 "rcparse.c"
3886
    break;
3887
3888
  case 202:
3889
#line 1501 "rcparse.y"
3890
          {
3891
      (yyval.verstringtable) = append_ver_stringtable ((yyvsp[-4].verstringtable), (yyvsp[-3].s), (yyvsp[-1].verstring));
3892
    }
3893
#line 3894 "rcparse.c"
3894
    break;
3895
3896
  case 203:
3897
#line 1508 "rcparse.y"
3898
          {
3899
      (yyval.verstring) = NULL;
3900
    }
3901
#line 3902 "rcparse.c"
3902
    break;
3903
3904
  case 204:
3905
#line 1512 "rcparse.y"
3906
          {
3907
      (yyval.verstring) = append_verval ((yyvsp[-4].verstring), (yyvsp[-2].uni), (yyvsp[0].uni));
3908
    }
3909
#line 3910 "rcparse.c"
3910
    break;
3911
3912
  case 205:
3913
#line 1519 "rcparse.y"
3914
          {
3915
      (yyval.vervar) = NULL;
3916
    }
3917
#line 3918 "rcparse.c"
3918
    break;
3919
3920
  case 206:
3921
#line 1523 "rcparse.y"
3922
          {
3923
      (yyval.vervar) = append_vertrans ((yyvsp[-2].vervar), (yyvsp[-1].il), (yyvsp[0].il));
3924
    }
3925
#line 3926 "rcparse.c"
3926
    break;
3927
3928
  case 207:
3929
#line 1532 "rcparse.y"
3930
          {
3931
      (yyval.id).named = 0;
3932
      (yyval.id).u.id = (yyvsp[0].il);
3933
    }
3934
#line 3935 "rcparse.c"
3935
    break;
3936
3937
  case 208:
3938
#line 1537 "rcparse.y"
3939
          {
3940
      res_unistring_to_id (&(yyval.id), (yyvsp[0].uni));
3941
    }
3942
#line 3943 "rcparse.c"
3943
    break;
3944
3945
  case 209:
3946
#line 1546 "rcparse.y"
3947
          {
3948
      (yyval.uni) = (yyvsp[0].uni);
3949
    }
3950
#line 3951 "rcparse.c"
3951
    break;
3952
3953
  case 210:
3954
#line 1550 "rcparse.y"
3955
          {
3956
      unichar *h = NULL;
3957
      unicode_from_ascii ((rc_uint_type *) NULL, &h, (yyvsp[0].s));
3958
      (yyval.uni) = h;
3959
    }
3960
#line 3961 "rcparse.c"
3961
    break;
3962
3963
  case 211:
3964
#line 1560 "rcparse.y"
3965
          {
3966
      (yyval.id).named = 0;
3967
      (yyval.id).u.id = (yyvsp[-1].il);
3968
    }
3969
#line 3970 "rcparse.c"
3970
    break;
3971
3972
  case 212:
3973
#line 1565 "rcparse.y"
3974
          {
3975
      res_unistring_to_id (&(yyval.id), (yyvsp[0].uni));
3976
    }
3977
#line 3978 "rcparse.c"
3978
    break;
3979
3980
  case 213:
3981
#line 1569 "rcparse.y"
3982
          {
3983
      res_unistring_to_id (&(yyval.id), (yyvsp[-1].uni));
3984
    }
3985
#line 3986 "rcparse.c"
3986
    break;
3987
3988
  case 214:
3989
#line 1579 "rcparse.y"
3990
          {
3991
      memset (&(yyval.res_info), 0, sizeof (rc_res_res_info));
3992
      (yyval.res_info).language = language;
3993
      /* FIXME: Is this the right default?  */
3994
      (yyval.res_info).memflags = MEMFLAG_MOVEABLE | MEMFLAG_PURE | MEMFLAG_DISCARDABLE;
3995
    }
3996
#line 3997 "rcparse.c"
3997
    break;
3998
3999
  case 215:
4000
#line 1586 "rcparse.y"
4001
          {
4002
      (yyval.res_info) = (yyvsp[-1].res_info);
4003
      (yyval.res_info).memflags |= (yyvsp[0].memflags).on;
4004
      (yyval.res_info).memflags &=~ (yyvsp[0].memflags).off;
4005
    }
4006
#line 4007 "rcparse.c"
4007
    break;
4008
4009
  case 216:
4010
#line 1592 "rcparse.y"
4011
          {
4012
      (yyval.res_info) = (yyvsp[-2].res_info);
4013
      (yyval.res_info).characteristics = (yyvsp[0].il);
4014
    }
4015
#line 4016 "rcparse.c"
4016
    break;
4017
4018
  case 217:
4019
#line 1597 "rcparse.y"
4020
          {
4021
      (yyval.res_info) = (yyvsp[-3].res_info);
4022
      (yyval.res_info).language = (yyvsp[-1].il) | ((yyvsp[0].il) << SUBLANG_SHIFT);
4023
    }
4024
#line 4025 "rcparse.c"
4025
    break;
4026
4027
  case 218:
4028
#line 1602 "rcparse.y"
4029
          {
4030
      (yyval.res_info) = (yyvsp[-2].res_info);
4031
      (yyval.res_info).version = (yyvsp[0].il);
4032
    }
4033
#line 4034 "rcparse.c"
4034
    break;
4035
4036
  case 219:
4037
#line 1612 "rcparse.y"
4038
          {
4039
      memset (&(yyval.res_info), 0, sizeof (rc_res_res_info));
4040
      (yyval.res_info).language = language;
4041
      (yyval.res_info).memflags = MEMFLAG_MOVEABLE | MEMFLAG_DISCARDABLE;
4042
    }
4043
#line 4044 "rcparse.c"
4044
    break;
4045
4046
  case 220:
4047
#line 1618 "rcparse.y"
4048
          {
4049
      (yyval.res_info) = (yyvsp[-1].res_info);
4050
      (yyval.res_info).memflags |= (yyvsp[0].memflags).on;
4051
      (yyval.res_info).memflags &=~ (yyvsp[0].memflags).off;
4052
    }
4053
#line 4054 "rcparse.c"
4054
    break;
4055
4056
  case 221:
4057
#line 1629 "rcparse.y"
4058
          {
4059
      memset (&(yyval.res_info), 0, sizeof (rc_res_res_info));
4060
      (yyval.res_info).language = language;
4061
      (yyval.res_info).memflags = MEMFLAG_MOVEABLE | MEMFLAG_PURE | MEMFLAG_DISCARDABLE;
4062
    }
4063
#line 4064 "rcparse.c"
4064
    break;
4065
4066
  case 222:
4067
#line 1635 "rcparse.y"
4068
          {
4069
      (yyval.res_info) = (yyvsp[-1].res_info);
4070
      (yyval.res_info).memflags |= (yyvsp[0].memflags).on;
4071
      (yyval.res_info).memflags &=~ (yyvsp[0].memflags).off;
4072
    }
4073
#line 4074 "rcparse.c"
4074
    break;
4075
4076
  case 223:
4077
#line 1647 "rcparse.y"
4078
          {
4079
      (yyval.memflags).on = MEMFLAG_MOVEABLE;
4080
      (yyval.memflags).off = 0;
4081
    }
4082
#line 4083 "rcparse.c"
4083
    break;
4084
4085
  case 224:
4086
#line 1652 "rcparse.y"
4087
          {
4088
      (yyval.memflags).on = 0;
4089
      (yyval.memflags).off = MEMFLAG_MOVEABLE;
4090
    }
4091
#line 4092 "rcparse.c"
4092
    break;
4093
4094
  case 225:
4095
#line 1657 "rcparse.y"
4096
          {
4097
      (yyval.memflags).on = MEMFLAG_PURE;
4098
      (yyval.memflags).off = 0;
4099
    }
4100
#line 4101 "rcparse.c"
4101
    break;
4102
4103
  case 226:
4104
#line 1662 "rcparse.y"
4105
          {
4106
      (yyval.memflags).on = 0;
4107
      (yyval.memflags).off = MEMFLAG_PURE;
4108
    }
4109
#line 4110 "rcparse.c"
4110
    break;
4111
4112
  case 227:
4113
#line 1667 "rcparse.y"
4114
          {
4115
      (yyval.memflags).on = MEMFLAG_PRELOAD;
4116
      (yyval.memflags).off = 0;
4117
    }
4118
#line 4119 "rcparse.c"
4119
    break;
4120
4121
  case 228:
4122
#line 1672 "rcparse.y"
4123
          {
4124
      (yyval.memflags).on = 0;
4125
      (yyval.memflags).off = MEMFLAG_PRELOAD;
4126
    }
4127
#line 4128 "rcparse.c"
4128
    break;
4129
4130
  case 229:
4131
#line 1677 "rcparse.y"
4132
          {
4133
      (yyval.memflags).on = MEMFLAG_DISCARDABLE;
4134
      (yyval.memflags).off = 0;
4135
    }
4136
#line 4137 "rcparse.c"
4137
    break;
4138
4139
  case 230:
4140
#line 1687 "rcparse.y"
4141
          {
4142
      (yyval.s) = (yyvsp[0].s);
4143
    }
4144
#line 4145 "rcparse.c"
4145
    break;
4146
4147
  case 231:
4148
#line 1691 "rcparse.y"
4149
          {
4150
      (yyval.s) = (yyvsp[0].s);
4151
    }
4152
#line 4153 "rcparse.c"
4153
    break;
4154
4155
  case 232:
4156
#line 1699 "rcparse.y"
4157
          {
4158
      (yyval.uni) = (yyvsp[0].uni);
4159
    }
4160
#line 4161 "rcparse.c"
4161
    break;
4162
4163
  case 233:
4164
#line 1704 "rcparse.y"
4165
          {
4166
      rc_uint_type l1 = unichar_len ((yyvsp[-1].uni));
4167
      rc_uint_type l2 = unichar_len ((yyvsp[0].uni));
4168
      unichar *h = (unichar *) res_alloc ((l1 + l2 + 1) * sizeof (unichar));
4169
      if (l1 != 0)
4170
        memcpy (h, (yyvsp[-1].uni), l1 * sizeof (unichar));
4171
      if (l2 != 0)
4172
        memcpy (h + l1, (yyvsp[0].uni), l2  * sizeof (unichar));
4173
      h[l1 + l2] = 0;
4174
      (yyval.uni) = h;
4175
    }
4176
#line 4177 "rcparse.c"
4177
    break;
4178
4179
  case 234:
4180
#line 1719 "rcparse.y"
4181
          {
4182
      (yyval.uni) = unichar_dup ((yyvsp[0].uni));
4183
    }
4184
#line 4185 "rcparse.c"
4185
    break;
4186
4187
  case 235:
4188
#line 1723 "rcparse.y"
4189
          {
4190
      unichar *h = NULL;
4191
      unicode_from_ascii ((rc_uint_type *) NULL, &h, (yyvsp[0].s));
4192
      (yyval.uni) = h;
4193
    }
4194
#line 4195 "rcparse.c"
4195
    break;
4196
4197
  case 236:
4198
#line 1732 "rcparse.y"
4199
          {
4200
      (yyval.suni) = (yyvsp[0].suni);
4201
    }
4202
#line 4203 "rcparse.c"
4203
    break;
4204
4205
  case 237:
4206
#line 1736 "rcparse.y"
4207
          {
4208
      unichar *h = NULL;
4209
      rc_uint_type l = 0;
4210
      unicode_from_ascii_len (&l, &h, (yyvsp[0].ss).s, (yyvsp[0].ss).length);
4211
      (yyval.suni).s = h;
4212
      (yyval.suni).length = l;
4213
    }
4214
#line 4215 "rcparse.c"
4215
    break;
4216
4217
  case 238:
4218
#line 1748 "rcparse.y"
4219
          {
4220
      (yyval.suni) = (yyvsp[0].suni);
4221
    }
4222
#line 4223 "rcparse.c"
4223
    break;
4224
4225
  case 239:
4226
#line 1753 "rcparse.y"
4227
          {
4228
      rc_uint_type l1 = (yyvsp[-1].suni).length;
4229
      rc_uint_type l2 = (yyvsp[0].suni).length;
4230
      unichar *h = (unichar *) res_alloc ((l1 + l2 + 1) * sizeof (unichar));
4231
      if (l1 != 0)
4232
        memcpy (h, (yyvsp[-1].suni).s, l1 * sizeof (unichar));
4233
      if (l2 != 0)
4234
        memcpy (h + l1, (yyvsp[0].suni).s, l2  * sizeof (unichar));
4235
      h[l1 + l2] = 0;
4236
      (yyval.suni).length = l1 + l2;
4237
      (yyval.suni).s = h;
4238
    }
4239
#line 4240 "rcparse.c"
4240
    break;
4241
4242
  case 240:
4243
#line 1769 "rcparse.y"
4244
          {
4245
      (yyval.ss) = (yyvsp[0].ss);
4246
    }
4247
#line 4248 "rcparse.c"
4248
    break;
4249
4250
  case 241:
4251
#line 1773 "rcparse.y"
4252
          {
4253
      rc_uint_type l = (yyvsp[-1].ss).length + (yyvsp[0].ss).length;
4254
      char *h = (char *) res_alloc (l);
4255
      memcpy (h, (yyvsp[-1].ss).s, (yyvsp[-1].ss).length);
4256
      memcpy (h + (yyvsp[-1].ss).length, (yyvsp[0].ss).s, (yyvsp[0].ss).length);
4257
      (yyval.ss).s = h;
4258
      (yyval.ss).length = l;
4259
    }
4260
#line 4261 "rcparse.c"
4261
    break;
4262
4263
  case 242:
4264
#line 1785 "rcparse.y"
4265
          {
4266
      (yyval.suni) = (yyvsp[0].suni);
4267
    }
4268
#line 4269 "rcparse.c"
4269
    break;
4270
4271
  case 243:
4272
#line 1789 "rcparse.y"
4273
          {
4274
      rc_uint_type l = (yyvsp[-1].suni).length + (yyvsp[0].suni).length;
4275
      unichar *h = (unichar *) res_alloc (l * sizeof (unichar));
4276
      memcpy (h, (yyvsp[-1].suni).s, (yyvsp[-1].suni).length * sizeof (unichar));
4277
      memcpy (h + (yyvsp[-1].suni).length, (yyvsp[0].suni).s, (yyvsp[0].suni).length  * sizeof (unichar));
4278
      (yyval.suni).s = h;
4279
      (yyval.suni).length = l;
4280
    }
4281
#line 4282 "rcparse.c"
4282
    break;
4283
4284
  case 244:
4285
#line 1811 "rcparse.y"
4286
          {
4287
      style |= (yyvsp[0].il);
4288
    }
4289
#line 4290 "rcparse.c"
4290
    break;
4291
4292
  case 245:
4293
#line 1815 "rcparse.y"
4294
          {
4295
      style &=~ (yyvsp[0].il);
4296
    }
4297
#line 4298 "rcparse.c"
4298
    break;
4299
4300
  case 246:
4301
#line 1819 "rcparse.y"
4302
          {
4303
      style |= (yyvsp[0].il);
4304
    }
4305
#line 4306 "rcparse.c"
4306
    break;
4307
4308
  case 247:
4309
#line 1823 "rcparse.y"
4310
          {
4311
      style &=~ (yyvsp[0].il);
4312
    }
4313
#line 4314 "rcparse.c"
4314
    break;
4315
4316
  case 248:
4317
#line 1830 "rcparse.y"
4318
          {
4319
      (yyval.il) = (yyvsp[0].i).val;
4320
    }
4321
#line 4322 "rcparse.c"
4322
    break;
4323
4324
  case 249:
4325
#line 1834 "rcparse.y"
4326
          {
4327
      (yyval.il) = (yyvsp[-1].il);
4328
    }
4329
#line 4330 "rcparse.c"
4330
    break;
4331
4332
  case 250:
4333
#line 1843 "rcparse.y"
4334
          {
4335
      (yyval.il) = 0;
4336
    }
4337
#line 4338 "rcparse.c"
4338
    break;
4339
4340
  case 251:
4341
#line 1847 "rcparse.y"
4342
          {
4343
      (yyval.il) = (yyvsp[0].il);
4344
    }
4345
#line 4346 "rcparse.c"
4346
    break;
4347
4348
  case 252:
4349
#line 1856 "rcparse.y"
4350
          {
4351
      (yyval.il) = (yyvsp[0].il);
4352
    }
4353
#line 4354 "rcparse.c"
4354
    break;
4355
4356
  case 253:
4357
#line 1865 "rcparse.y"
4358
          {
4359
      (yyval.il) = (yyvsp[0].i).val;
4360
    }
4361
#line 4362 "rcparse.c"
4362
    break;
4363
4364
  case 254:
4365
#line 1874 "rcparse.y"
4366
          {
4367
      (yyval.i) = (yyvsp[0].i);
4368
    }
4369
#line 4370 "rcparse.c"
4370
    break;
4371
4372
  case 255:
4373
#line 1878 "rcparse.y"
4374
          {
4375
      (yyval.i) = (yyvsp[-1].i);
4376
    }
4377
#line 4378 "rcparse.c"
4378
    break;
4379
4380
  case 256:
4381
#line 1882 "rcparse.y"
4382
          {
4383
      (yyval.i).val = ~ (yyvsp[0].i).val;
4384
      (yyval.i).dword = (yyvsp[0].i).dword;
4385
    }
4386
#line 4387 "rcparse.c"
4387
    break;
4388
4389
  case 257:
4390
#line 1887 "rcparse.y"
4391
          {
4392
      (yyval.i).val = - (yyvsp[0].i).val;
4393
      (yyval.i).dword = (yyvsp[0].i).dword;
4394
    }
4395
#line 4396 "rcparse.c"
4396
    break;
4397
4398
  case 258:
4399
#line 1892 "rcparse.y"
4400
          {
4401
      (yyval.i).val = (yyvsp[-2].i).val * (yyvsp[0].i).val;
4402
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4403
    }
4404
#line 4405 "rcparse.c"
4405
    break;
4406
4407
  case 259:
4408
#line 1897 "rcparse.y"
4409
          {
4410
      (yyval.i).val = (yyvsp[-2].i).val / ((yyvsp[0].i).val ? (yyvsp[0].i).val : 1);
4411
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4412
    }
4413
#line 4414 "rcparse.c"
4414
    break;
4415
4416
  case 260:
4417
#line 1902 "rcparse.y"
4418
          {
4419
      (yyval.i).val = (yyvsp[-2].i).val % ((yyvsp[0].i).val ? (yyvsp[0].i).val : 1);
4420
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4421
    }
4422
#line 4423 "rcparse.c"
4423
    break;
4424
4425
  case 261:
4426
#line 1907 "rcparse.y"
4427
          {
4428
      (yyval.i).val = (yyvsp[-2].i).val + (yyvsp[0].i).val;
4429
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4430
    }
4431
#line 4432 "rcparse.c"
4432
    break;
4433
4434
  case 262:
4435
#line 1912 "rcparse.y"
4436
          {
4437
      (yyval.i).val = (yyvsp[-2].i).val - (yyvsp[0].i).val;
4438
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4439
    }
4440
#line 4441 "rcparse.c"
4441
    break;
4442
4443
  case 263:
4444
#line 1917 "rcparse.y"
4445
          {
4446
      (yyval.i).val = (yyvsp[-2].i).val & (yyvsp[0].i).val;
4447
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4448
    }
4449
#line 4450 "rcparse.c"
4450
    break;
4451
4452
  case 264:
4453
#line 1922 "rcparse.y"
4454
          {
4455
      (yyval.i).val = (yyvsp[-2].i).val ^ (yyvsp[0].i).val;
4456
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4457
    }
4458
#line 4459 "rcparse.c"
4459
    break;
4460
4461
  case 265:
4462
#line 1927 "rcparse.y"
4463
          {
4464
      (yyval.i).val = (yyvsp[-2].i).val | (yyvsp[0].i).val;
4465
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4466
    }
4467
#line 4468 "rcparse.c"
4468
    break;
4469
4470
  case 266:
4471
#line 1938 "rcparse.y"
4472
          {
4473
      (yyval.il) = (yyvsp[0].il);
4474
    }
4475
#line 4476 "rcparse.c"
4476
    break;
4477
4478
  case 267:
4479
#line 1947 "rcparse.y"
4480
          {
4481
      (yyval.il) = (yyvsp[0].i).val;
4482
    }
4483
#line 4484 "rcparse.c"
4484
    break;
4485
4486
  case 268:
4487
#line 1958 "rcparse.y"
4488
          {
4489
      (yyval.i) = (yyvsp[0].i);
4490
    }
4491
#line 4492 "rcparse.c"
4492
    break;
4493
4494
  case 269:
4495
#line 1962 "rcparse.y"
4496
          {
4497
      (yyval.i) = (yyvsp[-1].i);
4498
    }
4499
#line 4500 "rcparse.c"
4500
    break;
4501
4502
  case 270:
4503
#line 1966 "rcparse.y"
4504
          {
4505
      (yyval.i).val = ~ (yyvsp[0].i).val;
4506
      (yyval.i).dword = (yyvsp[0].i).dword;
4507
    }
4508
#line 4509 "rcparse.c"
4509
    break;
4510
4511
  case 271:
4512
#line 1971 "rcparse.y"
4513
          {
4514
      (yyval.i).val = (yyvsp[-2].i).val * (yyvsp[0].i).val;
4515
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4516
    }
4517
#line 4518 "rcparse.c"
4518
    break;
4519
4520
  case 272:
4521
#line 1976 "rcparse.y"
4522
          {
4523
      (yyval.i).val = (yyvsp[-2].i).val / ((yyvsp[0].i).val ? (yyvsp[0].i).val : 1);
4524
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4525
    }
4526
#line 4527 "rcparse.c"
4527
    break;
4528
4529
  case 273:
4530
#line 1981 "rcparse.y"
4531
          {
4532
      /* PR 17512: file: 89105a25.  */
4533
      (yyval.i).val = (yyvsp[-2].i).val % ((yyvsp[0].i).val ? (yyvsp[0].i).val : 1);
4534
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4535
    }
4536
#line 4537 "rcparse.c"
4537
    break;
4538
4539
  case 274:
4540
#line 1987 "rcparse.y"
4541
          {
4542
      (yyval.i).val = (yyvsp[-2].i).val + (yyvsp[0].i).val;
4543
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4544
    }
4545
#line 4546 "rcparse.c"
4546
    break;
4547
4548
  case 275:
4549
#line 1992 "rcparse.y"
4550
          {
4551
      (yyval.i).val = (yyvsp[-2].i).val - (yyvsp[0].i).val;
4552
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4553
    }
4554
#line 4555 "rcparse.c"
4555
    break;
4556
4557
  case 276:
4558
#line 1997 "rcparse.y"
4559
          {
4560
      (yyval.i).val = (yyvsp[-2].i).val & (yyvsp[0].i).val;
4561
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4562
    }
4563
#line 4564 "rcparse.c"
4564
    break;
4565
4566
  case 277:
4567
#line 2002 "rcparse.y"
4568
          {
4569
      (yyval.i).val = (yyvsp[-2].i).val ^ (yyvsp[0].i).val;
4570
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4571
    }
4572
#line 4573 "rcparse.c"
4573
    break;
4574
4575
  case 278:
4576
#line 2007 "rcparse.y"
4577
          {
4578
      (yyval.i).val = (yyvsp[-2].i).val | (yyvsp[0].i).val;
4579
      (yyval.i).dword = (yyvsp[-2].i).dword || (yyvsp[0].i).dword;
4580
    }
4581
#line 4582 "rcparse.c"
4582
    break;
4583
4584
4585
#line 4586 "rcparse.c"
4586
4587
      default: break;
4588
    }
4589
  /* User semantic actions sometimes alter yychar, and that requires
4590
     that yytoken be updated with the new translation.  We take the
4591
     approach of translating immediately before every use of yytoken.
4592
     One alternative is translating here after every semantic action,
4593
     but that translation would be missed if the semantic action invokes
4594
     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
4595
     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
4596
     incorrect destructor might then be invoked immediately.  In the
4597
     case of YYERROR or YYBACKUP, subsequent parser actions might lead
4598
     to an incorrect destructor call or verbose syntax error message
4599
     before the lookahead is translated.  */
4600
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4601
4602
  YYPOPSTACK (yylen);
4603
  yylen = 0;
4604
  YY_STACK_PRINT (yyss, yyssp);
4605
4606
  *++yyvsp = yyval;
4607
4608
  /* Now 'shift' the result of the reduction.  Determine what state
4609
     that goes to, based on the state we popped back to and the rule
4610
     number reduced by.  */
4611
  {
4612
    const int yylhs = yyr1[yyn] - YYNTOKENS;
4613
    const int yyi = yypgoto[yylhs] + *yyssp;
4614
    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
4615
               ? yytable[yyi]
4616
               : yydefgoto[yylhs]);
4617
  }
4618
4619
  goto yynewstate;
4620
4621
4622
/*--------------------------------------.
4623
| yyerrlab -- here on detecting error.  |
4624
`--------------------------------------*/
4625
yyerrlab:
4626
  /* Make sure we have latest lookahead translation.  See comments at
4627
     user semantic actions for why this is necessary.  */
4628
  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
4629
4630
  /* If not already recovering from an error, report this error.  */
4631
  if (!yyerrstatus)
4632
    {
4633
      ++yynerrs;
4634
#if ! YYERROR_VERBOSE
4635
      yyerror (YY_("syntax error"));
4636
#else
4637
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
4638
                                        yyssp, yytoken)
4639
      {
4640
        char const *yymsgp = YY_("syntax error");
4641
        int yysyntax_error_status;
4642
        yysyntax_error_status = YYSYNTAX_ERROR;
4643
        if (yysyntax_error_status == 0)
4644
          yymsgp = yymsg;
4645
        else if (yysyntax_error_status == 1)
4646
          {
4647
            if (yymsg != yymsgbuf)
4648
              YYSTACK_FREE (yymsg);
4649
            yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
4650
            if (!yymsg)
4651
              {
4652
                yymsg = yymsgbuf;
4653
                yymsg_alloc = sizeof yymsgbuf;
4654
                yysyntax_error_status = 2;
4655
              }
4656
            else
4657
              {
4658
                yysyntax_error_status = YYSYNTAX_ERROR;
4659
                yymsgp = yymsg;
4660
              }
4661
          }
4662
        yyerror (yymsgp);
4663
        if (yysyntax_error_status == 2)
4664
          goto yyexhaustedlab;
4665
      }
4666
# undef YYSYNTAX_ERROR
4667
#endif
4668
    }
4669
4670
4671
4672
  if (yyerrstatus == 3)
4673
    {
4674
      /* If just tried and failed to reuse lookahead token after an
4675
         error, discard it.  */
4676
4677
      if (yychar <= YYEOF)
4678
        {
4679
          /* Return failure if at end of input.  */
4680
          if (yychar == YYEOF)
4681
            YYABORT;
4682
        }
4683
      else
4684
        {
4685
          yydestruct ("Error: discarding",
4686
                      yytoken, &yylval);
4687
          yychar = YYEMPTY;
4688
        }
4689
    }
4690
4691
  /* Else will try to reuse lookahead token after shifting the error
4692
     token.  */
4693
  goto yyerrlab1;
4694
4695
4696
/*---------------------------------------------------.
4697
| yyerrorlab -- error raised explicitly by YYERROR.  |
4698
`---------------------------------------------------*/
4699
yyerrorlab:
4700
  /* Pacify compilers when the user code never invokes YYERROR and the
4701
     label yyerrorlab therefore never appears in user code.  */
4702
  if (0)
4703
    YYERROR;
4704
4705
  /* Do not reclaim the symbols of the rule whose action triggered
4706
     this YYERROR.  */
4707
  YYPOPSTACK (yylen);
4708
  yylen = 0;
4709
  YY_STACK_PRINT (yyss, yyssp);
4710
  yystate = *yyssp;
4711
  goto yyerrlab1;
4712
4713
4714
/*-------------------------------------------------------------.
4715
| yyerrlab1 -- common code for both syntax error and YYERROR.  |
4716
`-------------------------------------------------------------*/
4717
yyerrlab1:
4718
  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
4719
4720
  for (;;)
4721
    {
4722
      yyn = yypact[yystate];
4723
      if (!yypact_value_is_default (yyn))
4724
        {
4725
          yyn += YYTERROR;
4726
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4727
            {
4728
              yyn = yytable[yyn];
4729
              if (0 < yyn)
4730
                break;
4731
            }
4732
        }
4733
4734
      /* Pop the current state because it cannot handle the error token.  */
4735
      if (yyssp == yyss)
4736
        YYABORT;
4737
4738
4739
      yydestruct ("Error: popping",
4740
                  yystos[yystate], yyvsp);
4741
      YYPOPSTACK (1);
4742
      yystate = *yyssp;
4743
      YY_STACK_PRINT (yyss, yyssp);
4744
    }
4745
4746
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
4747
  *++yyvsp = yylval;
4748
  YY_IGNORE_MAYBE_UNINITIALIZED_END
4749
4750
4751
  /* Shift the error token.  */
4752
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4753
4754
  yystate = yyn;
4755
  goto yynewstate;
4756
4757
4758
/*-------------------------------------.
4759
| yyacceptlab -- YYACCEPT comes here.  |
4760
`-------------------------------------*/
4761
yyacceptlab:
4762
  yyresult = 0;
4763
  goto yyreturn;
4764
4765
4766
/*-----------------------------------.
4767
| yyabortlab -- YYABORT comes here.  |
4768
`-----------------------------------*/
4769
yyabortlab:
4770
  yyresult = 1;
4771
  goto yyreturn;
4772
4773
4774
#if !defined yyoverflow || YYERROR_VERBOSE
4775
/*-------------------------------------------------.
4776
| yyexhaustedlab -- memory exhaustion comes here.  |
4777
`-------------------------------------------------*/
4778
yyexhaustedlab:
4779
  yyerror (YY_("memory exhausted"));
4780
  yyresult = 2;
4781
  /* Fall through.  */
4782
#endif
4783
4784
4785
/*-----------------------------------------------------.
4786
| yyreturn -- parsing is finished, return the result.  |
4787
`-----------------------------------------------------*/
4788
yyreturn:
4789
  if (yychar != YYEMPTY)
4790
    {
4791
      /* Make sure we have latest lookahead translation.  See comments at
4792
         user semantic actions for why this is necessary.  */
4793
      yytoken = YYTRANSLATE (yychar);
4794
      yydestruct ("Cleanup: discarding lookahead",
4795
                  yytoken, &yylval);
4796
    }
4797
  /* Do not reclaim the symbols of the rule whose action triggered
4798
     this YYABORT or YYACCEPT.  */
4799
  YYPOPSTACK (yylen);
4800
  YY_STACK_PRINT (yyss, yyssp);
4801
  while (yyssp != yyss)
4802
    {
4803
      yydestruct ("Cleanup: popping",
4804
                  yystos[+*yyssp], yyvsp);
4805
      YYPOPSTACK (1);
4806
    }
4807
#ifndef yyoverflow
4808
  if (yyss != yyssa)
4809
    YYSTACK_FREE (yyss);
4810
#endif
4811
#if YYERROR_VERBOSE
4812
  if (yymsg != yymsgbuf)
4813
    YYSTACK_FREE (yymsg);
4814
#endif
4815
  return yyresult;
4816
}
4817
#line 2013 "rcparse.y"
4818
4819
4820
/* Set the language from the command line.  */
4821
4822
void
4823
rcparse_set_language (int lang)
4824
0
{
4825
0
  language = lang;
4826
0
}