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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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