GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/gdb/f-exp.c
Go to the documentation of this file.
1/* A Bison parser, made by GNU Bison 3.8.2. */
2
3/* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 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 <https://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/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
38 especially those whose name start with YY_ or yy_. They are
39 private implementation details that can be changed or removed. */
40
41/* All symbols defined below should begin with yy or YY, to avoid
42 infringing on user name space. This should be done even for local
43 variables, as they might otherwise be expanded by user macros.
44 There are some unavoidable exceptions within include files to
45 define necessary library symbols; they are noted "INFRINGES ON
46 USER NAME SPACE" below. */
47
48/* Identify Bison output, and Bison version. */
49#define YYBISON 30802
50
51/* Bison version string. */
52#define YYBISON_VERSION "3.8.2"
53
54/* Skeleton name. */
55#define YYSKELETON_NAME "yacc.c"
56
57/* Pure parsers. */
58#define YYPURE 0
59
60/* Push parsers. */
61#define YYPUSH 0
62
63/* Pull parsers. */
64#define YYPULL 1
65
66
67
68
69/* First part of user prologue. */
70#line 43 "f-exp.y"
71
72
73#include "defs.h"
74#include "expression.h"
75#include "value.h"
76#include "parser-defs.h"
77#include "language.h"
78#include "f-lang.h"
79#include "bfd.h" /* Required by objfiles.h. */
80#include "symfile.h" /* Required by objfiles.h. */
81#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
82#include "block.h"
83#include <ctype.h>
84#include <algorithm>
85#include "type-stack.h"
86#include "f-exp.h"
87
88#define parse_type(ps) builtin_type (ps->gdbarch ())
89#define parse_f_type(ps) builtin_f_type (ps->gdbarch ())
90
91/* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
92 etc). */
93#define GDB_YY_REMAP_PREFIX f_
94#include "yy-remap.h"
95
96/* The state of the parser, used internally when we are parsing the
97 expression. */
98
99static struct parser_state *pstate = NULL;
100
101/* Depth of parentheses. */
102static int paren_depth;
103
104/* The current type stack. */
105static struct type_stack *type_stack;
106
107int yyparse (void);
108
109static int yylex (void);
110
111static void yyerror (const char *);
112
113static void growbuf_by_size (int);
114
115static int match_string_literal (void);
116
117static void push_kind_type (LONGEST val, struct type *type);
118
119static struct type *convert_to_kind_type (struct type *basetype, int kind);
120
121static void wrap_unop_intrinsic (exp_opcode opcode);
122
123static void wrap_binop_intrinsic (exp_opcode opcode);
124
125static void wrap_ternop_intrinsic (exp_opcode opcode);
126
127template<typename T>
128static void fortran_wrap2_kind (type *base_type);
129
130template<typename T>
131static void fortran_wrap3_kind (type *base_type);
132
133using namespace expr;
134
135#line 136 "f-exp.c.tmp"
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_NULLPTRPTR
147# if defined __cplusplus
148# if 201103L <= __cplusplus
149# define YY_NULLPTRPTR nullptr
150# else
151# define YY_NULLPTRPTR 0
152# endif
153# else
154# define YY_NULLPTRPTR ((void*)0)
155# endif
156# endif
157
158
159/* Debug traces. */
160#ifndef YYDEBUG
161# define YYDEBUG 0
162#endif
163#if YYDEBUG
164extern int yydebug;
165#endif
166
167/* Token kinds. */
168#ifndef YYTOKENTYPE
169# define YYTOKENTYPE
171 {
173 YYEOF = 0, /* "end of file" */
174 YYerror = 256, /* error */
175 YYUNDEF = 257, /* "invalid token" */
176 INT = 258, /* INT */
177 FLOAT = 259, /* FLOAT */
178 STRING_LITERAL = 260, /* STRING_LITERAL */
179 BOOLEAN_LITERAL = 261, /* BOOLEAN_LITERAL */
180 NAME = 262, /* NAME */
181 TYPENAME = 263, /* TYPENAME */
182 COMPLETE = 264, /* COMPLETE */
183 NAME_OR_INT = 265, /* NAME_OR_INT */
184 SIZEOF = 266, /* SIZEOF */
185 KIND = 267, /* KIND */
186 ERROR = 268, /* ERROR */
187 INT_S1_KEYWORD = 269, /* INT_S1_KEYWORD */
188 INT_S2_KEYWORD = 270, /* INT_S2_KEYWORD */
189 INT_KEYWORD = 271, /* INT_KEYWORD */
190 INT_S4_KEYWORD = 272, /* INT_S4_KEYWORD */
191 INT_S8_KEYWORD = 273, /* INT_S8_KEYWORD */
192 LOGICAL_S1_KEYWORD = 274, /* LOGICAL_S1_KEYWORD */
193 LOGICAL_S2_KEYWORD = 275, /* LOGICAL_S2_KEYWORD */
194 LOGICAL_KEYWORD = 276, /* LOGICAL_KEYWORD */
195 LOGICAL_S4_KEYWORD = 277, /* LOGICAL_S4_KEYWORD */
196 LOGICAL_S8_KEYWORD = 278, /* LOGICAL_S8_KEYWORD */
197 REAL_KEYWORD = 279, /* REAL_KEYWORD */
198 REAL_S4_KEYWORD = 280, /* REAL_S4_KEYWORD */
199 REAL_S8_KEYWORD = 281, /* REAL_S8_KEYWORD */
200 REAL_S16_KEYWORD = 282, /* REAL_S16_KEYWORD */
201 COMPLEX_KEYWORD = 283, /* COMPLEX_KEYWORD */
202 COMPLEX_S4_KEYWORD = 284, /* COMPLEX_S4_KEYWORD */
203 COMPLEX_S8_KEYWORD = 285, /* COMPLEX_S8_KEYWORD */
204 COMPLEX_S16_KEYWORD = 286, /* COMPLEX_S16_KEYWORD */
205 BOOL_AND = 287, /* BOOL_AND */
206 BOOL_OR = 288, /* BOOL_OR */
207 BOOL_NOT = 289, /* BOOL_NOT */
208 SINGLE = 290, /* SINGLE */
209 DOUBLE = 291, /* DOUBLE */
210 PRECISION = 292, /* PRECISION */
211 CHARACTER = 293, /* CHARACTER */
212 DOLLAR_VARIABLE = 294, /* DOLLAR_VARIABLE */
213 ASSIGN_MODIFY = 295, /* ASSIGN_MODIFY */
214 UNOP_INTRINSIC = 296, /* UNOP_INTRINSIC */
215 BINOP_INTRINSIC = 297, /* BINOP_INTRINSIC */
216 UNOP_OR_BINOP_INTRINSIC = 298, /* UNOP_OR_BINOP_INTRINSIC */
217 UNOP_OR_BINOP_OR_TERNOP_INTRINSIC = 299, /* UNOP_OR_BINOP_OR_TERNOP_INTRINSIC */
218 ABOVE_COMMA = 300, /* ABOVE_COMMA */
219 EQUAL = 301, /* EQUAL */
220 NOTEQUAL = 302, /* NOTEQUAL */
221 LESSTHAN = 303, /* LESSTHAN */
222 GREATERTHAN = 304, /* GREATERTHAN */
223 LEQ = 305, /* LEQ */
224 GEQ = 306, /* GEQ */
225 LSH = 307, /* LSH */
226 RSH = 308, /* RSH */
227 STARSTAR = 309, /* STARSTAR */
228 UNARY = 310 /* UNARY */
229 };
231#endif
232/* Token kinds. */
233#define YYEMPTY -2
234#define YYEOF 0
235#define YYerror 256
236#define YYUNDEF 257
237#define INT 258
238#define FLOAT 259
239#define STRING_LITERAL 260
240#define BOOLEAN_LITERAL 261
241#define NAME 262
242#define TYPENAME 263
243#define COMPLETE 264
244#define NAME_OR_INT 265
245#define SIZEOF 266
246#define KIND 267
247#define ERROR 268
248#define INT_S1_KEYWORD 269
249#define INT_S2_KEYWORD 270
250#define INT_KEYWORD 271
251#define INT_S4_KEYWORD 272
252#define INT_S8_KEYWORD 273
253#define LOGICAL_S1_KEYWORD 274
254#define LOGICAL_S2_KEYWORD 275
255#define LOGICAL_KEYWORD 276
256#define LOGICAL_S4_KEYWORD 277
257#define LOGICAL_S8_KEYWORD 278
258#define REAL_KEYWORD 279
259#define REAL_S4_KEYWORD 280
260#define REAL_S8_KEYWORD 281
261#define REAL_S16_KEYWORD 282
262#define COMPLEX_KEYWORD 283
263#define COMPLEX_S4_KEYWORD 284
264#define COMPLEX_S8_KEYWORD 285
265#define COMPLEX_S16_KEYWORD 286
266#define BOOL_AND 287
267#define BOOL_OR 288
268#define BOOL_NOT 289
269#define SINGLE 290
270#define DOUBLE 291
271#define PRECISION 292
272#define CHARACTER 293
273#define DOLLAR_VARIABLE 294
274#define ASSIGN_MODIFY 295
275#define UNOP_INTRINSIC 296
276#define BINOP_INTRINSIC 297
277#define UNOP_OR_BINOP_INTRINSIC 298
278#define UNOP_OR_BINOP_OR_TERNOP_INTRINSIC 299
279#define ABOVE_COMMA 300
280#define EQUAL 301
281#define NOTEQUAL 302
282#define LESSTHAN 303
283#define GREATERTHAN 304
284#define LEQ 305
285#define GEQ 306
286#define LSH 307
287#define RSH 308
288#define STARSTAR 309
289#define UNARY 310
290
291/* Value type. */
292#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
293union YYSTYPE
294{
295#line 113 "f-exp.y"
296
297 LONGEST lval;
298 struct {
299 LONGEST val;
300 struct type *type;
302 struct {
303 gdb_byte val[16];
304 struct type *type;
306 struct symbol *sym;
307 struct type *tval;
308 struct stoken sval;
309 struct ttype tsym;
310 struct symtoken ssym;
311 int voidval;
312 enum exp_opcode opcode;
313 struct internalvar *ivar;
314
315 struct type **tvec;
316 int *ivec;
317
318
319#line 320 "f-exp.c.tmp"
320
321};
322typedef union YYSTYPE YYSTYPE;
323# define YYSTYPE_IS_TRIVIAL 1
324# define YYSTYPE_IS_DECLARED 1
325#endif
326
327
328extern YYSTYPE yylval;
329
330
331int yyparse (void);
332
333
334
335/* Symbol kind. */
337{
339 YYSYMBOL_YYEOF = 0, /* "end of file" */
340 YYSYMBOL_YYerror = 1, /* error */
341 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
342 YYSYMBOL_INT = 3, /* INT */
343 YYSYMBOL_FLOAT = 4, /* FLOAT */
344 YYSYMBOL_STRING_LITERAL = 5, /* STRING_LITERAL */
345 YYSYMBOL_BOOLEAN_LITERAL = 6, /* BOOLEAN_LITERAL */
346 YYSYMBOL_NAME = 7, /* NAME */
347 YYSYMBOL_TYPENAME = 8, /* TYPENAME */
348 YYSYMBOL_COMPLETE = 9, /* COMPLETE */
349 YYSYMBOL_NAME_OR_INT = 10, /* NAME_OR_INT */
350 YYSYMBOL_SIZEOF = 11, /* SIZEOF */
351 YYSYMBOL_KIND = 12, /* KIND */
352 YYSYMBOL_ERROR = 13, /* ERROR */
353 YYSYMBOL_INT_S1_KEYWORD = 14, /* INT_S1_KEYWORD */
354 YYSYMBOL_INT_S2_KEYWORD = 15, /* INT_S2_KEYWORD */
355 YYSYMBOL_INT_KEYWORD = 16, /* INT_KEYWORD */
356 YYSYMBOL_INT_S4_KEYWORD = 17, /* INT_S4_KEYWORD */
357 YYSYMBOL_INT_S8_KEYWORD = 18, /* INT_S8_KEYWORD */
358 YYSYMBOL_LOGICAL_S1_KEYWORD = 19, /* LOGICAL_S1_KEYWORD */
359 YYSYMBOL_LOGICAL_S2_KEYWORD = 20, /* LOGICAL_S2_KEYWORD */
360 YYSYMBOL_LOGICAL_KEYWORD = 21, /* LOGICAL_KEYWORD */
361 YYSYMBOL_LOGICAL_S4_KEYWORD = 22, /* LOGICAL_S4_KEYWORD */
362 YYSYMBOL_LOGICAL_S8_KEYWORD = 23, /* LOGICAL_S8_KEYWORD */
363 YYSYMBOL_REAL_KEYWORD = 24, /* REAL_KEYWORD */
364 YYSYMBOL_REAL_S4_KEYWORD = 25, /* REAL_S4_KEYWORD */
365 YYSYMBOL_REAL_S8_KEYWORD = 26, /* REAL_S8_KEYWORD */
366 YYSYMBOL_REAL_S16_KEYWORD = 27, /* REAL_S16_KEYWORD */
367 YYSYMBOL_COMPLEX_KEYWORD = 28, /* COMPLEX_KEYWORD */
368 YYSYMBOL_COMPLEX_S4_KEYWORD = 29, /* COMPLEX_S4_KEYWORD */
369 YYSYMBOL_COMPLEX_S8_KEYWORD = 30, /* COMPLEX_S8_KEYWORD */
370 YYSYMBOL_COMPLEX_S16_KEYWORD = 31, /* COMPLEX_S16_KEYWORD */
371 YYSYMBOL_BOOL_AND = 32, /* BOOL_AND */
372 YYSYMBOL_BOOL_OR = 33, /* BOOL_OR */
373 YYSYMBOL_BOOL_NOT = 34, /* BOOL_NOT */
374 YYSYMBOL_SINGLE = 35, /* SINGLE */
375 YYSYMBOL_DOUBLE = 36, /* DOUBLE */
376 YYSYMBOL_PRECISION = 37, /* PRECISION */
377 YYSYMBOL_CHARACTER = 38, /* CHARACTER */
378 YYSYMBOL_DOLLAR_VARIABLE = 39, /* DOLLAR_VARIABLE */
379 YYSYMBOL_ASSIGN_MODIFY = 40, /* ASSIGN_MODIFY */
380 YYSYMBOL_UNOP_INTRINSIC = 41, /* UNOP_INTRINSIC */
381 YYSYMBOL_BINOP_INTRINSIC = 42, /* BINOP_INTRINSIC */
382 YYSYMBOL_UNOP_OR_BINOP_INTRINSIC = 43, /* UNOP_OR_BINOP_INTRINSIC */
383 YYSYMBOL_UNOP_OR_BINOP_OR_TERNOP_INTRINSIC = 44, /* UNOP_OR_BINOP_OR_TERNOP_INTRINSIC */
384 YYSYMBOL_45_ = 45, /* ',' */
385 YYSYMBOL_ABOVE_COMMA = 46, /* ABOVE_COMMA */
386 YYSYMBOL_47_ = 47, /* '=' */
387 YYSYMBOL_48_ = 48, /* '?' */
388 YYSYMBOL_49_ = 49, /* '|' */
389 YYSYMBOL_50_ = 50, /* '^' */
390 YYSYMBOL_51_ = 51, /* '&' */
391 YYSYMBOL_EQUAL = 52, /* EQUAL */
392 YYSYMBOL_NOTEQUAL = 53, /* NOTEQUAL */
393 YYSYMBOL_LESSTHAN = 54, /* LESSTHAN */
394 YYSYMBOL_GREATERTHAN = 55, /* GREATERTHAN */
395 YYSYMBOL_LEQ = 56, /* LEQ */
396 YYSYMBOL_GEQ = 57, /* GEQ */
397 YYSYMBOL_LSH = 58, /* LSH */
398 YYSYMBOL_RSH = 59, /* RSH */
399 YYSYMBOL_60_ = 60, /* '@' */
400 YYSYMBOL_61_ = 61, /* '+' */
401 YYSYMBOL_62_ = 62, /* '-' */
402 YYSYMBOL_63_ = 63, /* '*' */
403 YYSYMBOL_64_ = 64, /* '/' */
404 YYSYMBOL_STARSTAR = 65, /* STARSTAR */
405 YYSYMBOL_66_ = 66, /* '%' */
406 YYSYMBOL_UNARY = 67, /* UNARY */
407 YYSYMBOL_68_ = 68, /* '(' */
408 YYSYMBOL_69_ = 69, /* ')' */
409 YYSYMBOL_70_ = 70, /* '~' */
410 YYSYMBOL_71_ = 71, /* ':' */
411 YYSYMBOL_YYACCEPT = 72, /* $accept */
412 YYSYMBOL_start = 73, /* start */
413 YYSYMBOL_type_exp = 74, /* type_exp */
414 YYSYMBOL_exp = 75, /* exp */
415 YYSYMBOL_76_1 = 76, /* $@1 */
416 YYSYMBOL_77_2 = 77, /* $@2 */
417 YYSYMBOL_78_3 = 78, /* $@3 */
418 YYSYMBOL_arglist = 79, /* arglist */
419 YYSYMBOL_subrange = 80, /* subrange */
420 YYSYMBOL_complexnum = 81, /* complexnum */
421 YYSYMBOL_variable = 82, /* variable */
422 YYSYMBOL_type = 83, /* type */
423 YYSYMBOL_ptype = 84, /* ptype */
424 YYSYMBOL_abs_decl = 85, /* abs_decl */
425 YYSYMBOL_direct_abs_decl = 86, /* direct_abs_decl */
426 YYSYMBOL_func_mod = 87, /* func_mod */
427 YYSYMBOL_typebase = 88, /* typebase */
428 YYSYMBOL_nonempty_typelist = 89, /* nonempty_typelist */
429 YYSYMBOL_name = 90, /* name */
430 YYSYMBOL_name_not_typename = 91 /* name_not_typename */
433
434
435/* Second part of user prologue. */
436#line 136 "f-exp.y"
437
438/* YYSTYPE gets defined by %union */
439static int parse_number (struct parser_state *, const char *, int,
440 int, YYSTYPE *);
441
442#line 443 "f-exp.c.tmp"
443
444
445#ifdef short
446# undef short
447#endif
448
449/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
450 <limits.h> and (if available) <stdint.h> are included
451 so that the code can choose integer types of a good width. */
452
453#ifndef __PTRDIFF_MAX__
454# include <limits.h> /* INFRINGES ON USER NAME SPACE */
455# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
456# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
457# define YY_STDINT_H
458# endif
459#endif
460
461/* Narrow types that promote to a signed type and that can represent a
462 signed or unsigned integer of at least N bits. In tables they can
463 save space and decrease cache pressure. Promoting to a signed type
464 helps avoid bugs in integer arithmetic. */
465
466#ifdef __INT_LEAST8_MAX__
467typedef __INT_LEAST8_TYPE__ yytype_int8;
468#elif defined YY_STDINT_H
469typedef int_least8_t yytype_int8;
470#else
471typedef signed char yytype_int8;
472#endif
473
474#ifdef __INT_LEAST16_MAX__
475typedef __INT_LEAST16_TYPE__ yytype_int16;
476#elif defined YY_STDINT_H
477typedef int_least16_t yytype_int16;
478#else
479typedef short yytype_int16;
480#endif
481
482/* Work around bug in HP-UX 11.23, which defines these macros
483 incorrectly for preprocessor constants. This workaround can likely
484 be removed in 2023, as HPE has promised support for HP-UX 11.23
485 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
486 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
487#ifdef __hpux
488# undef UINT_LEAST8_MAX
489# undef UINT_LEAST16_MAX
490# define UINT_LEAST8_MAX 255
491# define UINT_LEAST16_MAX 65535
492#endif
493
494#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
495typedef __UINT_LEAST8_TYPE__ yytype_uint8;
496#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
497 && UINT_LEAST8_MAX <= INT_MAX)
498typedef uint_least8_t yytype_uint8;
499#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
500typedef unsigned char yytype_uint8;
501#else
502typedef short yytype_uint8;
503#endif
504
505#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
506typedef __UINT_LEAST16_TYPE__ yytype_uint16;
507#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
508 && UINT_LEAST16_MAX <= INT_MAX)
509typedef uint_least16_t yytype_uint16;
510#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
511typedef unsigned short yytype_uint16;
512#else
513typedef int yytype_uint16;
514#endif
515
516#ifndef YYPTRDIFF_T
517# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
518# define YYPTRDIFF_T __PTRDIFF_TYPE__
519# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
520# elif defined PTRDIFF_MAX
521# ifndef ptrdiff_t
522# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
523# endif
524# define YYPTRDIFF_T ptrdiff_t
525# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
526# else
527# define YYPTRDIFF_T long
528# define YYPTRDIFF_MAXIMUM LONG_MAX
529# endif
530#endif
531
532#ifndef YYSIZE_T
533# ifdef __SIZE_TYPE__
534# define YYSIZE_T __SIZE_TYPE__
535# elif defined size_t
536# define YYSIZE_T size_t
537# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
538# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
539# define YYSIZE_T size_t
540# else
541# define YYSIZE_T unsigned
542# endif
543#endif
544
545#define YYSIZE_MAXIMUM \
546 YY_CAST (YYPTRDIFF_T, \
547 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
548 ? YYPTRDIFF_MAXIMUM \
549 : YY_CAST (YYSIZE_T, -1)))
550
551#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
552
553
554/* Stored state numbers (used for stacks). */
556
557/* State numbers in computations. */
558typedef int yy_state_fast_t;
559
560#ifndef YY_
561# if defined YYENABLE_NLS && YYENABLE_NLS
562# if ENABLE_NLS
563# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
564# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
565# endif
566# endif
567# ifndef YY_
568# define YY_(Msgid) Msgid
569# endif
570#endif
571
572
573#ifndef YY_ATTRIBUTE_PURE
574# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
575# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
576# else
577# define YY_ATTRIBUTE_PURE
578# endif
579#endif
580
581#ifndef YY_ATTRIBUTE_UNUSED
582# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
583# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
584# else
585# define YY_ATTRIBUTE_UNUSED
586# endif
587#endif
588
589/* Suppress unused-variable warnings by "using" E. */
590#if ! defined lint || defined __GNUC__
591# define YY_USE(E) ((void) (E))
592#else
593# define YY_USE(E) /* empty */
594#endif
595
596/* Suppress an incorrect diagnostic about yylval being uninitialized. */
597#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
598# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
599# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
600 _Pragma ("GCC diagnostic push") \
601 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
602# else
603# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
604 _Pragma ("GCC diagnostic push") \
605 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
606 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
607# endif
608# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
609 _Pragma ("GCC diagnostic pop")
610#else
611# define YY_INITIAL_VALUE(Value) Value
612#endif
613#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
614# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
615# define YY_IGNORE_MAYBE_UNINITIALIZED_END
616#endif
617#ifndef YY_INITIAL_VALUE
618# define YY_INITIAL_VALUE(Value) /* Nothing. */
619#endif
620
621#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
622# define YY_IGNORE_USELESS_CAST_BEGIN \
623 _Pragma ("GCC diagnostic push") \
624 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
625# define YY_IGNORE_USELESS_CAST_END \
626 _Pragma ("GCC diagnostic pop")
627#endif
628#ifndef YY_IGNORE_USELESS_CAST_BEGIN
629# define YY_IGNORE_USELESS_CAST_BEGIN
630# define YY_IGNORE_USELESS_CAST_END
631#endif
632
633
634#define YY_ASSERT(E) ((void) (0 && (E)))
635
636#if !defined yyoverflow
637
638/* The parser invokes alloca or xmalloc; define the necessary symbols. */
639
640# ifdef YYSTACK_USE_ALLOCA
641# if YYSTACK_USE_ALLOCA
642# ifdef __GNUC__
643# define YYSTACK_ALLOC __builtin_alloca
644# elif defined __BUILTIN_VA_ARG_INCR
645# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
646# elif defined _AIX
647# define YYSTACK_ALLOC __alloca
648# elif defined _MSC_VER
649# define alloca _alloca
650# else
651# define YYSTACK_ALLOC alloca
652# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
653# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
654 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
655# ifndef EXIT_SUCCESS
656# define EXIT_SUCCESS 0
657# endif
658# endif
659# endif
660# endif
661# endif
662
663# ifdef YYSTACK_ALLOC
664 /* Pacify GCC's 'empty if-body' warning. */
665# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
666# ifndef YYSTACK_ALLOC_MAXIMUM
667 /* The OS might guarantee only one guard page at the bottom of the stack,
668 and a page size can be as small as 4096 bytes. So we cannot safely
669 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
670 to allow for a few compiler-allocated temporary stack slots. */
671# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
672# endif
673# else
674# define YYSTACK_ALLOC YYMALLOC
675# define YYSTACK_FREE YYFREE
676# ifndef YYSTACK_ALLOC_MAXIMUM
677# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
678# endif
679# if (defined __cplusplus && ! defined EXIT_SUCCESS \
680 && ! ((defined YYMALLOC || defined xmalloc) \
681 && (defined YYFREE || defined xfree)))
682# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
683# ifndef EXIT_SUCCESS
684# define EXIT_SUCCESS 0
685# endif
686# endif
687# ifndef YYMALLOC
688# define YYMALLOC xmalloc
689# if ! defined xmalloc && ! defined EXIT_SUCCESS
690void *xmalloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
691# endif
692# endif
693# ifndef YYFREE
694# define YYFREE xfree
695# if ! defined xfree && ! defined EXIT_SUCCESS
696void xfree (void *); /* INFRINGES ON USER NAME SPACE */
697# endif
698# endif
699# endif
700#endif /* !defined yyoverflow */
701
702#if (! defined yyoverflow \
703 && (! defined __cplusplus \
704 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
705
706/* A type that is properly aligned for any stack member. */
707union yyalloc
708{
711};
712
713/* The size of the maximum gap between one aligned stack and the next. */
714# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
715
716/* The size of an array large to enough to hold all stacks, each with
717 N elements. */
718# define YYSTACK_BYTES(N) \
719 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
720 + YYSTACK_GAP_MAXIMUM)
721
722# define YYCOPY_NEEDED 1
723
724/* Relocate STACK from its old location to the new one. The
725 local variables YYSIZE and YYSTACKSIZE give the old and new number of
726 elements in the stack, and YYPTR gives the new location of the
727 stack. Advance YYPTR to a properly aligned location for the next
728 stack. */
729# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
730 do \
731 { \
732 YYPTRDIFF_T yynewbytes; \
733 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
734 Stack = &yyptr->Stack_alloc; \
735 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
736 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
737 } \
738 while (0)
739
740#endif
741
742#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
743/* Copy COUNT objects from SRC to DST. The source and destination do
744 not overlap. */
745# ifndef YYCOPY
746# if defined __GNUC__ && 1 < __GNUC__
747# define YYCOPY(Dst, Src, Count) \
748 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
749# else
750# define YYCOPY(Dst, Src, Count) \
751 do \
752 { \
753 YYPTRDIFF_T yyi; \
754 for (yyi = 0; yyi < (Count); yyi++) \
755 (Dst)[yyi] = (Src)[yyi]; \
756 } \
757 while (0)
758# endif
759# endif
760#endif /* !YYCOPY_NEEDED */
761
762/* YYFINAL -- State number of the termination state. */
763#define YYFINAL 69
764/* YYLAST -- Last index in YYTABLE. */
765#define YYLAST 924
766
767/* YYNTOKENS -- Number of terminals. */
768#define YYNTOKENS 72
769/* YYNNTS -- Number of nonterminals. */
770#define YYNNTS 20
771/* YYNRULES -- Number of rules. */
772#define YYNRULES 113
773/* YYNSTATES -- Number of states. */
774#define YYNSTATES 184
775
776/* YYMAXUTOK -- Last valid token kind. */
777#define YYMAXUTOK 310
778
779
780/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
781 as returned by yylex, with out-of-bounds checking. */
782#define YYTRANSLATE(YYX) \
783 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
784 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
785 : YYSYMBOL_YYUNDEF)
786
787/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
788 as returned by yylex. */
789static const yytype_int8 yytranslate[] =
790{
791 0, 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, 66, 51, 2,
795 68, 69, 63, 61, 45, 62, 2, 64, 2, 2,
796 2, 2, 2, 2, 2, 2, 2, 2, 71, 2,
797 2, 47, 2, 48, 60, 2, 2, 2, 2, 2,
798 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
799 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
800 2, 2, 2, 2, 50, 2, 2, 2, 2, 2,
801 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
802 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
803 2, 2, 2, 2, 49, 2, 70, 2, 2, 2,
804 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
805 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
806 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
807 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
808 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
809 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
810 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
811 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
812 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
813 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
814 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
815 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
816 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
817 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
818 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
819 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
820 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
821 46, 52, 53, 54, 55, 56, 57, 58, 59, 65,
822 67
823};
824
825#if YYDEBUG
826/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
827static const yytype_int16 yyrline[] =
828{
829 0, 222, 222, 223, 226, 230, 235, 239, 243, 247,
830 251, 255, 259, 269, 268, 279, 285, 292, 291, 312,
831 311, 335, 338, 342, 346, 350, 356, 366, 375, 384,
832 395, 407, 419, 431, 443, 447, 457, 464, 471, 481,
833 493, 497, 501, 505, 509, 513, 517, 521, 525, 529,
834 533, 537, 541, 545, 549, 553, 557, 561, 566, 570,
835 574, 583, 590, 600, 609, 612, 616, 625, 629, 636,
836 644, 647, 648, 699, 701, 703, 705, 707, 710, 712,
837 714, 716, 718, 722, 724, 729, 731, 733, 735, 737,
838 739, 741, 743, 745, 747, 749, 751, 753, 755, 757,
839 759, 761, 763, 765, 767, 769, 771, 773, 775, 780,
840 785, 793, 795, 799
841};
842#endif
843
845#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
846
847#if YYDEBUG || 0
848/* The user-facing name of the symbol whose (internal) number is
849 YYSYMBOL. No bounds checking. */
850static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
851
852/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
853 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
854static const char *const yytname[] =
855{
856 "\"end of file\"", "error", "\"invalid token\"", "INT", "FLOAT",
857 "STRING_LITERAL", "BOOLEAN_LITERAL", "NAME", "TYPENAME", "COMPLETE",
858 "NAME_OR_INT", "SIZEOF", "KIND", "ERROR", "INT_S1_KEYWORD",
859 "INT_S2_KEYWORD", "INT_KEYWORD", "INT_S4_KEYWORD", "INT_S8_KEYWORD",
860 "LOGICAL_S1_KEYWORD", "LOGICAL_S2_KEYWORD", "LOGICAL_KEYWORD",
861 "LOGICAL_S4_KEYWORD", "LOGICAL_S8_KEYWORD", "REAL_KEYWORD",
862 "REAL_S4_KEYWORD", "REAL_S8_KEYWORD", "REAL_S16_KEYWORD",
863 "COMPLEX_KEYWORD", "COMPLEX_S4_KEYWORD", "COMPLEX_S8_KEYWORD",
864 "COMPLEX_S16_KEYWORD", "BOOL_AND", "BOOL_OR", "BOOL_NOT", "SINGLE",
865 "DOUBLE", "PRECISION", "CHARACTER", "DOLLAR_VARIABLE", "ASSIGN_MODIFY",
866 "UNOP_INTRINSIC", "BINOP_INTRINSIC", "UNOP_OR_BINOP_INTRINSIC",
867 "UNOP_OR_BINOP_OR_TERNOP_INTRINSIC", "','", "ABOVE_COMMA", "'='", "'?'",
868 "'|'", "'^'", "'&'", "EQUAL", "NOTEQUAL", "LESSTHAN", "GREATERTHAN",
869 "LEQ", "GEQ", "LSH", "RSH", "'@'", "'+'", "'-'", "'*'", "'/'",
870 "STARSTAR", "'%'", "UNARY", "'('", "')'", "'~'", "':'", "$accept",
871 "start", "type_exp", "exp", "$@1", "$@2", "$@3", "arglist", "subrange",
872 "complexnum", "variable", "type", "ptype", "abs_decl", "direct_abs_decl",
873 "func_mod", "typebase", "nonempty_typelist", "name", "name_not_typename", YY_NULLPTRPTR
874};
875
876static const char *
878{
879 return yytname[yysymbol];
880}
881#endif
882
883#define YYPACT_NINF (-103)
884
885#define yypact_value_is_default(Yyn) \
886 ((Yyn) == YYPACT_NINF)
887
888#define YYTABLE_NINF (-1)
889
890#define yytable_value_is_error(Yyn) \
891 0
892
893/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
894 STATE-NUM. */
895static const yytype_int16 yypact[] =
896{
897 249, -103, -103, -103, -103, -103, -103, -103, 291, -62,
898 -103, -103, -103, -103, -103, -103, -103, -103, -103, -103,
899 -103, -103, -103, -103, -103, -103, -103, -103, 333, 6,
900 18, -103, -103, -61, -33, -26, -21, 333, 333, 333,
901 249, 333, 56, -103, 718, -103, -103, -103, -6, -103,
902 249, -20, 333, -20, -103, -103, -103, -103, 333, 333,
903 -103, -103, -20, -20, -20, 567, -16, -4, -20, -103,
904 333, 333, 333, 333, 333, 333, 333, 333, 333, 333,
905 333, 333, 333, 333, 333, 333, 333, 333, 333, 333,
906 333, 60, -103, -6, -2, 432, -103, 29, -103, 40,
907 373, 605, 681, 88, 88, 333, -103, -103, 333, 802,
908 753, 718, 718, 821, 839, 856, 733, 733, 53, 53,
909 53, 53, 133, 133, 72, 38, 38, 58, 58, 58,
910 -103, -103, -103, 54, 88, -103, -103, -103, 63, -103,
911 -103, 59, -40, -5, -103, 375, -103, -103, 333, 166,
912 456, -18, -103, -9, 718, -20, -103, 51, 104, -103,
913 812, -103, 643, 333, 493, 180, 88, -103, -103, -103,
914 75, -103, -103, 718, 333, 333, 530, 456, -103, -103,
915 718, 718, 333, 718
916};
917
918/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
919 Performed when YYTABLE does not specify something else to do. Zero
920 means the default is an error. */
921static const yytype_int8 yydefact[] =
922{
923 0, 61, 63, 68, 67, 113, 85, 62, 0, 0,
924 86, 87, 88, 89, 90, 92, 93, 94, 95, 96,
925 97, 98, 99, 100, 101, 102, 103, 104, 0, 0,
926 0, 91, 65, 0, 0, 0, 0, 0, 0, 0,
927 0, 0, 0, 3, 2, 64, 4, 70, 71, 69,
928 0, 11, 0, 9, 107, 105, 108, 106, 0, 0,
929 17, 19, 7, 8, 6, 0, 0, 0, 10, 1,
930 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
931 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
932 0, 0, 13, 75, 73, 0, 72, 77, 82, 0,
933 0, 0, 0, 21, 21, 0, 5, 35, 0, 57,
934 58, 60, 59, 56, 55, 54, 48, 49, 52, 53,
935 50, 51, 46, 47, 40, 44, 45, 42, 43, 41,
936 111, 112, 39, 37, 21, 76, 80, 74, 0, 83,
937 109, 0, 0, 0, 81, 66, 12, 15, 0, 29,
938 22, 0, 23, 0, 34, 36, 38, 0, 0, 78,
939 0, 84, 0, 0, 28, 27, 0, 18, 20, 14,
940 0, 110, 16, 33, 0, 0, 26, 24, 25, 79,
941 32, 31, 0, 30
942};
943
944/* YYPGOTO[NTERM-NUM]. */
945static const yytype_int8 yypgoto[] =
946{
947 -103, -103, -103, 0, -103, -103, -103, -102, -41, -103,
948 -103, 4, -103, 48, -103, 49, -103, -103, -103, -103
949};
950
951/* YYDEFGOTO[NTERM-NUM]. */
952static const yytype_uint8 yydefgoto[] =
953{
954 0, 42, 43, 150, 134, 103, 104, 151, 152, 66,
955 45, 140, 47, 96, 97, 98, 48, 142, 133, 49
956};
957
958/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
959 positive, shift that token. If negative, reduce the rule whose
960 number is the opposite. If YYTABLE_NINF, syntax error. */
961static const yytype_uint8 yytable[] =
962{
963 44, 136, 153, 6, 46, 160, 52, 58, 51, 10,
964 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
965 21, 22, 23, 24, 25, 26, 27, 166, 53, 161,
966 29, 30, 157, 31, 54, 59, 166, 62, 63, 64,
967 65, 68, 60, 55, 67, 93, 56, 61, 92, 93,
968 65, 167, 100, 107, 99, 57, 69, 94, 101, 102,
969 168, 94, 95, 156, 139, 108, 95, 130, 131, 132,
970 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
971 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
972 129, 1, 2, 3, 4, 5, 166, 143, 7, 8,
973 9, 88, 89, 90, 91, 154, 92, 170, 155, 145,
974 158, 83, 84, 85, 86, 87, 88, 89, 90, 91,
975 169, 92, 28, 90, 91, 178, 92, 32, 159, 33,
976 34, 35, 36, 86, 87, 88, 89, 90, 91, 37,
977 92, 135, 137, 141, 179, 155, 144, 0, 162, 164,
978 38, 39, 0, 0, 0, 0, 40, 0, 41, 149,
979 0, 0, 0, 173, 171, 176, 177, 0, 0, 1,
980 2, 3, 4, 5, 180, 181, 7, 8, 9, 0,
981 0, 0, 183, 1, 2, 3, 4, 5, 0, 0,
982 7, 8, 9, 85, 86, 87, 88, 89, 90, 91,
983 28, 92, 0, 0, 0, 32, 0, 33, 34, 35,
984 36, 0, 0, 0, 28, 0, 0, 37, 0, 32,
985 0, 33, 34, 35, 36, 0, 0, 0, 38, 39,
986 0, 37, 0, 0, 40, 0, 41, 163, 0, 0,
987 0, 0, 38, 39, 0, 0, 0, 0, 40, 0,
988 41, 175, 1, 2, 3, 4, 5, 6, 0, 7,
989 8, 9, 0, 10, 11, 12, 13, 14, 15, 16,
990 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
991 27, 0, 0, 28, 29, 30, 0, 31, 32, 0,
992 33, 34, 35, 36, 1, 2, 3, 4, 5, 0,
993 37, 7, 8, 9, 0, 0, 0, 0, 0, 0,
994 0, 38, 39, 0, 0, 0, 0, 40, 0, 41,
995 0, 0, 0, 0, 0, 28, 0, 0, 0, 0,
996 32, 0, 33, 34, 35, 36, 1, 2, 3, 4,
997 5, 0, 37, 7, 8, 9, 0, 0, 0, 0,
998 0, 0, 0, 38, 39, 0, 0, 0, 0, 50,
999 0, 41, 0, 0, 0, 0, 0, 28, 0, 0,
1000 0, 0, 32, 0, 33, 34, 35, 36, 1, 2,
1001 3, 4, 5, 0, 37, 7, 8, 9, 0, 0,
1002 0, 0, 0, 0, 0, 38, 39, 0, 0, 0,
1003 0, 40, 0, 41, 0, 70, 71, 0, 0, 28,
1004 0, 0, 0, 72, 32, 0, 33, 34, 35, 36,
1005 73, 0, 74, 75, 76, 77, 78, 79, 80, 81,
1006 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
1007 6, 92, 146, 40, 138, 41, 10, 11, 12, 13,
1008 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1009 24, 25, 26, 27, 0, 0, 0, 29, 30, 0,
1010 31, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1011 0, 0, 0, 93, 0, 0, 0, 0, 70, 71,
1012 0, 0, 0, 0, 0, 94, 72, 0, 0, 0,
1013 95, 139, 0, 73, 0, 74, 75, 76, 77, 78,
1014 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
1015 89, 90, 91, 0, 92, 70, 71, 165, 0, 0,
1016 0, 0, 0, 72, 0, 0, 0, 0, 0, 0,
1017 73, 0, 74, 75, 76, 77, 78, 79, 80, 81,
1018 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
1019 0, 92, 70, 71, 174, 0, 0, 0, 0, 0,
1020 72, 0, 0, 0, 0, 0, 0, 73, 0, 74,
1021 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1022 85, 86, 87, 88, 89, 90, 91, 0, 92, 70,
1023 71, 182, 0, 0, 0, 0, 0, 72, 0, 0,
1024 0, 0, 105, 0, 73, 0, 74, 75, 76, 77,
1025 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
1026 88, 89, 90, 91, 0, 92, 106, 70, 71, 0,
1027 0, 0, 0, 0, 0, 72, 0, 0, 0, 0,
1028 0, 0, 73, 0, 74, 75, 76, 77, 78, 79,
1029 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
1030 90, 91, 0, 92, 147, 70, 71, 0, 0, 0,
1031 0, 0, 0, 72, 0, 0, 0, 0, 0, 0,
1032 73, 0, 74, 75, 76, 77, 78, 79, 80, 81,
1033 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
1034 0, 92, 172, 70, 71, 0, 0, 0, 0, 0,
1035 0, 72, 0, 0, 0, 0, 148, 0, 73, 0,
1036 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1037 84, 85, 86, 87, 88, 89, 90, 91, 0, 92,
1038 70, 71, 0, 0, 0, 0, 0, 0, 72, 0,
1039 0, 0, 0, 0, 0, 73, 0, 74, 75, 76,
1040 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
1041 87, 88, 89, 90, 91, 70, 92, 79, 80, 81,
1042 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
1043 0, 92, 74, 75, 76, 77, 78, 79, 80, 81,
1044 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
1045 6, 92, 0, 0, 0, 0, 10, 11, 12, 13,
1046 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1047 24, 25, 26, 27, 0, 0, 0, 29, 30, 0,
1048 31, 74, 75, 76, 77, 78, 79, 80, 81, 82,
1049 83, 84, 85, 86, 87, 88, 89, 90, 91, 0,
1050 92, 75, 76, 77, 78, 79, 80, 81, 82, 83,
1051 84, 85, 86, 87, 88, 89, 90, 91, 0, 92,
1052 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1053 86, 87, 88, 89, 90, 91, 0, 92, 77, 78,
1054 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
1055 89, 90, 91, 0, 92
1056};
1057
1058static const yytype_int16 yycheck[] =
1059{
1060 0, 3, 104, 8, 0, 45, 68, 68, 8, 14,
1061 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1062 25, 26, 27, 28, 29, 30, 31, 45, 28, 69,
1063 35, 36, 134, 38, 28, 68, 45, 37, 38, 39,
1064 40, 41, 68, 37, 40, 51, 28, 68, 68, 51,
1065 50, 69, 52, 69, 50, 37, 0, 63, 58, 59,
1066 69, 63, 68, 9, 69, 69, 68, 7, 8, 9,
1067 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
1068 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
1069 90, 3, 4, 5, 6, 7, 45, 68, 10, 11,
1070 12, 63, 64, 65, 66, 105, 68, 3, 108, 69,
1071 47, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1072 69, 68, 34, 65, 66, 166, 68, 39, 69, 41,
1073 42, 43, 44, 61, 62, 63, 64, 65, 66, 51,
1074 68, 93, 94, 95, 69, 145, 97, -1, 148, 149,
1075 62, 63, -1, -1, -1, -1, 68, -1, 70, 71,
1076 -1, -1, -1, 163, 160, 165, 166, -1, -1, 3,
1077 4, 5, 6, 7, 174, 175, 10, 11, 12, -1,
1078 -1, -1, 182, 3, 4, 5, 6, 7, -1, -1,
1079 10, 11, 12, 60, 61, 62, 63, 64, 65, 66,
1080 34, 68, -1, -1, -1, 39, -1, 41, 42, 43,
1081 44, -1, -1, -1, 34, -1, -1, 51, -1, 39,
1082 -1, 41, 42, 43, 44, -1, -1, -1, 62, 63,
1083 -1, 51, -1, -1, 68, -1, 70, 71, -1, -1,
1084 -1, -1, 62, 63, -1, -1, -1, -1, 68, -1,
1085 70, 71, 3, 4, 5, 6, 7, 8, -1, 10,
1086 11, 12, -1, 14, 15, 16, 17, 18, 19, 20,
1087 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1088 31, -1, -1, 34, 35, 36, -1, 38, 39, -1,
1089 41, 42, 43, 44, 3, 4, 5, 6, 7, -1,
1090 51, 10, 11, 12, -1, -1, -1, -1, -1, -1,
1091 -1, 62, 63, -1, -1, -1, -1, 68, -1, 70,
1092 -1, -1, -1, -1, -1, 34, -1, -1, -1, -1,
1093 39, -1, 41, 42, 43, 44, 3, 4, 5, 6,
1094 7, -1, 51, 10, 11, 12, -1, -1, -1, -1,
1095 -1, -1, -1, 62, 63, -1, -1, -1, -1, 68,
1096 -1, 70, -1, -1, -1, -1, -1, 34, -1, -1,
1097 -1, -1, 39, -1, 41, 42, 43, 44, 3, 4,
1098 5, 6, 7, -1, 51, 10, 11, 12, -1, -1,
1099 -1, -1, -1, -1, -1, 62, 63, -1, -1, -1,
1100 -1, 68, -1, 70, -1, 32, 33, -1, -1, 34,
1101 -1, -1, -1, 40, 39, -1, 41, 42, 43, 44,
1102 47, -1, 49, 50, 51, 52, 53, 54, 55, 56,
1103 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1104 8, 68, 69, 68, 12, 70, 14, 15, 16, 17,
1105 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
1106 28, 29, 30, 31, -1, -1, -1, 35, 36, -1,
1107 38, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1108 -1, -1, -1, 51, -1, -1, -1, -1, 32, 33,
1109 -1, -1, -1, -1, -1, 63, 40, -1, -1, -1,
1110 68, 69, -1, 47, -1, 49, 50, 51, 52, 53,
1111 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1112 64, 65, 66, -1, 68, 32, 33, 71, -1, -1,
1113 -1, -1, -1, 40, -1, -1, -1, -1, -1, -1,
1114 47, -1, 49, 50, 51, 52, 53, 54, 55, 56,
1115 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1116 -1, 68, 32, 33, 71, -1, -1, -1, -1, -1,
1117 40, -1, -1, -1, -1, -1, -1, 47, -1, 49,
1118 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1119 60, 61, 62, 63, 64, 65, 66, -1, 68, 32,
1120 33, 71, -1, -1, -1, -1, -1, 40, -1, -1,
1121 -1, -1, 45, -1, 47, -1, 49, 50, 51, 52,
1122 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
1123 63, 64, 65, 66, -1, 68, 69, 32, 33, -1,
1124 -1, -1, -1, -1, -1, 40, -1, -1, -1, -1,
1125 -1, -1, 47, -1, 49, 50, 51, 52, 53, 54,
1126 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1127 65, 66, -1, 68, 69, 32, 33, -1, -1, -1,
1128 -1, -1, -1, 40, -1, -1, -1, -1, -1, -1,
1129 47, -1, 49, 50, 51, 52, 53, 54, 55, 56,
1130 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1131 -1, 68, 69, 32, 33, -1, -1, -1, -1, -1,
1132 -1, 40, -1, -1, -1, -1, 45, -1, 47, -1,
1133 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1134 59, 60, 61, 62, 63, 64, 65, 66, -1, 68,
1135 32, 33, -1, -1, -1, -1, -1, -1, 40, -1,
1136 -1, -1, -1, -1, -1, 47, -1, 49, 50, 51,
1137 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
1138 62, 63, 64, 65, 66, 32, 68, 54, 55, 56,
1139 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1140 -1, 68, 49, 50, 51, 52, 53, 54, 55, 56,
1141 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
1142 8, 68, -1, -1, -1, -1, 14, 15, 16, 17,
1143 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
1144 28, 29, 30, 31, -1, -1, -1, 35, 36, -1,
1145 38, 49, 50, 51, 52, 53, 54, 55, 56, 57,
1146 58, 59, 60, 61, 62, 63, 64, 65, 66, -1,
1147 68, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1148 59, 60, 61, 62, 63, 64, 65, 66, -1, 68,
1149 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
1150 61, 62, 63, 64, 65, 66, -1, 68, 52, 53,
1151 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1152 64, 65, 66, -1, 68
1153};
1154
1155/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
1156 state STATE-NUM. */
1157static const yytype_int8 yystos[] =
1158{
1159 0, 3, 4, 5, 6, 7, 8, 10, 11, 12,
1160 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1161 24, 25, 26, 27, 28, 29, 30, 31, 34, 35,
1162 36, 38, 39, 41, 42, 43, 44, 51, 62, 63,
1163 68, 70, 73, 74, 75, 82, 83, 84, 88, 91,
1164 68, 75, 68, 75, 28, 37, 28, 37, 68, 68,
1165 68, 68, 75, 75, 75, 75, 81, 83, 75, 0,
1166 32, 33, 40, 47, 49, 50, 51, 52, 53, 54,
1167 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1168 65, 66, 68, 51, 63, 68, 85, 86, 87, 83,
1169 75, 75, 75, 77, 78, 45, 69, 69, 69, 75,
1170 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
1171 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
1172 7, 8, 9, 90, 76, 85, 3, 85, 12, 69,
1173 83, 85, 89, 68, 87, 69, 69, 69, 45, 71,
1174 75, 79, 80, 79, 75, 75, 9, 79, 47, 69,
1175 45, 69, 75, 71, 75, 71, 45, 69, 69, 69,
1176 3, 83, 69, 75, 71, 71, 75, 75, 80, 69,
1177 75, 75, 71, 75
1178};
1179
1180/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */
1181static const yytype_int8 yyr1[] =
1182{
1183 0, 72, 73, 73, 74, 75, 75, 75, 75, 75,
1184 75, 75, 75, 76, 75, 75, 75, 77, 75, 78,
1185 75, 79, 79, 79, 79, 79, 80, 80, 80, 80,
1186 80, 80, 80, 80, 81, 75, 75, 75, 75, 75,
1187 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
1188 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
1189 75, 75, 75, 75, 75, 75, 75, 75, 75, 82,
1190 83, 84, 84, 85, 85, 85, 85, 85, 86, 86,
1191 86, 86, 86, 87, 87, 88, 88, 88, 88, 88,
1192 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
1193 88, 88, 88, 88, 88, 88, 88, 88, 88, 89,
1194 89, 90, 90, 91
1195};
1196
1197/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */
1198static const yytype_int8 yyr2[] =
1199{
1200 0, 2, 1, 1, 1, 3, 2, 2, 2, 2,
1201 2, 2, 4, 0, 5, 4, 6, 0, 5, 0,
1202 5, 0, 1, 1, 3, 3, 3, 2, 2, 1,
1203 5, 4, 4, 3, 3, 3, 4, 3, 4, 3,
1204 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1205 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1206 3, 1, 1, 1, 1, 1, 4, 1, 1, 1,
1207 1, 1, 2, 1, 2, 1, 2, 1, 3, 5,
1208 2, 2, 1, 2, 3, 1, 1, 1, 1, 1,
1209 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1210 1, 1, 1, 1, 1, 2, 2, 2, 2, 1,
1211 3, 1, 1, 1
1212};
1213
1214
1215enum { YYENOMEM = -2 };
1216
1217#define yyerrok (yyerrstatus = 0)
1218#define yyclearin (yychar = YYEMPTY)
1219
1220#define YYACCEPT goto yyacceptlab
1221#define YYABORT goto yyabortlab
1222#define YYERROR goto yyerrorlab
1223#define YYNOMEM goto yyexhaustedlab
1224
1225
1226#define YYRECOVERING() (!!yyerrstatus)
1227
1228#define YYBACKUP(Token, Value) \
1229 do \
1230 if (yychar == YYEMPTY) \
1231 { \
1232 yychar = (Token); \
1233 yylval = (Value); \
1234 YYPOPSTACK (yylen); \
1235 yystate = *yyssp; \
1236 goto yybackup; \
1237 } \
1238 else \
1239 { \
1240 yyerror (YY_("syntax error: cannot back up")); \
1241 YYERROR; \
1242 } \
1243 while (0)
1244
1245/* Backward compatibility with an undocumented macro.
1246 Use YYerror or YYUNDEF. */
1247#define YYERRCODE YYUNDEF
1248
1249
1250/* Enable debugging if requested. */
1251#if YYDEBUG
1252
1253# ifndef YYFPRINTF
1254# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1255# define YYFPRINTF fprintf
1256# endif
1257
1258# define YYDPRINTF(Args) \
1259do { \
1260 if (yydebug) \
1261 YYFPRINTF Args; \
1262} while (0)
1263
1264
1265
1266
1267# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
1268do { \
1269 if (yydebug) \
1270 { \
1271 YYFPRINTF (stderr, "%s ", Title); \
1272 yy_symbol_print (stderr, \
1273 Kind, Value); \
1274 YYFPRINTF (stderr, "\n"); \
1275 } \
1276} while (0)
1277
1278
1279/*-----------------------------------.
1280| Print this symbol's value on YYO. |
1281`-----------------------------------*/
1282
1283static void
1285 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1286{
1287 FILE *yyoutput = yyo;
1288 YY_USE (yyoutput);
1289 if (!yyvaluep)
1290 return;
1292 YY_USE (yykind);
1294}
1295
1296
1297/*---------------------------.
1298| Print this symbol on YYO. |
1299`---------------------------*/
1300
1301static void
1303 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1304{
1305 YYFPRINTF (yyo, "%s %s (",
1306 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
1307
1308 yy_symbol_value_print (yyo, yykind, yyvaluep);
1309 YYFPRINTF (yyo, ")");
1310}
1311
1312/*------------------------------------------------------------------.
1313| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1314| TOP (included). |
1315`------------------------------------------------------------------*/
1316
1317static void
1319{
1320 YYFPRINTF (stderr, "Stack now");
1321 for (; yybottom <= yytop; yybottom++)
1322 {
1323 int yybot = *yybottom;
1324 YYFPRINTF (stderr, " %d", yybot);
1325 }
1326 YYFPRINTF (stderr, "\n");
1327}
1328
1329# define YY_STACK_PRINT(Bottom, Top) \
1330do { \
1331 if (yydebug) \
1332 yy_stack_print ((Bottom), (Top)); \
1333} while (0)
1334
1335
1336/*------------------------------------------------.
1337| Report that the YYRULE is going to be reduced. |
1338`------------------------------------------------*/
1339
1340static void
1342 int yyrule)
1343{
1344 int yylno = yyrline[yyrule];
1345 int yynrhs = yyr2[yyrule];
1346 int yyi;
1347 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1348 yyrule - 1, yylno);
1349 /* The symbols being reduced. */
1350 for (yyi = 0; yyi < yynrhs; yyi++)
1351 {
1352 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1353 yy_symbol_print (stderr,
1354 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
1355 &yyvsp[(yyi + 1) - (yynrhs)]);
1356 YYFPRINTF (stderr, "\n");
1357 }
1358}
1359
1360# define YY_REDUCE_PRINT(Rule) \
1361do { \
1362 if (yydebug) \
1363 yy_reduce_print (yyssp, yyvsp, Rule); \
1364} while (0)
1365
1366/* Nonzero means print parse trace. It is left uninitialized so that
1367 multiple parsers can coexist. */
1369#else /* !YYDEBUG */
1370# define YYDPRINTF(Args) ((void) 0)
1371# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
1372# define YY_STACK_PRINT(Bottom, Top)
1373# define YY_REDUCE_PRINT(Rule)
1374#endif /* !YYDEBUG */
1375
1376
1377/* YYINITDEPTH -- initial size of the parser's stacks. */
1378#ifndef YYINITDEPTH
1379# define YYINITDEPTH 200
1380#endif
1381
1382/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1383 if the built-in stack extension method is used).
1384
1385 Do not make this value too large; the results are undefined if
1386 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1387 evaluated with infinite-precision integer arithmetic. */
1388
1389#ifndef YYMAXDEPTH
1390# define YYMAXDEPTH 10000
1391#endif
1392
1393
1394
1395
1396
1397
1398/*-----------------------------------------------.
1399| Release the memory associated to this symbol. |
1400`-----------------------------------------------*/
1401
1402static void
1403yydestruct (const char *yymsg,
1404 yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
1405{
1406 YY_USE (yyvaluep);
1407 if (!yymsg)
1408 yymsg = "Deleting";
1409 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
1410
1412 YY_USE (yykind);
1414}
1415
1416
1417/* Lookahead token kind. */
1419
1420/* The semantic value of the lookahead symbol. */
1422/* Number of syntax errors so far. */
1424
1425
1426
1427
1428/*----------.
1429| yyparse. |
1430`----------*/
1431
1432int
1434{
1436 /* Number of tokens to shift before error messages enabled. */
1437 int yyerrstatus = 0;
1438
1439 /* Refer to the stacks through separate pointers, to allow yyoverflow
1440 to xreallocate them elsewhere. */
1441
1442 /* Their size. */
1444
1445 /* The state stack: array, bottom, top. */
1446 yy_state_t yyssa[YYINITDEPTH];
1447 yy_state_t *yyss = yyssa;
1449
1450 /* The semantic value stack: array, bottom, top. */
1451 YYSTYPE yyvsa[YYINITDEPTH];
1452 YYSTYPE *yyvs = yyvsa;
1453 YYSTYPE *yyvsp = yyvs;
1454
1455 int yyn;
1456 /* The return value of yyparse. */
1457 int yyresult;
1458 /* Lookahead symbol kind. */
1460 /* The variables used to return semantic value and location from the
1461 action routines. */
1462 YYSTYPE yyval;
1463
1464
1465
1466#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1467
1468 /* The number of symbols on the RHS of the reduced rule.
1469 Keep to zero when no symbol should be popped. */
1470 int yylen = 0;
1471
1472 YYDPRINTF ((stderr, "Starting parse\n"));
1473
1474 yychar = YYEMPTY; /* Cause a token to be read. */
1475
1476 goto yysetstate;
1477
1478
1479/*------------------------------------------------------------.
1480| yynewstate -- push a new state, which is found in yystate. |
1481`------------------------------------------------------------*/
1482yynewstate:
1483 /* In all cases, when you get here, the value and location stacks
1484 have just been pushed. So pushing a state here evens the stacks. */
1485 yyssp++;
1486
1487
1488/*--------------------------------------------------------------------.
1489| yysetstate -- set current state (the top of the stack) to yystate. |
1490`--------------------------------------------------------------------*/
1491yysetstate:
1492 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1493 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1498
1499 if (yyss + yystacksize - 1 <= yyssp)
1500#if !defined yyoverflow && !defined YYSTACK_RELOCATE
1501 YYNOMEM;
1502#else
1503 {
1504 /* Get the current used size of the three stacks, in elements. */
1505 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1506
1507# if defined yyoverflow
1508 {
1509 /* Give user a chance to xreallocate the stack. Use copies of
1510 these so that the &'s don't force the real ones into
1511 memory. */
1512 yy_state_t *yyss1 = yyss;
1513 YYSTYPE *yyvs1 = yyvs;
1514
1515 /* Each stack pointer address is followed by the size of the
1516 data in use in that stack, in bytes. This used to be a
1517 conditional around just the two extra args, but that might
1518 be undefined if yyoverflow is a macro. */
1519 yyoverflow (YY_("memory exhausted"),
1520 &yyss1, yysize * YYSIZEOF (*yyssp),
1521 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1522 &yystacksize);
1523 yyss = yyss1;
1524 yyvs = yyvs1;
1525 }
1526# else /* defined YYSTACK_RELOCATE */
1527 /* Extend the stack our own way. */
1528 if (YYMAXDEPTH <= yystacksize)
1529 YYNOMEM;
1530 yystacksize *= 2;
1531 if (YYMAXDEPTH < yystacksize)
1533
1534 {
1535 yy_state_t *yyss1 = yyss;
1536 union yyalloc *yyptr =
1537 YY_CAST (union yyalloc *,
1539 if (! yyptr)
1540 YYNOMEM;
1543# undef YYSTACK_RELOCATE
1544 if (yyss1 != yyssa)
1545 YYSTACK_FREE (yyss1);
1546 }
1547# endif
1548
1549 yyssp = yyss + yysize - 1;
1550 yyvsp = yyvs + yysize - 1;
1551
1553 YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1554 YY_CAST (long, yystacksize)));
1556
1557 if (yyss + yystacksize - 1 <= yyssp)
1558 YYABORT;
1559 }
1560#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1561
1562
1563 if (yystate == YYFINAL)
1564 YYACCEPT;
1565
1566 goto yybackup;
1567
1568
1569/*-----------.
1570| yybackup. |
1571`-----------*/
1572yybackup:
1573 /* Do appropriate processing given the current state. Read a
1574 lookahead token if we need one and don't already have one. */
1575
1576 /* First try to decide what to do without reference to lookahead token. */
1577 yyn = yypact[yystate];
1578 if (yypact_value_is_default (yyn))
1579 goto yydefault;
1580
1581 /* Not known => get a lookahead token if don't already have one. */
1582
1583 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1584 if (yychar == YYEMPTY)
1585 {
1586 YYDPRINTF ((stderr, "Reading a token\n"));
1587 yychar = yylex ();
1588 }
1589
1590 if (yychar <= YYEOF)
1591 {
1592 yychar = YYEOF;
1593 yytoken = YYSYMBOL_YYEOF;
1594 YYDPRINTF ((stderr, "Now at end of input.\n"));
1595 }
1596 else if (yychar == YYerror)
1597 {
1598 /* The scanner already issued an error message, process directly
1599 to error recovery. But do not keep the error token as
1600 lookahead, it is too special and may lead us to an endless
1601 loop in error recovery. */
1602 yychar = YYUNDEF;
1603 yytoken = YYSYMBOL_YYerror;
1604 goto yyerrlab1;
1605 }
1606 else
1607 {
1608 yytoken = YYTRANSLATE (yychar);
1609 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1610 }
1611
1612 /* If the proper action on seeing token YYTOKEN is to reduce or to
1613 detect an error, take that action. */
1614 yyn += yytoken;
1615 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1616 goto yydefault;
1617 yyn = yytable[yyn];
1618 if (yyn <= 0)
1619 {
1620 if (yytable_value_is_error (yyn))
1621 goto yyerrlab;
1622 yyn = -yyn;
1623 goto yyreduce;
1624 }
1625
1626 /* Count tokens shifted since error; after three, turn off error
1627 status. */
1628 if (yyerrstatus)
1629 yyerrstatus--;
1630
1631 /* Shift the lookahead token. */
1632 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1633 yystate = yyn;
1635 *++yyvsp = yylval;
1637
1638 /* Discard the shifted token. */
1639 yychar = YYEMPTY;
1640 goto yynewstate;
1641
1642
1643/*-----------------------------------------------------------.
1644| yydefault -- do the default action for the current state. |
1645`-----------------------------------------------------------*/
1646yydefault:
1647 yyn = yydefact[yystate];
1648 if (yyn == 0)
1649 goto yyerrlab;
1650 goto yyreduce;
1651
1652
1653/*-----------------------------.
1654| yyreduce -- do a reduction. |
1655`-----------------------------*/
1656yyreduce:
1657 /* yyn is the number of a rule to reduce with. */
1658 yylen = yyr2[yyn];
1659
1660 /* If YYLEN is nonzero, implement the default value of the action:
1661 '$$ = $1'.
1662
1663 Otherwise, the following line sets YYVAL to garbage.
1664 This behavior is undocumented and Bison
1665 users should not rely upon it. Assigning to YYVAL
1666 unconditionally makes the parser a bit smaller, and it avoids a
1667 GCC warning that YYVAL may be used uninitialized. */
1668 yyval = yyvsp[1-yylen];
1669
1670
1671 YY_REDUCE_PRINT (yyn);
1672 switch (yyn)
1673 {
1674 case 4: /* type_exp: type */
1675#line 227 "f-exp.y"
1676 { pstate->push_new<type_operation> ((yyvsp[0].tval)); }
1677#line 1679 "f-exp.c.tmp"
1678 break;
1679
1680 case 5: /* exp: '(' exp ')' */
1681#line 231 "f-exp.y"
1682 { }
1683#line 1685 "f-exp.c.tmp"
1684 break;
1685
1686 case 6: /* exp: '*' exp */
1687#line 236 "f-exp.y"
1689#line 1691 "f-exp.c.tmp"
1690 break;
1691
1692 case 7: /* exp: '&' exp */
1693#line 240 "f-exp.y"
1695#line 1697 "f-exp.c.tmp"
1696 break;
1697
1698 case 8: /* exp: '-' exp */
1699#line 244 "f-exp.y"
1701#line 1703 "f-exp.c.tmp"
1702 break;
1703
1704 case 9: /* exp: BOOL_NOT exp */
1705#line 248 "f-exp.y"
1707#line 1709 "f-exp.c.tmp"
1708 break;
1709
1710 case 10: /* exp: '~' exp */
1711#line 252 "f-exp.y"
1713#line 1715 "f-exp.c.tmp"
1714 break;
1715
1716 case 11: /* exp: SIZEOF exp */
1717#line 256 "f-exp.y"
1719#line 1721 "f-exp.c.tmp"
1720 break;
1721
1722 case 12: /* exp: KIND '(' exp ')' */
1723#line 260 "f-exp.y"
1725#line 1727 "f-exp.c.tmp"
1726 break;
1727
1728 case 13: /* $@1: %empty */
1729#line 269 "f-exp.y"
1730 { pstate->start_arglist (); }
1731#line 1733 "f-exp.c.tmp"
1732 break;
1733
1734 case 14: /* exp: exp '(' $@1 arglist ')' */
1735#line 271 "f-exp.y"
1736 {
1737 std::vector<operation_up> args
1740 (pstate->pop (), std::move (args));
1741 }
1742#line 1744 "f-exp.c.tmp"
1743 break;
1744
1745 case 15: /* exp: UNOP_INTRINSIC '(' exp ')' */
1746#line 280 "f-exp.y"
1747 {
1748 wrap_unop_intrinsic ((yyvsp[-3].opcode));
1749 }
1750#line 1752 "f-exp.c.tmp"
1751 break;
1752
1753 case 16: /* exp: BINOP_INTRINSIC '(' exp ',' exp ')' */
1754#line 286 "f-exp.y"
1755 {
1756 wrap_binop_intrinsic ((yyvsp[-5].opcode));
1757 }
1758#line 1760 "f-exp.c.tmp"
1759 break;
1760
1761 case 17: /* $@2: %empty */
1762#line 292 "f-exp.y"
1763 { pstate->start_arglist (); }
1764#line 1766 "f-exp.c.tmp"
1765 break;
1766
1767 case 18: /* exp: UNOP_OR_BINOP_INTRINSIC '(' $@2 arglist ')' */
1768#line 294 "f-exp.y"
1769 {
1770 const int n = pstate->end_arglist ();
1771
1772 switch (n)
1773 {
1774 case 1:
1775 wrap_unop_intrinsic ((yyvsp[-4].opcode));
1776 break;
1777 case 2:
1778 wrap_binop_intrinsic ((yyvsp[-4].opcode));
1779 break;
1780 default:
1781 gdb_assert_not_reached
1782 ("wrong number of arguments for intrinsics");
1783 }
1784 }
1785#line 1787 "f-exp.c.tmp"
1786 break;
1787
1788 case 19: /* $@3: %empty */
1789#line 312 "f-exp.y"
1790 { pstate->start_arglist (); }
1791#line 1793 "f-exp.c.tmp"
1792 break;
1793
1794 case 20: /* exp: UNOP_OR_BINOP_OR_TERNOP_INTRINSIC '(' $@3 arglist ')' */
1795#line 314 "f-exp.y"
1796 {
1797 const int n = pstate->end_arglist ();
1798
1799 switch (n)
1800 {
1801 case 1:
1802 wrap_unop_intrinsic ((yyvsp[-4].opcode));
1803 break;
1804 case 2:
1805 wrap_binop_intrinsic ((yyvsp[-4].opcode));
1806 break;
1807 case 3:
1808 wrap_ternop_intrinsic ((yyvsp[-4].opcode));
1809 break;
1810 default:
1811 gdb_assert_not_reached
1812 ("wrong number of arguments for intrinsics");
1813 }
1814 }
1815#line 1817 "f-exp.c.tmp"
1816 break;
1817
1818 case 22: /* arglist: exp */
1819#line 339 "f-exp.y"
1820 { pstate->arglist_len = 1; }
1821#line 1823 "f-exp.c.tmp"
1822 break;
1823
1824 case 23: /* arglist: subrange */
1825#line 343 "f-exp.y"
1826 { pstate->arglist_len = 1; }
1827#line 1829 "f-exp.c.tmp"
1828 break;
1829
1830 case 24: /* arglist: arglist ',' exp */
1831#line 347 "f-exp.y"
1832 { pstate->arglist_len++; }
1833#line 1835 "f-exp.c.tmp"
1834 break;
1835
1836 case 25: /* arglist: arglist ',' subrange */
1837#line 351 "f-exp.y"
1838 { pstate->arglist_len++; }
1839#line 1841 "f-exp.c.tmp"
1840 break;
1841
1842 case 26: /* subrange: exp ':' exp */
1843#line 357 "f-exp.y"
1844 {
1845 operation_up high = pstate->pop ();
1846 operation_up low = pstate->pop ();
1848 (RANGE_STANDARD, std::move (low),
1849 std::move (high), operation_up ());
1850 }
1851#line 1853 "f-exp.c.tmp"
1852 break;
1853
1854 case 27: /* subrange: exp ':' */
1855#line 367 "f-exp.y"
1856 {
1857 operation_up low = pstate->pop ();
1859 (RANGE_HIGH_BOUND_DEFAULT, std::move (low),
1860 operation_up (), operation_up ());
1861 }
1862#line 1864 "f-exp.c.tmp"
1863 break;
1864
1865 case 28: /* subrange: ':' exp */
1866#line 376 "f-exp.y"
1867 {
1868 operation_up high = pstate->pop ();
1871 std::move (high), operation_up ());
1872 }
1873#line 1875 "f-exp.c.tmp"
1874 break;
1875
1876 case 29: /* subrange: ':' */
1877#line 385 "f-exp.y"
1878 {
1883 operation_up ());
1884 }
1885#line 1887 "f-exp.c.tmp"
1886 break;
1887
1888 case 30: /* subrange: exp ':' exp ':' exp */
1889#line 396 "f-exp.y"
1890 {
1891 operation_up stride = pstate->pop ();
1892 operation_up high = pstate->pop ();
1893 operation_up low = pstate->pop ();
1896 std::move (low), std::move (high),
1897 std::move (stride));
1898 }
1899#line 1901 "f-exp.c.tmp"
1900 break;
1901
1902 case 31: /* subrange: exp ':' ':' exp */
1903#line 408 "f-exp.y"
1904 {
1905 operation_up stride = pstate->pop ();
1906 operation_up low = pstate->pop ();
1910 std::move (low), operation_up (),
1911 std::move (stride));
1912 }
1913#line 1915 "f-exp.c.tmp"
1914 break;
1915
1916 case 32: /* subrange: ':' exp ':' exp */
1917#line 420 "f-exp.y"
1918 {
1919 operation_up stride = pstate->pop ();
1920 operation_up high = pstate->pop ();
1924 operation_up (), std::move (high),
1925 std::move (stride));
1926 }
1927#line 1929 "f-exp.c.tmp"
1928 break;
1929
1930 case 33: /* subrange: ':' ':' exp */
1931#line 432 "f-exp.y"
1932 {
1933 operation_up stride = pstate->pop ();
1939 std::move (stride));
1940 }
1941#line 1943 "f-exp.c.tmp"
1942 break;
1943
1944 case 34: /* complexnum: exp ',' exp */
1945#line 444 "f-exp.y"
1946 { }
1947#line 1949 "f-exp.c.tmp"
1948 break;
1949
1950 case 35: /* exp: '(' complexnum ')' */
1951#line 448 "f-exp.y"
1952 {
1953 operation_up rhs = pstate->pop ();
1954 operation_up lhs = pstate->pop ();
1956 (std::move (lhs), std::move (rhs),
1957 parse_f_type (pstate)->builtin_complex_s16);
1958 }
1959#line 1961 "f-exp.c.tmp"
1960 break;
1961
1962 case 36: /* exp: '(' type ')' exp */
1963#line 458 "f-exp.y"
1964 {
1966 (pstate->pop (), (yyvsp[-2].tval));
1967 }
1968#line 1970 "f-exp.c.tmp"
1969 break;
1970
1971 case 37: /* exp: exp '%' name */
1972#line 465 "f-exp.y"
1973 {
1975 (pstate->pop (), copy_name ((yyvsp[0].sval)));
1976 }
1977#line 1979 "f-exp.c.tmp"
1978 break;
1979
1980 case 38: /* exp: exp '%' name COMPLETE */
1981#line 472 "f-exp.y"
1982 {
1985 copy_name ((yyvsp[-1].sval)));
1987 pstate->push (operation_up (op));
1988 }
1989#line 1991 "f-exp.c.tmp"
1990 break;
1991
1992 case 39: /* exp: exp '%' COMPLETE */
1993#line 482 "f-exp.y"
1994 {
1997 "");
1999 pstate->push (operation_up (op));
2000 }
2001#line 2003 "f-exp.c.tmp"
2002 break;
2003
2004 case 40: /* exp: exp '@' exp */
2005#line 494 "f-exp.y"
2006 { pstate->wrap2<repeat_operation> (); }
2007#line 2009 "f-exp.c.tmp"
2008 break;
2009
2010 case 41: /* exp: exp STARSTAR exp */
2011#line 498 "f-exp.y"
2012 { pstate->wrap2<exp_operation> (); }
2013#line 2015 "f-exp.c.tmp"
2014 break;
2015
2016 case 42: /* exp: exp '*' exp */
2017#line 502 "f-exp.y"
2018 { pstate->wrap2<mul_operation> (); }
2019#line 2021 "f-exp.c.tmp"
2020 break;
2021
2022 case 43: /* exp: exp '/' exp */
2023#line 506 "f-exp.y"
2024 { pstate->wrap2<div_operation> (); }
2025#line 2027 "f-exp.c.tmp"
2026 break;
2027
2028 case 44: /* exp: exp '+' exp */
2029#line 510 "f-exp.y"
2030 { pstate->wrap2<add_operation> (); }
2031#line 2033 "f-exp.c.tmp"
2032 break;
2033
2034 case 45: /* exp: exp '-' exp */
2035#line 514 "f-exp.y"
2036 { pstate->wrap2<sub_operation> (); }
2037#line 2039 "f-exp.c.tmp"
2038 break;
2039
2040 case 46: /* exp: exp LSH exp */
2041#line 518 "f-exp.y"
2042 { pstate->wrap2<lsh_operation> (); }
2043#line 2045 "f-exp.c.tmp"
2044 break;
2045
2046 case 47: /* exp: exp RSH exp */
2047#line 522 "f-exp.y"
2048 { pstate->wrap2<rsh_operation> (); }
2049#line 2051 "f-exp.c.tmp"
2050 break;
2051
2052 case 48: /* exp: exp EQUAL exp */
2053#line 526 "f-exp.y"
2054 { pstate->wrap2<equal_operation> (); }
2055#line 2057 "f-exp.c.tmp"
2056 break;
2057
2058 case 49: /* exp: exp NOTEQUAL exp */
2059#line 530 "f-exp.y"
2061#line 2063 "f-exp.c.tmp"
2062 break;
2063
2064 case 50: /* exp: exp LEQ exp */
2065#line 534 "f-exp.y"
2066 { pstate->wrap2<leq_operation> (); }
2067#line 2069 "f-exp.c.tmp"
2068 break;
2069
2070 case 51: /* exp: exp GEQ exp */
2071#line 538 "f-exp.y"
2072 { pstate->wrap2<geq_operation> (); }
2073#line 2075 "f-exp.c.tmp"
2074 break;
2075
2076 case 52: /* exp: exp LESSTHAN exp */
2077#line 542 "f-exp.y"
2078 { pstate->wrap2<less_operation> (); }
2079#line 2081 "f-exp.c.tmp"
2080 break;
2081
2082 case 53: /* exp: exp GREATERTHAN exp */
2083#line 546 "f-exp.y"
2084 { pstate->wrap2<gtr_operation> (); }
2085#line 2087 "f-exp.c.tmp"
2086 break;
2087
2088 case 54: /* exp: exp '&' exp */
2089#line 550 "f-exp.y"
2091#line 2093 "f-exp.c.tmp"
2092 break;
2093
2094 case 55: /* exp: exp '^' exp */
2095#line 554 "f-exp.y"
2097#line 2099 "f-exp.c.tmp"
2098 break;
2099
2100 case 56: /* exp: exp '|' exp */
2101#line 558 "f-exp.y"
2103#line 2105 "f-exp.c.tmp"
2104 break;
2105
2106 case 57: /* exp: exp BOOL_AND exp */
2107#line 562 "f-exp.y"
2109#line 2111 "f-exp.c.tmp"
2110 break;
2111
2112 case 58: /* exp: exp BOOL_OR exp */
2113#line 567 "f-exp.y"
2115#line 2117 "f-exp.c.tmp"
2116 break;
2117
2118 case 59: /* exp: exp '=' exp */
2119#line 571 "f-exp.y"
2120 { pstate->wrap2<assign_operation> (); }
2121#line 2123 "f-exp.c.tmp"
2122 break;
2123
2124 case 60: /* exp: exp ASSIGN_MODIFY exp */
2125#line 575 "f-exp.y"
2126 {
2127 operation_up rhs = pstate->pop ();
2128 operation_up lhs = pstate->pop ();
2130 ((yyvsp[-1].opcode), std::move (lhs), std::move (rhs));
2131 }
2132#line 2134 "f-exp.c.tmp"
2133 break;
2134
2135 case 61: /* exp: INT */
2136#line 584 "f-exp.y"
2137 {
2139 ((yyvsp[0].typed_val).type, (yyvsp[0].typed_val).val);
2140 }
2141#line 2143 "f-exp.c.tmp"
2142 break;
2143
2144 case 62: /* exp: NAME_OR_INT */
2145#line 591 "f-exp.y"
2146 { YYSTYPE val;
2147 parse_number (pstate, (yyvsp[0].ssym).stoken.ptr,
2148 (yyvsp[0].ssym).stoken.length, 0, &val);
2150 (val.typed_val.type,
2151 val.typed_val.val);
2152 }
2153#line 2155 "f-exp.c.tmp"
2154 break;
2155
2156 case 63: /* exp: FLOAT */
2157#line 601 "f-exp.y"
2158 {
2159 float_data data;
2160 std::copy (std::begin ((yyvsp[0].typed_val_float).val), std::end ((yyvsp[0].typed_val_float).val),
2161 std::begin (data));
2162 pstate->push_new<float_const_operation> ((yyvsp[0].typed_val_float).type, data);
2163 }
2164#line 2166 "f-exp.c.tmp"
2165 break;
2166
2167 case 65: /* exp: DOLLAR_VARIABLE */
2168#line 613 "f-exp.y"
2169 { pstate->push_dollar ((yyvsp[0].sval)); }
2170#line 2172 "f-exp.c.tmp"
2171 break;
2172
2173 case 66: /* exp: SIZEOF '(' type ')' */
2174#line 617 "f-exp.y"
2175 {
2176 (yyvsp[-1].tval) = check_typedef ((yyvsp[-1].tval));
2178 (parse_f_type (pstate)->builtin_integer,
2179 (yyvsp[-1].tval)->length ());
2180 }
2181#line 2183 "f-exp.c.tmp"
2182 break;
2183
2184 case 67: /* exp: BOOLEAN_LITERAL */
2185#line 626 "f-exp.y"
2186 { pstate->push_new<bool_operation> ((yyvsp[0].lval)); }
2187#line 2189 "f-exp.c.tmp"
2188 break;
2189
2190 case 68: /* exp: STRING_LITERAL */
2191#line 630 "f-exp.y"
2192 {
2194 (copy_name ((yyvsp[0].sval)));
2195 }
2196#line 2198 "f-exp.c.tmp"
2197 break;
2198
2199 case 69: /* variable: name_not_typename */
2200#line 637 "f-exp.y"
2201 { struct block_symbol sym = (yyvsp[0].ssym).sym;
2202 std::string name = copy_name ((yyvsp[0].ssym).stoken);
2203 pstate->push_symbol (name.c_str (), sym);
2204 }
2205#line 2207 "f-exp.c.tmp"
2206 break;
2207
2208 case 72: /* ptype: typebase abs_decl */
2209#line 649 "f-exp.y"
2210 {
2211 /* This is where the interesting stuff happens. */
2212 int done = 0;
2213 int array_size;
2214 struct type *follow_type = (yyvsp[-1].tval);
2215 struct type *range_type;
2216
2217 while (!done)
2218 switch (type_stack->pop ())
2219 {
2220 case tp_end:
2221 done = 1;
2222 break;
2223 case tp_pointer:
2224 follow_type = lookup_pointer_type (follow_type);
2225 break;
2226 case tp_reference:
2227 follow_type = lookup_lvalue_reference_type (follow_type);
2228 break;
2229 case tp_array:
2230 array_size = type_stack->pop_int ();
2231 if (array_size != -1)
2232 {
2233 range_type =
2234 create_static_range_type ((struct type *) NULL,
2236 ->builtin_integer,
2237 0, array_size - 1);
2238 follow_type =
2239 create_array_type ((struct type *) NULL,
2240 follow_type, range_type);
2241 }
2242 else
2243 follow_type = lookup_pointer_type (follow_type);
2244 break;
2245 case tp_function:
2246 follow_type = lookup_function_type (follow_type);
2247 break;
2248 case tp_kind:
2249 {
2250 int kind_val = type_stack->pop_int ();
2251 follow_type
2252 = convert_to_kind_type (follow_type, kind_val);
2253 }
2254 break;
2255 }
2256 (yyval.tval) = follow_type;
2257 }
2258#line 2260 "f-exp.c.tmp"
2259 break;
2260
2261 case 73: /* abs_decl: '*' */
2262#line 700 "f-exp.y"
2263 { type_stack->push (tp_pointer); (yyval.voidval) = 0; }
2264#line 2266 "f-exp.c.tmp"
2265 break;
2266
2267 case 74: /* abs_decl: '*' abs_decl */
2268#line 702 "f-exp.y"
2269 { type_stack->push (tp_pointer); (yyval.voidval) = (yyvsp[0].voidval); }
2270#line 2272 "f-exp.c.tmp"
2271 break;
2272
2273 case 75: /* abs_decl: '&' */
2274#line 704 "f-exp.y"
2275 { type_stack->push (tp_reference); (yyval.voidval) = 0; }
2276#line 2278 "f-exp.c.tmp"
2277 break;
2278
2279 case 76: /* abs_decl: '&' abs_decl */
2280#line 706 "f-exp.y"
2281 { type_stack->push (tp_reference); (yyval.voidval) = (yyvsp[0].voidval); }
2282#line 2284 "f-exp.c.tmp"
2283 break;
2284
2285 case 78: /* direct_abs_decl: '(' abs_decl ')' */
2286#line 711 "f-exp.y"
2287 { (yyval.voidval) = (yyvsp[-1].voidval); }
2288#line 2290 "f-exp.c.tmp"
2289 break;
2290
2291 case 79: /* direct_abs_decl: '(' KIND '=' INT ')' */
2292#line 713 "f-exp.y"
2293 { push_kind_type ((yyvsp[-1].typed_val).val, (yyvsp[-1].typed_val).type); }
2294#line 2296 "f-exp.c.tmp"
2295 break;
2296
2297 case 80: /* direct_abs_decl: '*' INT */
2298#line 715 "f-exp.y"
2299 { push_kind_type ((yyvsp[0].typed_val).val, (yyvsp[0].typed_val).type); }
2300#line 2302 "f-exp.c.tmp"
2301 break;
2302
2303 case 81: /* direct_abs_decl: direct_abs_decl func_mod */
2304#line 717 "f-exp.y"
2306#line 2308 "f-exp.c.tmp"
2307 break;
2308
2309 case 82: /* direct_abs_decl: func_mod */
2310#line 719 "f-exp.y"
2312#line 2314 "f-exp.c.tmp"
2313 break;
2314
2315 case 83: /* func_mod: '(' ')' */
2316#line 723 "f-exp.y"
2317 { (yyval.voidval) = 0; }
2318#line 2320 "f-exp.c.tmp"
2319 break;
2320
2321 case 84: /* func_mod: '(' nonempty_typelist ')' */
2322#line 725 "f-exp.y"
2323 { xfree ((yyvsp[-1].tvec)); (yyval.voidval) = 0; }
2324#line 2326 "f-exp.c.tmp"
2325 break;
2326
2327 case 85: /* typebase: TYPENAME */
2328#line 730 "f-exp.y"
2329 { (yyval.tval) = (yyvsp[0].tsym).type; }
2330#line 2332 "f-exp.c.tmp"
2331 break;
2332
2333 case 86: /* typebase: INT_S1_KEYWORD */
2334#line 732 "f-exp.y"
2335 { (yyval.tval) = parse_f_type (pstate)->builtin_integer_s1; }
2336#line 2338 "f-exp.c.tmp"
2337 break;
2338
2339 case 87: /* typebase: INT_S2_KEYWORD */
2340#line 734 "f-exp.y"
2341 { (yyval.tval) = parse_f_type (pstate)->builtin_integer_s2; }
2342#line 2344 "f-exp.c.tmp"
2343 break;
2344
2345 case 88: /* typebase: INT_KEYWORD */
2346#line 736 "f-exp.y"
2347 { (yyval.tval) = parse_f_type (pstate)->builtin_integer; }
2348#line 2350 "f-exp.c.tmp"
2349 break;
2350
2351 case 89: /* typebase: INT_S4_KEYWORD */
2352#line 738 "f-exp.y"
2353 { (yyval.tval) = parse_f_type (pstate)->builtin_integer; }
2354#line 2356 "f-exp.c.tmp"
2355 break;
2356
2357 case 90: /* typebase: INT_S8_KEYWORD */
2358#line 740 "f-exp.y"
2359 { (yyval.tval) = parse_f_type (pstate)->builtin_integer_s8; }
2360#line 2362 "f-exp.c.tmp"
2361 break;
2362
2363 case 91: /* typebase: CHARACTER */
2364#line 742 "f-exp.y"
2365 { (yyval.tval) = parse_f_type (pstate)->builtin_character; }
2366#line 2368 "f-exp.c.tmp"
2367 break;
2368
2369 case 92: /* typebase: LOGICAL_S1_KEYWORD */
2370#line 744 "f-exp.y"
2371 { (yyval.tval) = parse_f_type (pstate)->builtin_logical_s1; }
2372#line 2374 "f-exp.c.tmp"
2373 break;
2374
2375 case 93: /* typebase: LOGICAL_S2_KEYWORD */
2376#line 746 "f-exp.y"
2377 { (yyval.tval) = parse_f_type (pstate)->builtin_logical_s2; }
2378#line 2380 "f-exp.c.tmp"
2379 break;
2380
2381 case 94: /* typebase: LOGICAL_KEYWORD */
2382#line 748 "f-exp.y"
2383 { (yyval.tval) = parse_f_type (pstate)->builtin_logical; }
2384#line 2386 "f-exp.c.tmp"
2385 break;
2386
2387 case 95: /* typebase: LOGICAL_S4_KEYWORD */
2388#line 750 "f-exp.y"
2389 { (yyval.tval) = parse_f_type (pstate)->builtin_logical; }
2390#line 2392 "f-exp.c.tmp"
2391 break;
2392
2393 case 96: /* typebase: LOGICAL_S8_KEYWORD */
2394#line 752 "f-exp.y"
2395 { (yyval.tval) = parse_f_type (pstate)->builtin_logical_s8; }
2396#line 2398 "f-exp.c.tmp"
2397 break;
2398
2399 case 97: /* typebase: REAL_KEYWORD */
2400#line 754 "f-exp.y"
2401 { (yyval.tval) = parse_f_type (pstate)->builtin_real; }
2402#line 2404 "f-exp.c.tmp"
2403 break;
2404
2405 case 98: /* typebase: REAL_S4_KEYWORD */
2406#line 756 "f-exp.y"
2407 { (yyval.tval) = parse_f_type (pstate)->builtin_real; }
2408#line 2410 "f-exp.c.tmp"
2409 break;
2410
2411 case 99: /* typebase: REAL_S8_KEYWORD */
2412#line 758 "f-exp.y"
2413 { (yyval.tval) = parse_f_type (pstate)->builtin_real_s8; }
2414#line 2416 "f-exp.c.tmp"
2415 break;
2416
2417 case 100: /* typebase: REAL_S16_KEYWORD */
2418#line 760 "f-exp.y"
2419 { (yyval.tval) = parse_f_type (pstate)->builtin_real_s16; }
2420#line 2422 "f-exp.c.tmp"
2421 break;
2422
2423 case 101: /* typebase: COMPLEX_KEYWORD */
2424#line 762 "f-exp.y"
2425 { (yyval.tval) = parse_f_type (pstate)->builtin_complex; }
2426#line 2428 "f-exp.c.tmp"
2427 break;
2428
2429 case 102: /* typebase: COMPLEX_S4_KEYWORD */
2430#line 764 "f-exp.y"
2431 { (yyval.tval) = parse_f_type (pstate)->builtin_complex; }
2432#line 2434 "f-exp.c.tmp"
2433 break;
2434
2435 case 103: /* typebase: COMPLEX_S8_KEYWORD */
2436#line 766 "f-exp.y"
2437 { (yyval.tval) = parse_f_type (pstate)->builtin_complex_s8; }
2438#line 2440 "f-exp.c.tmp"
2439 break;
2440
2441 case 104: /* typebase: COMPLEX_S16_KEYWORD */
2442#line 768 "f-exp.y"
2443 { (yyval.tval) = parse_f_type (pstate)->builtin_complex_s16; }
2444#line 2446 "f-exp.c.tmp"
2445 break;
2446
2447 case 105: /* typebase: SINGLE PRECISION */
2448#line 770 "f-exp.y"
2449 { (yyval.tval) = parse_f_type (pstate)->builtin_real;}
2450#line 2452 "f-exp.c.tmp"
2451 break;
2452
2453 case 106: /* typebase: DOUBLE PRECISION */
2454#line 772 "f-exp.y"
2455 { (yyval.tval) = parse_f_type (pstate)->builtin_real_s8;}
2456#line 2458 "f-exp.c.tmp"
2457 break;
2458
2459 case 107: /* typebase: SINGLE COMPLEX_KEYWORD */
2460#line 774 "f-exp.y"
2461 { (yyval.tval) = parse_f_type (pstate)->builtin_complex;}
2462#line 2464 "f-exp.c.tmp"
2463 break;
2464
2465 case 108: /* typebase: DOUBLE COMPLEX_KEYWORD */
2466#line 776 "f-exp.y"
2467 { (yyval.tval) = parse_f_type (pstate)->builtin_complex_s8;}
2468#line 2470 "f-exp.c.tmp"
2469 break;
2470
2471 case 109: /* nonempty_typelist: type */
2472#line 781 "f-exp.y"
2473 { (yyval.tvec) = (struct type **) xmalloc (sizeof (struct type *) * 2);
2474 (yyval.ivec)[0] = 1; /* Number of types in vector */
2475 (yyval.tvec)[1] = (yyvsp[0].tval);
2476 }
2477#line 2479 "f-exp.c.tmp"
2478 break;
2479
2480 case 110: /* nonempty_typelist: nonempty_typelist ',' type */
2481#line 786 "f-exp.y"
2482 { int len = sizeof (struct type *) * (++((yyvsp[-2].ivec)[0]) + 1);
2483 (yyval.tvec) = (struct type **) xrealloc ((char *) (yyvsp[-2].tvec), len);
2484 (yyval.tvec)[(yyval.ivec)[0]] = (yyvsp[0].tval);
2485 }
2486#line 2488 "f-exp.c.tmp"
2487 break;
2488
2489 case 111: /* name: NAME */
2490#line 794 "f-exp.y"
2491 { (yyval.sval) = (yyvsp[0].ssym).stoken; }
2492#line 2494 "f-exp.c.tmp"
2493 break;
2494
2495 case 112: /* name: TYPENAME */
2496#line 796 "f-exp.y"
2497 { (yyval.sval) = (yyvsp[0].tsym).stoken; }
2498#line 2500 "f-exp.c.tmp"
2499 break;
2500
2501
2502#line 2504 "f-exp.c.tmp"
2503
2504 default: break;
2505 }
2506 /* User semantic actions sometimes alter yychar, and that requires
2507 that yytoken be updated with the new translation. We take the
2508 approach of translating immediately before every use of yytoken.
2509 One alternative is translating here after every semantic action,
2510 but that translation would be missed if the semantic action invokes
2511 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2512 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2513 incorrect destructor might then be invoked immediately. In the
2514 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2515 to an incorrect destructor call or verbose syntax error message
2516 before the lookahead is translated. */
2517 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
2518
2519 YYPOPSTACK (yylen);
2520 yylen = 0;
2521
2522 *++yyvsp = yyval;
2523
2524 /* Now 'shift' the result of the reduction. Determine what state
2525 that goes to, based on the state we popped back to and the rule
2526 number reduced by. */
2527 {
2528 const int yylhs = yyr1[yyn] - YYNTOKENS;
2529 const int yyi = yypgoto[yylhs] + *yyssp;
2530 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
2531 ? yytable[yyi]
2532 : yydefgoto[yylhs]);
2533 }
2534
2535 goto yynewstate;
2536
2537
2538/*--------------------------------------.
2539| yyerrlab -- here on detecting error. |
2540`--------------------------------------*/
2541yyerrlab:
2542 /* Make sure we have latest lookahead translation. See comments at
2543 user semantic actions for why this is necessary. */
2545 /* If not already recovering from an error, report this error. */
2546 if (!yyerrstatus)
2547 {
2548 ++yynerrs;
2549 yyerror (YY_("syntax error"));
2550 }
2551
2552 if (yyerrstatus == 3)
2553 {
2554 /* If just tried and failed to reuse lookahead token after an
2555 error, discard it. */
2556
2557 if (yychar <= YYEOF)
2558 {
2559 /* Return failure if at end of input. */
2560 if (yychar == YYEOF)
2561 YYABORT;
2562 }
2563 else
2564 {
2565 yydestruct ("Error: discarding",
2566 yytoken, &yylval);
2567 yychar = YYEMPTY;
2568 }
2569 }
2570
2571 /* Else will try to reuse lookahead token after shifting the error
2572 token. */
2573 goto yyerrlab1;
2574
2575
2576/*---------------------------------------------------.
2577| yyerrorlab -- error raised explicitly by YYERROR. |
2578`---------------------------------------------------*/
2579yyerrorlab:
2580 /* Pacify compilers when the user code never invokes YYERROR and the
2581 label yyerrorlab therefore never appears in user code. */
2582 if (0)
2583 YYERROR;
2584 ++yynerrs;
2585
2586 /* Do not reclaim the symbols of the rule whose action triggered
2587 this YYERROR. */
2588 YYPOPSTACK (yylen);
2589 yylen = 0;
2591 yystate = *yyssp;
2592 goto yyerrlab1;
2593
2594
2595/*-------------------------------------------------------------.
2596| yyerrlab1 -- common code for both syntax error and YYERROR. |
2597`-------------------------------------------------------------*/
2598yyerrlab1:
2599 yyerrstatus = 3; /* Each real token shifted decrements this. */
2600
2601 /* Pop stack until we find a state that shifts the error token. */
2602 for (;;)
2603 {
2604 yyn = yypact[yystate];
2605 if (!yypact_value_is_default (yyn))
2606 {
2607 yyn += YYSYMBOL_YYerror;
2608 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
2609 {
2610 yyn = yytable[yyn];
2611 if (0 < yyn)
2612 break;
2613 }
2614 }
2615
2616 /* Pop the current state because it cannot handle the error token. */
2617 if (yyssp == yyss)
2618 YYABORT;
2619
2620
2621 yydestruct ("Error: popping",
2623 YYPOPSTACK (1);
2624 yystate = *yyssp;
2626 }
2627
2629 *++yyvsp = yylval;
2631
2632
2633 /* Shift the error token. */
2634 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
2635
2636 yystate = yyn;
2637 goto yynewstate;
2638
2639
2640/*-------------------------------------.
2641| yyacceptlab -- YYACCEPT comes here. |
2642`-------------------------------------*/
2643yyacceptlab:
2644 yyresult = 0;
2645 goto yyreturnlab;
2646
2647
2648/*-----------------------------------.
2649| yyabortlab -- YYABORT comes here. |
2650`-----------------------------------*/
2651yyabortlab:
2652 yyresult = 1;
2653 goto yyreturnlab;
2654
2655
2656/*-----------------------------------------------------------.
2657| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. |
2658`-----------------------------------------------------------*/
2659yyexhaustedlab:
2660 yyerror (YY_("memory exhausted"));
2661 yyresult = 2;
2662 goto yyreturnlab;
2663
2664
2665/*----------------------------------------------------------.
2666| yyreturnlab -- parsing is finished, clean up and return. |
2667`----------------------------------------------------------*/
2668yyreturnlab:
2669 if (yychar != YYEMPTY)
2670 {
2671 /* Make sure we have latest lookahead translation. See comments at
2672 user semantic actions for why this is necessary. */
2673 yytoken = YYTRANSLATE (yychar);
2674 yydestruct ("Cleanup: discarding lookahead",
2675 yytoken, &yylval);
2676 }
2677 /* Do not reclaim the symbols of the rule whose action triggered
2678 this YYABORT or YYACCEPT. */
2679 YYPOPSTACK (yylen);
2681 while (yyssp != yyss)
2682 {
2683 yydestruct ("Cleanup: popping",
2685 YYPOPSTACK (1);
2686 }
2687#ifndef yyoverflow
2688 if (yyss != yyssa)
2690#endif
2691
2692 return yyresult;
2693}
2694
2695#line 809 "f-exp.y"
2696
2697
2698/* Called to match intrinsic function calls with one argument to their
2699 respective implementation and push the operation. */
2700
2701static void
2703{
2704 switch (code)
2705 {
2706 case UNOP_ABS:
2708 break;
2709 case FORTRAN_FLOOR:
2711 break;
2712 case FORTRAN_CEILING:
2714 break;
2715 case UNOP_FORTRAN_ALLOCATED:
2717 break;
2718 case UNOP_FORTRAN_RANK:
2720 break;
2721 case UNOP_FORTRAN_SHAPE:
2723 break;
2724 case UNOP_FORTRAN_LOC:
2726 break;
2727 case FORTRAN_ASSOCIATED:
2729 break;
2730 case FORTRAN_ARRAY_SIZE:
2732 break;
2733 case FORTRAN_CMPLX:
2735 break;
2736 case FORTRAN_LBOUND:
2737 case FORTRAN_UBOUND:
2739 break;
2740 default:
2741 gdb_assert_not_reached ("unhandled intrinsic");
2742 }
2743}
2744
2745/* Called to match intrinsic function calls with two arguments to their
2746 respective implementation and push the operation. */
2747
2748static void
2750{
2751 switch (code)
2752 {
2753 case FORTRAN_FLOOR:
2754 fortran_wrap2_kind<fortran_floor_operation_2arg>
2755 (parse_f_type (pstate)->builtin_integer);
2756 break;
2757 case FORTRAN_CEILING:
2758 fortran_wrap2_kind<fortran_ceil_operation_2arg>
2759 (parse_f_type (pstate)->builtin_integer);
2760 break;
2761 case BINOP_MOD:
2763 break;
2764 case BINOP_FORTRAN_MODULO:
2766 break;
2767 case FORTRAN_CMPLX:
2769 break;
2770 case FORTRAN_ASSOCIATED:
2772 break;
2773 case FORTRAN_ARRAY_SIZE:
2775 break;
2776 case FORTRAN_LBOUND:
2777 case FORTRAN_UBOUND:
2778 {
2779 operation_up arg2 = pstate->pop ();
2780 operation_up arg1 = pstate->pop ();
2781 pstate->push_new<fortran_bound_2arg> (code, std::move (arg1),
2782 std::move (arg2));
2783 }
2784 break;
2785 default:
2786 gdb_assert_not_reached ("unhandled intrinsic");
2787 }
2788}
2789
2790/* Called to match intrinsic function calls with three arguments to their
2791 respective implementation and push the operation. */
2792
2793static void
2795{
2796 switch (code)
2797 {
2798 case FORTRAN_LBOUND:
2799 case FORTRAN_UBOUND:
2800 {
2801 operation_up kind_arg = pstate->pop ();
2802 operation_up arg2 = pstate->pop ();
2803 operation_up arg1 = pstate->pop ();
2804
2805 value *val = kind_arg->evaluate (nullptr, pstate->expout.get (),
2807 gdb_assert (val != nullptr);
2808
2809 type *follow_type
2810 = convert_to_kind_type (parse_f_type (pstate)->builtin_integer,
2811 value_as_long (val));
2812
2813 pstate->push_new<fortran_bound_3arg> (code, std::move (arg1),
2814 std::move (arg2), follow_type);
2815 }
2816 break;
2817 case FORTRAN_ARRAY_SIZE:
2818 fortran_wrap3_kind<fortran_array_size_3arg>
2819 (parse_f_type (pstate)->builtin_integer);
2820 break;
2821 case FORTRAN_CMPLX:
2822 fortran_wrap3_kind<fortran_cmplx_operation_3arg>
2823 (parse_f_type (pstate)->builtin_complex);
2824 break;
2825 default:
2826 gdb_assert_not_reached ("unhandled intrinsic");
2827 }
2828}
2829
2830/* A helper that pops two operations (similar to wrap2), evaluates the last one
2831 assuming it is a kind parameter, and wraps them in some other operation
2832 pushing it to the stack. */
2833
2834template<typename T>
2835static void
2837{
2838 operation_up kind_arg = pstate->pop ();
2839 operation_up arg = pstate->pop ();
2840
2841 value *val = kind_arg->evaluate (nullptr, pstate->expout.get (),
2843 gdb_assert (val != nullptr);
2844
2845 type *follow_type = convert_to_kind_type (base_type, value_as_long (val));
2846
2847 pstate->push_new<T> (std::move (arg), follow_type);
2848}
2849
2850/* A helper that pops three operations, evaluates the last one assuming it is a
2851 kind parameter, and wraps them in some other operation pushing it to the
2852 stack. */
2853
2854template<typename T>
2855static void
2857{
2858 operation_up kind_arg = pstate->pop ();
2859 operation_up arg2 = pstate->pop ();
2860 operation_up arg1 = pstate->pop ();
2861
2862 value *val = kind_arg->evaluate (nullptr, pstate->expout.get (),
2864 gdb_assert (val != nullptr);
2865
2866 type *follow_type = convert_to_kind_type (base_type, value_as_long (val));
2867
2868 pstate->push_new<T> (std::move (arg1), std::move (arg2), follow_type);
2869}
2870
2871/* Take care of parsing a number (anything that starts with a digit).
2872 Set yylval and return the token type; update lexptr.
2873 LEN is the number of characters in it. */
2874
2875/*** Needs some error checking for the float case ***/
2876
2877static int
2878parse_number (struct parser_state *par_state,
2879 const char *p, int len, int parsed_float, YYSTYPE *putithere)
2880{
2881 ULONGEST n = 0;
2882 ULONGEST prevn = 0;
2883 int c;
2884 int base = input_radix;
2885 int unsigned_p = 0;
2886 int long_p = 0;
2887 ULONGEST high_bit;
2888 struct type *signed_type;
2889 struct type *unsigned_type;
2890
2891 if (parsed_float)
2892 {
2893 /* It's a float since it contains a point or an exponent. */
2894 /* [dD] is not understood as an exponent by parse_float,
2895 change it to 'e'. */
2896 char *tmp, *tmp2;
2897
2898 tmp = xstrdup (p);
2899 for (tmp2 = tmp; *tmp2; ++tmp2)
2900 if (*tmp2 == 'd' || *tmp2 == 'D')
2901 *tmp2 = 'e';
2902
2903 /* FIXME: Should this use different types? */
2904 putithere->typed_val_float.type = parse_f_type (pstate)->builtin_real_s8;
2905 bool parsed = parse_float (tmp, len,
2906 putithere->typed_val_float.type,
2907 putithere->typed_val_float.val);
2908 xfree (tmp);
2909 return parsed? FLOAT : ERROR;
2910 }
2911
2912 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
2913 if (p[0] == '0' && len > 1)
2914 switch (p[1])
2915 {
2916 case 'x':
2917 case 'X':
2918 if (len >= 3)
2919 {
2920 p += 2;
2921 base = 16;
2922 len -= 2;
2923 }
2924 break;
2925
2926 case 't':
2927 case 'T':
2928 case 'd':
2929 case 'D':
2930 if (len >= 3)
2931 {
2932 p += 2;
2933 base = 10;
2934 len -= 2;
2935 }
2936 break;
2937
2938 default:
2939 base = 8;
2940 break;
2941 }
2942
2943 while (len-- > 0)
2944 {
2945 c = *p++;
2946 if (isupper (c))
2947 c = tolower (c);
2948 if (len == 0 && c == 'l')
2949 long_p = 1;
2950 else if (len == 0 && c == 'u')
2951 unsigned_p = 1;
2952 else
2953 {
2954 int i;
2955 if (c >= '0' && c <= '9')
2956 i = c - '0';
2957 else if (c >= 'a' && c <= 'f')
2958 i = c - 'a' + 10;
2959 else
2960 return ERROR; /* Char not a digit */
2961 if (i >= base)
2962 return ERROR; /* Invalid digit in this base */
2963 n *= base;
2964 n += i;
2965 }
2966 /* Test for overflow. */
2967 if (prevn == 0 && n == 0)
2968 ;
2969 else if (RANGE_CHECK && prevn >= n)
2970 range_error (_("Overflow on numeric constant."));
2971 prevn = n;
2972 }
2973
2974 /* If the number is too big to be an int, or it's got an l suffix
2975 then it's a long. Work out if this has to be a long by
2976 shifting right and seeing if anything remains, and the
2977 target int size is different to the target long size.
2978
2979 In the expression below, we could have tested
2980 (n >> gdbarch_int_bit (parse_gdbarch))
2981 to see if it was zero,
2982 but too many compilers warn about that, when ints and longs
2983 are the same size. So we shift it twice, with fewer bits
2984 each time, for the same result. */
2985
2986 int bits_available;
2987 if ((gdbarch_int_bit (par_state->gdbarch ())
2988 != gdbarch_long_bit (par_state->gdbarch ())
2989 && ((n >> 2)
2990 >> (gdbarch_int_bit (par_state->gdbarch ())-2))) /* Avoid
2991 shift warning */
2992 || long_p)
2993 {
2994 bits_available = gdbarch_long_bit (par_state->gdbarch ());
2995 unsigned_type = parse_type (par_state)->builtin_unsigned_long;
2996 signed_type = parse_type (par_state)->builtin_long;
2997 }
2998 else
2999 {
3000 bits_available = gdbarch_int_bit (par_state->gdbarch ());
3001 unsigned_type = parse_type (par_state)->builtin_unsigned_int;
3002 signed_type = parse_type (par_state)->builtin_int;
3003 }
3004 high_bit = ((ULONGEST)1) << (bits_available - 1);
3005
3006 if (RANGE_CHECK
3007 && ((n >> 2) >> (bits_available - 2)))
3008 range_error (_("Overflow on numeric constant."));
3009
3010 putithere->typed_val.val = n;
3011
3012 /* If the high bit of the worked out type is set then this number
3013 has to be unsigned. */
3014
3015 if (unsigned_p || (n & high_bit))
3016 putithere->typed_val.type = unsigned_type;
3017 else
3018 putithere->typed_val.type = signed_type;
3019
3020 return INT;
3021}
3022
3023/* Called to setup the type stack when we encounter a '(kind=N)' type
3024 modifier, performs some bounds checking on 'N' and then pushes this to
3025 the type stack followed by the 'tp_kind' marker. */
3026static void
3027push_kind_type (LONGEST val, struct type *type)
3028{
3029 int ival;
3030
3031 if (type->is_unsigned ())
3032 {
3033 ULONGEST uval = static_cast <ULONGEST> (val);
3034 if (uval > INT_MAX)
3035 error (_("kind value out of range"));
3036 ival = static_cast <int> (uval);
3037 }
3038 else
3039 {
3040 if (val > INT_MAX || val < 0)
3041 error (_("kind value out of range"));
3042 ival = static_cast <int> (val);
3043 }
3044
3045 type_stack->push (ival);
3047}
3048
3049/* Called when a type has a '(kind=N)' modifier after it, for example
3050 'character(kind=1)'. The BASETYPE is the type described by 'character'
3051 in our example, and KIND is the integer '1'. This function returns a
3052 new type that represents the basetype of a specific kind. */
3053static struct type *
3054convert_to_kind_type (struct type *basetype, int kind)
3055{
3056 if (basetype == parse_f_type (pstate)->builtin_character)
3057 {
3058 /* Character of kind 1 is a special case, this is the same as the
3059 base character type. */
3060 if (kind == 1)
3061 return parse_f_type (pstate)->builtin_character;
3062 }
3063 else if (basetype == parse_f_type (pstate)->builtin_complex)
3064 {
3065 if (kind == 4)
3066 return parse_f_type (pstate)->builtin_complex;
3067 else if (kind == 8)
3068 return parse_f_type (pstate)->builtin_complex_s8;
3069 else if (kind == 16)
3070 return parse_f_type (pstate)->builtin_complex_s16;
3071 }
3072 else if (basetype == parse_f_type (pstate)->builtin_real)
3073 {
3074 if (kind == 4)
3075 return parse_f_type (pstate)->builtin_real;
3076 else if (kind == 8)
3077 return parse_f_type (pstate)->builtin_real_s8;
3078 else if (kind == 16)
3079 return parse_f_type (pstate)->builtin_real_s16;
3080 }
3081 else if (basetype == parse_f_type (pstate)->builtin_logical)
3082 {
3083 if (kind == 1)
3084 return parse_f_type (pstate)->builtin_logical_s1;
3085 else if (kind == 2)
3086 return parse_f_type (pstate)->builtin_logical_s2;
3087 else if (kind == 4)
3088 return parse_f_type (pstate)->builtin_logical;
3089 else if (kind == 8)
3090 return parse_f_type (pstate)->builtin_logical_s8;
3091 }
3092 else if (basetype == parse_f_type (pstate)->builtin_integer)
3093 {
3094 if (kind == 1)
3095 return parse_f_type (pstate)->builtin_integer_s1;
3096 else if (kind == 2)
3097 return parse_f_type (pstate)->builtin_integer_s2;
3098 else if (kind == 4)
3099 return parse_f_type (pstate)->builtin_integer;
3100 else if (kind == 8)
3101 return parse_f_type (pstate)->builtin_integer_s8;
3102 }
3103
3104 error (_("unsupported kind %d for type %s"),
3105 kind, TYPE_SAFE_NAME (basetype));
3106
3107 /* Should never get here. */
3108 return nullptr;
3109}
3110
3111struct token
3112{
3113 /* The string to match against. */
3114 const char *oper;
3115
3116 /* The lexer token to return. */
3117 int token;
3118
3119 /* The expression opcode to embed within the token. */
3120 enum exp_opcode opcode;
3121
3122 /* When this is true the string in OPER is matched exactly including
3123 case, when this is false OPER is matched case insensitively. */
3125};
3126
3127/* List of Fortran operators. */
3128
3129static const struct token fortran_operators[] =
3130{
3131 { ".and.", BOOL_AND, OP_NULL, false },
3132 { ".or.", BOOL_OR, OP_NULL, false },
3133 { ".not.", BOOL_NOT, OP_NULL, false },
3134 { ".eq.", EQUAL, OP_NULL, false },
3135 { ".eqv.", EQUAL, OP_NULL, false },
3136 { ".neqv.", NOTEQUAL, OP_NULL, false },
3137 { ".xor.", NOTEQUAL, OP_NULL, false },
3138 { "==", EQUAL, OP_NULL, false },
3139 { ".ne.", NOTEQUAL, OP_NULL, false },
3140 { "/=", NOTEQUAL, OP_NULL, false },
3141 { ".le.", LEQ, OP_NULL, false },
3142 { "<=", LEQ, OP_NULL, false },
3143 { ".ge.", GEQ, OP_NULL, false },
3144 { ">=", GEQ, OP_NULL, false },
3145 { ".gt.", GREATERTHAN, OP_NULL, false },
3146 { ">", GREATERTHAN, OP_NULL, false },
3147 { ".lt.", LESSTHAN, OP_NULL, false },
3148 { "<", LESSTHAN, OP_NULL, false },
3149 { "**", STARSTAR, BINOP_EXP, false },
3150};
3151
3152/* Holds the Fortran representation of a boolean, and the integer value we
3153 substitute in when one of the matching strings is parsed. */
3155{
3156 /* The string representing a Fortran boolean. */
3157 const char *name;
3158
3159 /* The integer value to replace it with. */
3161};
3162
3163/* The set of Fortran booleans. These are matched case insensitively. */
3164static const struct f77_boolean_val boolean_values[] =
3165{
3166 { ".true.", 1 },
3167 { ".false.", 0 }
3168};
3169
3170static const token f_keywords[] =
3171{
3172 /* Historically these have always been lowercase only in GDB. */
3173 { "character", CHARACTER, OP_NULL, true },
3174 { "complex", COMPLEX_KEYWORD, OP_NULL, true },
3175 { "complex_4", COMPLEX_S4_KEYWORD, OP_NULL, true },
3176 { "complex_8", COMPLEX_S8_KEYWORD, OP_NULL, true },
3177 { "complex_16", COMPLEX_S16_KEYWORD, OP_NULL, true },
3178 { "integer_1", INT_S1_KEYWORD, OP_NULL, true },
3179 { "integer_2", INT_S2_KEYWORD, OP_NULL, true },
3180 { "integer_4", INT_S4_KEYWORD, OP_NULL, true },
3181 { "integer", INT_KEYWORD, OP_NULL, true },
3182 { "integer_8", INT_S8_KEYWORD, OP_NULL, true },
3183 { "logical_1", LOGICAL_S1_KEYWORD, OP_NULL, true },
3184 { "logical_2", LOGICAL_S2_KEYWORD, OP_NULL, true },
3185 { "logical", LOGICAL_KEYWORD, OP_NULL, true },
3186 { "logical_4", LOGICAL_S4_KEYWORD, OP_NULL, true },
3187 { "logical_8", LOGICAL_S8_KEYWORD, OP_NULL, true },
3188 { "real", REAL_KEYWORD, OP_NULL, true },
3189 { "real_4", REAL_S4_KEYWORD, OP_NULL, true },
3190 { "real_8", REAL_S8_KEYWORD, OP_NULL, true },
3191 { "real_16", REAL_S16_KEYWORD, OP_NULL, true },
3192 { "sizeof", SIZEOF, OP_NULL, true },
3193 { "single", SINGLE, OP_NULL, true },
3194 { "double", DOUBLE, OP_NULL, true },
3195 { "precision", PRECISION, OP_NULL, true },
3196 /* The following correspond to actual functions in Fortran and are case
3197 insensitive. */
3198 { "kind", KIND, OP_NULL, false },
3199 { "abs", UNOP_INTRINSIC, UNOP_ABS, false },
3200 { "mod", BINOP_INTRINSIC, BINOP_MOD, false },
3201 { "floor", UNOP_OR_BINOP_INTRINSIC, FORTRAN_FLOOR, false },
3202 { "ceiling", UNOP_OR_BINOP_INTRINSIC, FORTRAN_CEILING, false },
3203 { "modulo", BINOP_INTRINSIC, BINOP_FORTRAN_MODULO, false },
3204 { "cmplx", UNOP_OR_BINOP_OR_TERNOP_INTRINSIC, FORTRAN_CMPLX, false },
3205 { "lbound", UNOP_OR_BINOP_OR_TERNOP_INTRINSIC, FORTRAN_LBOUND, false },
3206 { "ubound", UNOP_OR_BINOP_OR_TERNOP_INTRINSIC, FORTRAN_UBOUND, false },
3207 { "allocated", UNOP_INTRINSIC, UNOP_FORTRAN_ALLOCATED, false },
3208 { "associated", UNOP_OR_BINOP_INTRINSIC, FORTRAN_ASSOCIATED, false },
3209 { "rank", UNOP_INTRINSIC, UNOP_FORTRAN_RANK, false },
3210 { "size", UNOP_OR_BINOP_OR_TERNOP_INTRINSIC, FORTRAN_ARRAY_SIZE, false },
3211 { "shape", UNOP_INTRINSIC, UNOP_FORTRAN_SHAPE, false },
3212 { "loc", UNOP_INTRINSIC, UNOP_FORTRAN_LOC, false },
3213};
3214
3215/* Implementation of a dynamically expandable buffer for processing input
3216 characters acquired through lexptr and building a value to return in
3217 yylval. Ripped off from ch-exp.y */
3218
3219static char *tempbuf; /* Current buffer contents */
3220static int tempbufsize; /* Size of allocated buffer */
3221static int tempbufindex; /* Current index into buffer */
3222
3223#define GROWBY_MIN_SIZE 64 /* Minimum amount to grow buffer by */
3224
3225#define CHECKBUF(size) \
3226 do { \
3227 if (tempbufindex + (size) >= tempbufsize) \
3228 { \
3229 growbuf_by_size (size); \
3230 } \
3231 } while (0);
3232
3233
3234/* Grow the static temp buffer if necessary, including allocating the
3235 first one on demand. */
3236
3237static void
3239{
3240 int growby;
3241
3242 growby = std::max (count, GROWBY_MIN_SIZE);
3243 tempbufsize += growby;
3244 if (tempbuf == NULL)
3245 tempbuf = (char *) xmalloc (tempbufsize);
3246 else
3247 tempbuf = (char *) xrealloc (tempbuf, tempbufsize);
3248}
3249
3250/* Blatantly ripped off from ch-exp.y. This routine recognizes F77
3251 string-literals.
3252
3253 Recognize a string literal. A string literal is a nonzero sequence
3254 of characters enclosed in matching single quotes, except that
3255 a single character inside single quotes is a character literal, which
3256 we reject as a string literal. To embed the terminator character inside
3257 a string, it is simply doubled (I.E. 'this''is''one''string') */
3258
3259static int
3261{
3262 const char *tokptr = pstate->lexptr;
3263
3264 for (tempbufindex = 0, tokptr++; *tokptr != '\0'; tokptr++)
3265 {
3266 CHECKBUF (1);
3267 if (*tokptr == *pstate->lexptr)
3268 {
3269 if (*(tokptr + 1) == *pstate->lexptr)
3270 tokptr++;
3271 else
3272 break;
3273 }
3274 tempbuf[tempbufindex++] = *tokptr;
3275 }
3276 if (*tokptr == '\0' /* no terminator */
3277 || tempbufindex == 0) /* no string */
3278 return 0;
3279 else
3280 {
3281 tempbuf[tempbufindex] = '\0';
3284 pstate->lexptr = ++tokptr;
3285 return STRING_LITERAL;
3286 }
3287}
3288
3289/* This is set if a NAME token appeared at the very end of the input
3290 string, with no whitespace separating the name from the EOF. This
3291 is used only when parsing to do field name completion. */
3293
3294/* This is set if the previously-returned token was a structure
3295 operator '%'. */
3297
3298/* Read one token, getting characters through lexptr. */
3299
3300static int
3301yylex (void)
3302{
3303 int c;
3304 int namelen;
3305 unsigned int token;
3306 const char *tokstart;
3307 bool saw_structop = last_was_structop;
3308
3309 last_was_structop = false;
3310
3311 retry:
3312
3314
3315 tokstart = pstate->lexptr;
3316
3317 /* First of all, let us make sure we are not dealing with the
3318 special tokens .true. and .false. which evaluate to 1 and 0. */
3319
3320 if (*pstate->lexptr == '.')
3321 {
3322 for (const auto &candidate : boolean_values)
3323 {
3324 if (strncasecmp (tokstart, candidate.name,
3325 strlen (candidate.name)) == 0)
3326 {
3327 pstate->lexptr += strlen (candidate.name);
3328 yylval.lval = candidate.value;
3329 return BOOLEAN_LITERAL;
3330 }
3331 }
3332 }
3333
3334 /* See if it is a Fortran operator. */
3335 for (const auto &candidate : fortran_operators)
3336 if (strncasecmp (tokstart, candidate.oper,
3337 strlen (candidate.oper)) == 0)
3338 {
3339 gdb_assert (!candidate.case_sensitive);
3340 pstate->lexptr += strlen (candidate.oper);
3341 yylval.opcode = candidate.opcode;
3342 return candidate.token;
3343 }
3344
3345 switch (c = *tokstart)
3346 {
3347 case 0:
3348 if (saw_name_at_eof)
3349 {
3350 saw_name_at_eof = false;
3351 return COMPLETE;
3352 }
3353 else if (pstate->parse_completion && saw_structop)
3354 return COMPLETE;
3355 return 0;
3356
3357 case ' ':
3358 case '\t':
3359 case '\n':
3360 pstate->lexptr++;
3361 goto retry;
3362
3363 case '\'':
3365 if (token != 0)
3366 return (token);
3367 break;
3368
3369 case '(':
3370 paren_depth++;
3371 pstate->lexptr++;
3372 return c;
3373
3374 case ')':
3375 if (paren_depth == 0)
3376 return 0;
3377 paren_depth--;
3378 pstate->lexptr++;
3379 return c;
3380
3381 case ',':
3382 if (pstate->comma_terminates && paren_depth == 0)
3383 return 0;
3384 pstate->lexptr++;
3385 return c;
3386
3387 case '.':
3388 /* Might be a floating point number. */
3389 if (pstate->lexptr[1] < '0' || pstate->lexptr[1] > '9')
3390 goto symbol; /* Nope, must be a symbol. */
3391 /* FALL THRU. */
3392
3393 case '0':
3394 case '1':
3395 case '2':
3396 case '3':
3397 case '4':
3398 case '5':
3399 case '6':
3400 case '7':
3401 case '8':
3402 case '9':
3403 {
3404 /* It's a number. */
3405 int got_dot = 0, got_e = 0, got_d = 0, toktype;
3406 const char *p = tokstart;
3407 int hex = input_radix > 10;
3408
3409 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
3410 {
3411 p += 2;
3412 hex = 1;
3413 }
3414 else if (c == '0' && (p[1]=='t' || p[1]=='T'
3415 || p[1]=='d' || p[1]=='D'))
3416 {
3417 p += 2;
3418 hex = 0;
3419 }
3420
3421 for (;; ++p)
3422 {
3423 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
3424 got_dot = got_e = 1;
3425 else if (!hex && !got_d && (*p == 'd' || *p == 'D'))
3426 got_dot = got_d = 1;
3427 else if (!hex && !got_dot && *p == '.')
3428 got_dot = 1;
3429 else if (((got_e && (p[-1] == 'e' || p[-1] == 'E'))
3430 || (got_d && (p[-1] == 'd' || p[-1] == 'D')))
3431 && (*p == '-' || *p == '+'))
3432 /* This is the sign of the exponent, not the end of the
3433 number. */
3434 continue;
3435 /* We will take any letters or digits. parse_number will
3436 complain if past the radix, or if L or U are not final. */
3437 else if ((*p < '0' || *p > '9')
3438 && ((*p < 'a' || *p > 'z')
3439 && (*p < 'A' || *p > 'Z')))
3440 break;
3441 }
3442 toktype = parse_number (pstate, tokstart, p - tokstart,
3443 got_dot|got_e|got_d,
3444 &yylval);
3445 if (toktype == ERROR)
3446 {
3447 char *err_copy = (char *) alloca (p - tokstart + 1);
3448
3449 memcpy (err_copy, tokstart, p - tokstart);
3450 err_copy[p - tokstart] = 0;
3451 error (_("Invalid number \"%s\"."), err_copy);
3452 }
3453 pstate->lexptr = p;
3454 return toktype;
3455 }
3456
3457 case '%':
3458 last_was_structop = true;
3459 /* Fall through. */
3460 case '+':
3461 case '-':
3462 case '*':
3463 case '/':
3464 case '|':
3465 case '&':
3466 case '^':
3467 case '~':
3468 case '!':
3469 case '@':
3470 case '<':
3471 case '>':
3472 case '[':
3473 case ']':
3474 case '?':
3475 case ':':
3476 case '=':
3477 case '{':
3478 case '}':
3479 symbol:
3480 pstate->lexptr++;
3481 return c;
3482 }
3483
3484 if (!(c == '_' || c == '$' || c ==':'
3485 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
3486 /* We must have come across a bad character (e.g. ';'). */
3487 error (_("Invalid character '%c' in expression."), c);
3488
3489 namelen = 0;
3490 for (c = tokstart[namelen];
3491 (c == '_' || c == '$' || c == ':' || (c >= '0' && c <= '9')
3492 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
3493 c = tokstart[++namelen]);
3494
3495 /* The token "if" terminates the expression and is NOT
3496 removed from the input stream. */
3497
3498 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
3499 return 0;
3500
3501 pstate->lexptr += namelen;
3502
3503 /* Catch specific keywords. */
3504
3505 for (const auto &keyword : f_keywords)
3506 if (strlen (keyword.oper) == namelen
3507 && ((!keyword.case_sensitive
3508 && strncasecmp (tokstart, keyword.oper, namelen) == 0)
3509 || (keyword.case_sensitive
3510 && strncmp (tokstart, keyword.oper, namelen) == 0)))
3511 {
3512 yylval.opcode = keyword.opcode;
3513 return keyword.token;
3514 }
3515
3516 yylval.sval.ptr = tokstart;
3517 yylval.sval.length = namelen;
3518
3519 if (*tokstart == '$')
3520 return DOLLAR_VARIABLE;
3521
3522 /* Use token-type TYPENAME for symbols that happen to be defined
3523 currently as names of types; NAME for other symbols.
3524 The caller is not constrained to care about the distinction. */
3525 {
3526 std::string tmp = copy_name (yylval.sval);
3527 struct block_symbol result;
3528 const domain_enum lookup_domains[] =
3529 {
3531 VAR_DOMAIN,
3533 };
3534 int hextype;
3535
3536 for (const auto &domain : lookup_domains)
3537 {
3538 result = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
3539 domain, NULL);
3540 if (result.symbol && result.symbol->aclass () == LOC_TYPEDEF)
3541 {
3542 yylval.tsym.type = result.symbol->type ();
3543 return TYPENAME;
3544 }
3545
3546 if (result.symbol)
3547 break;
3548 }
3549
3552 pstate->gdbarch (), tmp.c_str ());
3553 if (yylval.tsym.type != NULL)
3554 return TYPENAME;
3555
3556 /* Input names that aren't symbols but ARE valid hex numbers,
3557 when the input radix permits them, can be names or numbers
3558 depending on the parse. Note we support radixes > 16 here. */
3559 if (!result.symbol
3560 && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
3561 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
3562 {
3563 YYSTYPE newlval; /* Its value is ignored. */
3564 hextype = parse_number (pstate, tokstart, namelen, 0, &newlval);
3565 if (hextype == INT)
3566 {
3567 yylval.ssym.sym = result;
3569 return NAME_OR_INT;
3570 }
3571 }
3572
3573 if (pstate->parse_completion && *pstate->lexptr == '\0')
3574 saw_name_at_eof = true;
3575
3576 /* Any other kind of symbol */
3577 yylval.ssym.sym = result;
3579 return NAME;
3580 }
3581}
3582
3583int
3584f_language::parser (struct parser_state *par_state) const
3585{
3586 /* Setting up the parser state. */
3587 scoped_restore pstate_restore = make_scoped_restore (&pstate);
3588 scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
3589 parser_debug);
3590 gdb_assert (par_state != NULL);
3591 pstate = par_state;
3592 last_was_structop = false;
3593 saw_name_at_eof = false;
3594 paren_depth = 0;
3595
3596 struct type_stack stack;
3597 scoped_restore restore_type_stack = make_scoped_restore (&type_stack,
3598 &stack);
3599
3600 int result = yyparse ();
3601 if (!result)
3603 return result;
3604}
3605
3606static void
3607yyerror (const char *msg)
3608{
3609 if (pstate->prev_lexptr)
3611
3612 error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);
3613}
const char *const name
Definition: aarch64-tdep.c:67
yytokentype
Definition: ada-exp.c:498
short yytype_uint8
Definition: ada-exp.c:808
yysymbol_kind_t
Definition: ada-exp.c:647
short yytype_int16
Definition: ada-exp.c:785
yytype_uint8 yy_state_t
Definition: ada-exp.c:861
static struct parser_state * pstate
Definition: ada-exp.c:104
int yy_state_fast_t
Definition: ada-exp.c:864
signed char yytype_int8
Definition: ada-exp.c:777
static int paren_depth
Definition: ada-lex.c:914
int code
Definition: ada-lex.l:688
void * xrealloc(void *ptr, size_t size)
Definition: alloc.c:65
static bool last_was_structop
Definition: c-exp.c:5291
static int saw_name_at_eof
Definition: c-exp.c:5287
int parser(struct parser_state *ps) const override
Definition: f-exp.c:3584
unsigned input_radix
Definition: valprint.c:165
#define INT_MAX
Definition: defs.h:457
exp_opcode
Definition: expression.h:44
@ EVAL_AVOID_SIDE_EFFECTS
Definition: expression.h:57
@ RANGE_LOW_BOUND_DEFAULT
Definition: expression.h:299
@ RANGE_HIGH_BOUND_DEFAULT
Definition: expression.h:302
@ RANGE_STANDARD
Definition: expression.h:296
@ RANGE_HAS_STRIDE
Definition: expression.h:308
#define INT_S4_KEYWORD
Definition: f-exp.c:251
#define BINOP_INTRINSIC
Definition: f-exp.c:276
#define BOOL_NOT
Definition: f-exp.c:268
static const char * yysymbol_name(yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED
Definition: f-exp.c:877
static void wrap_ternop_intrinsic(exp_opcode opcode)
Definition: f-exp.c:2794
#define LEQ
Definition: f-exp.c:284
#define DOLLAR_VARIABLE
Definition: f-exp.c:273
#define REAL_S8_KEYWORD
Definition: f-exp.c:260
int yynerrs
Definition: f-exp.c:1423
#define BOOL_AND
Definition: f-exp.c:266
#define CHARACTER
Definition: f-exp.c:272
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: f-exp.c:614
#define YYMAXDEPTH
Definition: f-exp.c:1390
#define NOTEQUAL
Definition: f-exp.c:281
#define INT_S2_KEYWORD
Definition: f-exp.c:249
#define GREATERTHAN
Definition: f-exp.c:283
#define TYPENAME
Definition: f-exp.c:242
#define COMPLEX_S16_KEYWORD
Definition: f-exp.c:265
#define YYSTACK_FREE
Definition: f-exp.c:675
#define LOGICAL_S2_KEYWORD
Definition: f-exp.c:254
static const yytype_int8 yytranslate[]
Definition: f-exp.c:789
static const token f_keywords[]
Definition: f-exp.c:3170
short yytype_uint8
Definition: f-exp.c:502
yysymbol_kind_t
Definition: f-exp.c:337
@ YYSYMBOL_type_exp
Definition: f-exp.c:413
@ YYSYMBOL_68_
Definition: f-exp.c:407
@ YYSYMBOL_complexnum
Definition: f-exp.c:420
@ YYSYMBOL_TYPENAME
Definition: f-exp.c:347
@ YYSYMBOL_YYUNDEF
Definition: f-exp.c:341
@ YYSYMBOL_name_not_typename
Definition: f-exp.c:430
@ YYSYMBOL_71_
Definition: f-exp.c:410
@ YYSYMBOL_DOUBLE
Definition: f-exp.c:375
@ YYSYMBOL_NAME_OR_INT
Definition: f-exp.c:349
@ YYSYMBOL_ASSIGN_MODIFY
Definition: f-exp.c:379
@ YYSYMBOL_STRING_LITERAL
Definition: f-exp.c:344
@ YYSYMBOL_arglist
Definition: f-exp.c:418
@ YYSYMBOL_47_
Definition: f-exp.c:386
@ YYSYMBOL_INT
Definition: f-exp.c:342
@ YYSYMBOL_60_
Definition: f-exp.c:399
@ YYSYMBOL_50_
Definition: f-exp.c:389
@ YYSYMBOL_76_1
Definition: f-exp.c:415
@ YYSYMBOL_INT_KEYWORD
Definition: f-exp.c:355
@ YYSYMBOL_NOTEQUAL
Definition: f-exp.c:392
@ YYSYMBOL_LOGICAL_KEYWORD
Definition: f-exp.c:360
@ YYSYMBOL_SIZEOF
Definition: f-exp.c:350
@ YYSYMBOL_UNARY
Definition: f-exp.c:406
@ YYSYMBOL_LEQ
Definition: f-exp.c:395
@ YYSYMBOL_YYerror
Definition: f-exp.c:340
@ YYSYMBOL_UNOP_OR_BINOP_INTRINSIC
Definition: f-exp.c:382
@ YYSYMBOL_GEQ
Definition: f-exp.c:396
@ YYSYMBOL_start
Definition: f-exp.c:412
@ YYSYMBOL_BOOL_NOT
Definition: f-exp.c:373
@ YYSYMBOL_exp
Definition: f-exp.c:414
@ YYSYMBOL_type
Definition: f-exp.c:422
@ YYSYMBOL_49_
Definition: f-exp.c:388
@ YYSYMBOL_INT_S8_KEYWORD
Definition: f-exp.c:357
@ YYSYMBOL_SINGLE
Definition: f-exp.c:374
@ YYSYMBOL_PRECISION
Definition: f-exp.c:376
@ YYSYMBOL_COMPLEX_S16_KEYWORD
Definition: f-exp.c:370
@ YYSYMBOL_REAL_S8_KEYWORD
Definition: f-exp.c:365
@ YYSYMBOL_REAL_S4_KEYWORD
Definition: f-exp.c:364
@ YYSYMBOL_COMPLETE
Definition: f-exp.c:348
@ YYSYMBOL_STARSTAR
Definition: f-exp.c:404
@ YYSYMBOL_COMPLEX_KEYWORD
Definition: f-exp.c:367
@ YYSYMBOL_63_
Definition: f-exp.c:402
@ YYSYMBOL_typebase
Definition: f-exp.c:427
@ YYSYMBOL_BOOL_OR
Definition: f-exp.c:372
@ YYSYMBOL_BOOL_AND
Definition: f-exp.c:371
@ YYSYMBOL_direct_abs_decl
Definition: f-exp.c:425
@ YYSYMBOL_51_
Definition: f-exp.c:390
@ YYSYMBOL_REAL_S16_KEYWORD
Definition: f-exp.c:366
@ YYSYMBOL_LOGICAL_S1_KEYWORD
Definition: f-exp.c:358
@ YYSYMBOL_LSH
Definition: f-exp.c:397
@ YYSYMBOL_48_
Definition: f-exp.c:387
@ YYSYMBOL_REAL_KEYWORD
Definition: f-exp.c:363
@ YYSYMBOL_61_
Definition: f-exp.c:400
@ YYSYMBOL_UNOP_INTRINSIC
Definition: f-exp.c:380
@ YYSYMBOL_INT_S2_KEYWORD
Definition: f-exp.c:354
@ YYSYMBOL_INT_S4_KEYWORD
Definition: f-exp.c:356
@ YYSYMBOL_BOOLEAN_LITERAL
Definition: f-exp.c:345
@ YYSYMBOL_64_
Definition: f-exp.c:403
@ YYSYMBOL_70_
Definition: f-exp.c:409
@ YYSYMBOL_RSH
Definition: f-exp.c:398
@ YYSYMBOL_KIND
Definition: f-exp.c:351
@ YYSYMBOL_name
Definition: f-exp.c:429
@ YYSYMBOL_LOGICAL_S4_KEYWORD
Definition: f-exp.c:361
@ YYSYMBOL_YYACCEPT
Definition: f-exp.c:411
@ YYSYMBOL_COMPLEX_S4_KEYWORD
Definition: f-exp.c:368
@ YYSYMBOL_COMPLEX_S8_KEYWORD
Definition: f-exp.c:369
@ YYSYMBOL_subrange
Definition: f-exp.c:419
@ YYSYMBOL_BINOP_INTRINSIC
Definition: f-exp.c:381
@ YYSYMBOL_78_3
Definition: f-exp.c:417
@ YYSYMBOL_ERROR
Definition: f-exp.c:352
@ YYSYMBOL_INT_S1_KEYWORD
Definition: f-exp.c:353
@ YYSYMBOL_YYEOF
Definition: f-exp.c:339
@ YYSYMBOL_ABOVE_COMMA
Definition: f-exp.c:385
@ YYSYMBOL_62_
Definition: f-exp.c:401
@ YYSYMBOL_DOLLAR_VARIABLE
Definition: f-exp.c:378
@ YYSYMBOL_nonempty_typelist
Definition: f-exp.c:428
@ YYSYMBOL_LOGICAL_S8_KEYWORD
Definition: f-exp.c:362
@ YYSYMBOL_variable
Definition: f-exp.c:421
@ YYSYMBOL_YYEMPTY
Definition: f-exp.c:338
@ YYSYMBOL_ptype
Definition: f-exp.c:423
@ YYSYMBOL_EQUAL
Definition: f-exp.c:391
@ YYSYMBOL_abs_decl
Definition: f-exp.c:424
@ YYSYMBOL_LOGICAL_S2_KEYWORD
Definition: f-exp.c:359
@ YYSYMBOL_69_
Definition: f-exp.c:408
@ YYSYMBOL_func_mod
Definition: f-exp.c:426
@ YYSYMBOL_77_2
Definition: f-exp.c:416
@ YYSYMBOL_GREATERTHAN
Definition: f-exp.c:394
@ YYSYMBOL_66_
Definition: f-exp.c:405
@ YYSYMBOL_FLOAT
Definition: f-exp.c:343
@ YYSYMBOL_NAME
Definition: f-exp.c:346
@ YYSYMBOL_LESSTHAN
Definition: f-exp.c:393
@ YYSYMBOL_45_
Definition: f-exp.c:384
@ YYSYMBOL_UNOP_OR_BINOP_OR_TERNOP_INTRINSIC
Definition: f-exp.c:383
@ YYSYMBOL_CHARACTER
Definition: f-exp.c:377
#define EQUAL
Definition: f-exp.c:280
#define REAL_S16_KEYWORD
Definition: f-exp.c:261
#define LOGICAL_S1_KEYWORD
Definition: f-exp.c:253
static void yy_symbol_print(FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep)
Definition: f-exp.c:1302
#define LOGICAL_KEYWORD
Definition: f-exp.c:255
#define YY_ASSERT(E)
Definition: f-exp.c:634
#define YY_(Msgid)
Definition: f-exp.c:568
static struct type_stack * type_stack
Definition: f-exp.c:105
#define RSH
Definition: f-exp.c:287
#define YYNOMEM
Definition: f-exp.c:1223
#define SIZEOF
Definition: f-exp.c:245
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: f-exp.c:615
static void wrap_binop_intrinsic(exp_opcode opcode)
Definition: f-exp.c:2749
static const yytype_int8 yydefact[]
Definition: f-exp.c:921
#define YYNSTATES
Definition: f-exp.c:774
#define YY_IGNORE_USELESS_CAST_END
Definition: f-exp.c:630
short yytype_int16
Definition: f-exp.c:479
#define KIND
Definition: f-exp.c:246
#define STRING_LITERAL
Definition: f-exp.c:239
#define INT_S8_KEYWORD
Definition: f-exp.c:252
void * xmalloc(YYSIZE_T)
static int tempbufsize
Definition: f-exp.c:3220
#define YYEOF
Definition: f-exp.c:234
static int tempbufindex
Definition: f-exp.c:3221
#define YYABORT
Definition: f-exp.c:1221
#define COMPLEX_S8_KEYWORD
Definition: f-exp.c:264
static const yytype_int16 yyrline[]
Definition: f-exp.c:827
#define COMPLEX_KEYWORD
Definition: f-exp.c:262
#define BOOL_OR
Definition: f-exp.c:267
#define YYSTACK_BYTES(N)
Definition: f-exp.c:718
static char * tempbuf
Definition: f-exp.c:3219
yytype_uint8 yy_state_t
Definition: f-exp.c:555
#define NAME
Definition: f-exp.c:241
#define YY_REDUCE_PRINT(Rule)
Definition: f-exp.c:1360
#define UNOP_OR_BINOP_OR_TERNOP_INTRINSIC
Definition: f-exp.c:278
#define COMPLETE
Definition: f-exp.c:243
#define GROWBY_MIN_SIZE
Definition: f-exp.c:3223
#define YY_CAST(Type, Val)
Definition: f-exp.c:142
static void yydestruct(const char *yymsg, yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
Definition: f-exp.c:1403
#define ABOVE_COMMA
Definition: f-exp.c:279
#define UNOP_INTRINSIC
Definition: f-exp.c:275
static struct parser_state * pstate
Definition: f-exp.c:99
static const yytype_int16 yypact[]
Definition: f-exp.c:895
YYSTYPE yylval
Definition: f-exp.c:1421
static const yytype_uint8 yydefgoto[]
Definition: f-exp.c:952
#define YYerror
Definition: f-exp.c:235
#define YYUNDEF
Definition: f-exp.c:236
static void wrap_unop_intrinsic(exp_opcode opcode)
Definition: f-exp.c:2702
static const struct token fortran_operators[]
Definition: f-exp.c:3129
#define YYFINAL
Definition: f-exp.c:763
#define LSH
Definition: f-exp.c:286
static int yylex(void)
Definition: f-exp.c:3301
#define YY_ACCESSING_SYMBOL(State)
Definition: f-exp.c:845
#define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
Definition: f-exp.c:1267
static void growbuf_by_size(int)
Definition: f-exp.c:3238
static int parse_number(struct parser_state *, const char *, int, int, YYSTYPE *)
Definition: f-exp.c:2878
#define YYNTOKENS
Definition: f-exp.c:768
#define STARSTAR
Definition: f-exp.c:288
#define YY_STACK_PRINT(Bottom, Top)
Definition: f-exp.c:1329
#define INT_S1_KEYWORD
Definition: f-exp.c:248
static void yy_symbol_value_print(FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep)
Definition: f-exp.c:1284
#define YYSIZE_T
Definition: f-exp.c:541
#define YY_IGNORE_USELESS_CAST_BEGIN
Definition: f-exp.c:629
#define parse_type(ps)
Definition: f-exp.c:88
static const struct f77_boolean_val boolean_values[]
Definition: f-exp.c:3164
int yyparse(void)
Definition: f-exp.c:1433
#define LOGICAL_S4_KEYWORD
Definition: f-exp.c:256
#define DOUBLE
Definition: f-exp.c:270
static const yytype_int8 yyr2[]
Definition: f-exp.c:1198
#define COMPLEX_S4_KEYWORD
Definition: f-exp.c:263
#define ERROR
Definition: f-exp.c:247
#define YYPTRDIFF_T
Definition: f-exp.c:527
static int paren_depth
Definition: f-exp.c:102
#define UNOP_OR_BINOP_INTRINSIC
Definition: f-exp.c:277
static void yy_reduce_print(yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
Definition: f-exp.c:1341
#define REAL_S4_KEYWORD
Definition: f-exp.c:259
#define NAME_OR_INT
Definition: f-exp.c:244
#define PRECISION
Definition: f-exp.c:271
int yychar
Definition: f-exp.c:1418
#define ASSIGN_MODIFY
Definition: f-exp.c:274
#define GEQ
Definition: f-exp.c:285
#define parse_f_type(ps)
Definition: f-exp.c:89
#define YY_NULLPTRPTR
Definition: f-exp.c:154
#define BOOLEAN_LITERAL
Definition: f-exp.c:240
static bool last_was_structop
Definition: f-exp.c:3296
#define YYACCEPT
Definition: f-exp.c:1220
#define yytable_value_is_error(Yyn)
Definition: f-exp.c:890
static bool saw_name_at_eof
Definition: f-exp.c:3292
int yytype_uint16
Definition: f-exp.c:513
#define YYTRANSLATE(YYX)
Definition: f-exp.c:782
static const yytype_int8 yystos[]
Definition: f-exp.c:1157
#define SINGLE
Definition: f-exp.c:269
#define UNARY
Definition: f-exp.c:289
int yydebug
Definition: f-exp.c:1368
#define YY_ATTRIBUTE_UNUSED
Definition: f-exp.c:585
static const char *const yytname[]
Definition: f-exp.c:854
#define INT_KEYWORD
Definition: f-exp.c:250
static const yytype_int8 yypgoto[]
Definition: f-exp.c:945
static void fortran_wrap3_kind(type *base_type)
Definition: f-exp.c:2856
static const yytype_int8 yyr1[]
Definition: f-exp.c:1181
#define LESSTHAN
Definition: f-exp.c:282
enum yytokentype yytoken_kind_t
Definition: f-exp.c:230
static struct type * convert_to_kind_type(struct type *basetype, int kind)
Definition: f-exp.c:3054
static void fortran_wrap2_kind(type *base_type)
Definition: f-exp.c:2836
#define LOGICAL_S8_KEYWORD
Definition: f-exp.c:257
static int match_string_literal(void)
Definition: f-exp.c:3260
#define YYPOPSTACK(N)
int yy_state_fast_t
Definition: f-exp.c:558
#define YYEMPTY
Definition: f-exp.c:233
#define YYLAST
Definition: f-exp.c:765
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: f-exp.c:729
#define FLOAT
Definition: f-exp.c:238
#define yypact_value_is_default(Yyn)
Definition: f-exp.c:885
static void push_kind_type(LONGEST val, struct type *type)
Definition: f-exp.c:3027
#define YYINITDEPTH
Definition: f-exp.c:1379
static const yytype_uint8 yytable[]
Definition: f-exp.c:961
#define REAL_KEYWORD
Definition: f-exp.c:258
signed char yytype_int8
Definition: f-exp.c:471
#define CHECKBUF(size)
Definition: f-exp.c:3225
#define YYERROR
Definition: f-exp.c:1222
static void yy_stack_print(yy_state_t *yybottom, yy_state_t *yytop)
Definition: f-exp.c:1318
#define YYSIZEOF(X)
Definition: f-exp.c:551
static const yytype_int16 yycheck[]
Definition: f-exp.c:1058
#define YYSTACK_ALLOC
Definition: f-exp.c:674
#define YYDPRINTF(Args)
Definition: f-exp.c:1258
void xfree(void *)
@ YYENOMEM
Definition: f-exp.c:1215
#define YY_USE(E)
Definition: f-exp.c:591
#define INT
Definition: f-exp.c:237
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1423
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1440
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:402
struct type * lookup_lvalue_reference_type(struct type *type)
Definition: gdbtypes.c:490
struct type * lookup_function_type(struct type *type)
Definition: gdbtypes.c:539
struct type * create_array_type(struct type *result_type, struct type *element_type, struct type *range_type)
Definition: gdbtypes.c:1422
struct type * create_static_range_type(struct type *result_type, struct type *index_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1025
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:3010
#define TYPE_SAFE_NAME(type)
Definition: gdbtypes.h:2228
void range_error(const char *string,...)
Definition: language.c:396
struct type * language_lookup_primitive_type(const struct language_defn *la, struct gdbarch *gdbarch, const char *name)
Definition: language.c:1053
#define RANGE_CHECK
Definition: language.h:751
Definition: ada-exp.h:80
std::unique_ptr< operation > operation_up
Definition: expression.h:81
std::array< gdb_byte, 16 > float_data
Definition: expop.h:547
bool parse_float(const char *p, int len, const struct type *type, gdb_byte *data)
Definition: parse.c:609
std::string copy_name(struct stoken token)
Definition: parse.c:407
bool parser_debug
Definition: parse.c:65
Definition: 1.cc:26
struct symbol * symbol
Definition: symtab.h:1494
void set_operation(expr::operation_up &&op)
Definition: parser-defs.h:75
const struct language_defn * language()
Definition: parser-defs.h:68
struct gdbarch * gdbarch()
Definition: parser-defs.h:61
expression_up expout
Definition: parser-defs.h:82
const char * name
Definition: f-exp.c:3157
int token
Definition: m2-exp.c:2440
void push_new(Arg... args)
Definition: parser-defs.h:214
int end_arglist()
Definition: parser-defs.h:179
void wrap2()
Definition: parser-defs.h:260
const struct block *const expression_context_block
Definition: parser-defs.h:270
std::vector< expr::operation_up > pop_vector(int n)
Definition: parser-defs.h:239
bool parse_completion
Definition: parser-defs.h:297
void push_dollar(struct stoken str)
Definition: parse.c:248
const char * prev_lexptr
Definition: parser-defs.h:290
void push_symbol(const char *name, block_symbol sym)
Definition: parse.c:225
void start_arglist()
Definition: parser-defs.h:170
expr::operation_up pop()
Definition: parser-defs.h:231
void push(expr::operation_up &&op)
Definition: parser-defs.h:207
const char * lexptr
Definition: parser-defs.h:286
int comma_terminates
Definition: parser-defs.h:281
void mark_struct_expression(expr::structop_base_operation *op)
Definition: parse.c:187
int length
Definition: parser-defs.h:370
const char * ptr
Definition: parser-defs.h:368
address_class aclass() const
Definition: symtab.h:1235
struct type * type() const
Definition: symtab.h:1285
int is_a_field_of_this
Definition: parser-defs.h:399
struct block_symbol sym
Definition: parser-defs.h:398
Definition: c-exp.c:5133
const char * oper
Definition: c-exp.c:5134
enum exp_opcode opcode
Definition: c-exp.c:5136
int token
Definition: c-exp.c:5135
bool case_sensitive
Definition: f-exp.c:3124
struct type * type
Definition: parser-defs.h:392
void push(enum type_pieces tp)
Definition: type-stack.h:83
enum type_pieces pop()
Definition: type-stack.h:119
int pop_int()
Definition: type-stack.h:128
Definition: gdbtypes.h:922
bool is_unsigned() const
Definition: gdbtypes.h:1063
Definition: value.c:181
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1967
@ LOC_TYPEDEF
Definition: symtab.h:989
domain_enum
Definition: symtab.h:871
@ VAR_DOMAIN
Definition: symtab.h:881
@ STRUCT_DOMAIN
Definition: symtab.h:887
@ MODULE_DOMAIN
Definition: symtab.h:891
@ tp_function
Definition: type-stack.h:38
@ tp_kind
Definition: type-stack.h:46
@ tp_array
Definition: type-stack.h:37
@ tp_pointer
Definition: type-stack.h:34
@ tp_reference
Definition: type-stack.h:35
@ tp_end
Definition: type-stack.h:33
struct ttype tsym
Definition: c-exp.c:370
struct YYSTYPE::@3 typed_val_float
int voidval
Definition: c-exp.c:372
struct stoken sval
Definition: ada-exp.c:624
struct internalvar * ivar
Definition: ada-exp.c:626
struct symtoken ssym
Definition: c-exp.c:371
int * ivec
Definition: f-exp.c:316
LONGEST val
Definition: ada-exp.c:616
struct type * tval
Definition: ada-exp.c:623
struct type ** tvec
Definition: f-exp.c:315
struct symbol * sym
Definition: d-exp.c:274
LONGEST lval
Definition: ada-exp.c:614
enum exp_opcode opcode
Definition: c-exp.c:374
struct YYSTYPE::@2 typed_val
struct type * type
Definition: ada-exp.c:617
YYSTYPE yyvs_alloc
Definition: ada-exp.c:1016
yy_state_t yyss_alloc
Definition: ada-exp.c:1015
LONGEST value_as_long(struct value *val)
Definition: value.c:2791
#define yylloc
Definition: yy-remap.h:68
#define yyss
Definition: yy-remap.h:82
#define yyval
Definition: yy-remap.h:67
#define yyrule
Definition: yy-remap.h:72
#define yylhs
Definition: yy-remap.h:73
#define yyvsp
Definition: yy-remap.h:87
#define yyparse
Definition: yy-remap.h:43
#define yylen
Definition: yy-remap.h:74
#define yyssp
Definition: yy-remap.h:84
#define yydebug
Definition: yy-remap.h:48
#define yystacksize
Definition: yy-remap.h:85
#define yyvs
Definition: yy-remap.h:86
#define yystate
Definition: yy-remap.h:63
#define YYFPRINTF
Definition: yy-remap.h:96
#define yyerror
Definition: yy-remap.h:45