OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [binutils/] [rcparse.c] - Blame information for rev 281

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.