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