1 /* YACC parser for Ada expressions, for GDB.
2 Copyright (C) 1986-2021 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 /* Parse an Ada expression from text in a string,
20 and return the result as a struct expression pointer.
21 That structure contains arithmetic operations in reverse polish,
22 with constants represented by operations that are followed by special data.
23 See expression.h for the details of the format.
24 What is important here is that it can be built up sequentially
25 during the process of parsing; the lower levels of the tree always
26 come first in the result.
28 malloc's and realloc's in this file are transformed to
29 xmalloc and xrealloc respectively by the same sed command in the
30 makefile that remaps any other malloc/realloc inserted by the parser
31 generator. Doing this with #defines and trying to control the interaction
32 with include files (<malloc.h> and <stdlib.h> for example) just became
33 too messy, particularly when such includes can be inserted at random
34 times by the parser generator. */
40 #include "expression.h"
42 #include "parser-defs.h"
45 #include "bfd.h" /* Required by objfiles.h. */
46 #include "symfile.h" /* Required by objfiles.h. */
47 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
52 #define parse_type(ps) builtin_type (ps->gdbarch ())
54 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
56 #define GDB_YY_REMAP_PREFIX ada_
61 struct minimal_symbol *msym;
62 const struct block *block;
66 /* The state of the parser, used internally when we are parsing the
69 static struct parser_state *pstate = NULL;
71 /* If expression is in the context of TYPE'(...), then TYPE, else
73 static struct type *type_qualifier;
77 static int yylex (void);
79 static void yyerror (const char *);
81 static void write_int (struct parser_state *, LONGEST, struct type *);
83 static void write_object_renaming (struct parser_state *,
84 const struct block *, const char *, int,
87 static struct type* write_var_or_type (struct parser_state *,
88 const struct block *, struct stoken);
90 static void write_name_assoc (struct parser_state *, struct stoken);
92 static const struct block *block_lookup (const struct block *, const char *);
94 static LONGEST convert_char_literal (struct type *, LONGEST);
96 static void write_ambiguous_var (struct parser_state *,
97 const struct block *, char *, int);
99 static struct type *type_int (struct parser_state *);
101 static struct type *type_long (struct parser_state *);
103 static struct type *type_long_long (struct parser_state *);
105 static struct type *type_long_double (struct parser_state *);
107 static struct type *type_char (struct parser_state *);
109 static struct type *type_boolean (struct parser_state *);
111 static struct type *type_system_address (struct parser_state *);
113 using namespace expr;
115 /* Handle Ada type resolution for OP. DEPROCEDURE_P and CONTEXT_TYPE
116 are passed to the resolve method, if called. */
118 resolve (operation_up &&op, bool deprocedure_p, struct type *context_type)
120 operation_up result = std::move (op);
121 ada_resolvable *res = dynamic_cast<ada_resolvable *> (result.get ());
123 && res->resolve (pstate->expout.get (),
125 pstate->parse_completion,
126 pstate->block_tracker,
129 = make_operation<ada_funcall_operation> (std::move (result),
130 std::vector<operation_up> ());
135 /* Like parser_state::pop, but handles Ada type resolution.
136 DEPROCEDURE_P and CONTEXT_TYPE are passed to the resolve method, if
139 ada_pop (bool deprocedure_p = true, struct type *context_type = nullptr)
141 /* Of course it's ok to call parser_state::pop here... */
142 return resolve (pstate->pop (), deprocedure_p, context_type);
145 /* Like parser_state::wrap, but use ada_pop to pop the value. */
150 operation_up arg = ada_pop ();
151 pstate->push_new<T> (std::move (arg));
154 /* Create and push an address-of operation, as appropriate for Ada.
155 If TYPE is not NULL, the resulting operation will be wrapped in a
158 ada_addrof (struct type *type = nullptr)
160 operation_up arg = ada_pop (false);
161 operation_up addr = make_operation<unop_addr_operation> (std::move (arg));
163 = make_operation<ada_wrapped_operation> (std::move (addr));
165 wrapped = make_operation<unop_cast_operation> (std::move (wrapped), type);
166 pstate->push (std::move (wrapped));
169 /* Handle operator overloading. Either returns a function all
170 operation wrapping the arguments, or it returns null, leaving the
171 caller to construct the appropriate operation. If RHS is null, a
172 unary operator is assumed. */
174 maybe_overload (enum exp_opcode op, operation_up &lhs, operation_up &rhs)
176 struct value *args[2];
179 args[0] = lhs->evaluate (nullptr, pstate->expout.get (),
180 EVAL_AVOID_SIDE_EFFECTS);
185 args[1] = rhs->evaluate (nullptr, pstate->expout.get (),
186 EVAL_AVOID_SIDE_EFFECTS);
190 block_symbol fn = ada_find_operator_symbol (op, pstate->parse_completion,
192 if (fn.symbol == nullptr)
195 if (symbol_read_needs_frame (fn.symbol))
196 pstate->block_tracker->update (fn.block, INNERMOST_BLOCK_FOR_SYMBOLS);
197 operation_up callee = make_operation<ada_var_value_operation> (fn);
199 std::vector<operation_up> argvec;
200 argvec.push_back (std::move (lhs));
202 argvec.push_back (std::move (rhs));
203 return make_operation<ada_funcall_operation> (std::move (callee),
207 /* Like parser_state::wrap, but use ada_pop to pop the value, and
208 handle unary overloading. */
211 ada_wrap_overload (enum exp_opcode op)
213 operation_up arg = ada_pop ();
216 operation_up call = maybe_overload (op, arg, empty);
218 call = make_operation<T> (std::move (arg));
219 pstate->push (std::move (call));
222 /* A variant of parser_state::wrap2 that uses ada_pop to pop both
223 operands, and then pushes a new Ada-wrapped operation of the
227 ada_un_wrap2 (enum exp_opcode op)
229 operation_up rhs = ada_pop ();
230 operation_up lhs = ada_pop ();
232 operation_up wrapped = maybe_overload (op, lhs, rhs);
233 if (wrapped == nullptr)
235 wrapped = make_operation<T> (std::move (lhs), std::move (rhs));
236 wrapped = make_operation<ada_wrapped_operation> (std::move (wrapped));
238 pstate->push (std::move (wrapped));
241 /* A variant of parser_state::wrap2 that uses ada_pop to pop both
242 operands. Unlike ada_un_wrap2, ada_wrapped_operation is not
246 ada_wrap2 (enum exp_opcode op)
248 operation_up rhs = ada_pop ();
249 operation_up lhs = ada_pop ();
250 operation_up call = maybe_overload (op, lhs, rhs);
252 call = make_operation<T> (std::move (lhs), std::move (rhs));
253 pstate->push (std::move (call));
256 /* A variant of parser_state::wrap2 that uses ada_pop to pop both
257 operands. OP is also passed to the constructor of the new binary
261 ada_wrap_op (enum exp_opcode op)
263 operation_up rhs = ada_pop ();
264 operation_up lhs = ada_pop ();
265 operation_up call = maybe_overload (op, lhs, rhs);
267 call = make_operation<T> (op, std::move (lhs), std::move (rhs));
268 pstate->push (std::move (call));
271 /* Pop three operands using ada_pop, then construct a new ternary
272 operation of type T and push it. */
277 operation_up rhs = ada_pop ();
278 operation_up mid = ada_pop ();
279 operation_up lhs = ada_pop ();
280 pstate->push_new<T> (std::move (lhs), std::move (mid), std::move (rhs));
283 /* Pop NARGS operands, then a callee operand, and use these to
284 construct and push a new Ada function call operation. */
286 ada_funcall (int nargs)
288 /* We use the ordinary pop here, because we're going to do
289 resolution in a separate step, in order to handle array
291 std::vector<operation_up> args = pstate->pop_vector (nargs);
292 /* Call parser_state::pop here, because we don't want to
293 function-convert the callee slot of a call we're already
295 operation_up callee = pstate->pop ();
297 ada_var_value_operation *vvo
298 = dynamic_cast<ada_var_value_operation *> (callee.get ());
300 struct type *callee_t = nullptr;
302 || SYMBOL_DOMAIN (vvo->get_symbol ()) != UNDEF_DOMAIN)
304 struct value *callee_v = callee->evaluate (nullptr,
305 pstate->expout.get (),
306 EVAL_AVOID_SIDE_EFFECTS);
307 callee_t = ada_check_typedef (value_type (callee_v));
308 array_arity = ada_array_arity (callee_t);
311 for (int i = 0; i < nargs; ++i)
313 struct type *subtype = nullptr;
315 subtype = ada_index_type (callee_t, i + 1, "array type");
316 args[i] = resolve (std::move (args[i]), true, subtype);
319 std::unique_ptr<ada_funcall_operation> funcall
320 (new ada_funcall_operation (std::move (callee), std::move (args)));
321 funcall->resolve (pstate->expout.get (), true, pstate->parse_completion,
322 pstate->block_tracker, nullptr);
323 pstate->push (std::move (funcall));
326 /* The components being constructed during this parse. */
327 static std::vector<ada_component_up> components;
329 /* Create a new ada_component_up of the indicated type and arguments,
330 and push it on the global 'components' vector. */
331 template<typename T, typename... Arg>
333 push_component (Arg... args)
335 components.emplace_back (new T (std::forward<Arg> (args)...));
338 /* Examine the final element of the 'components' vector, and return it
339 as a pointer to an ada_choices_component. The caller is
340 responsible for ensuring that the final element is in fact an
341 ada_choices_component. */
342 static ada_choices_component *
345 ada_component *last = components.back ().get ();
346 ada_choices_component *result = dynamic_cast<ada_choices_component *> (last);
347 gdb_assert (result != nullptr);
351 /* Pop the most recent component from the global stack, and return
353 static ada_component_up
356 ada_component_up result = std::move (components.back ());
357 components.pop_back ();
361 /* Pop the N most recent components from the global stack, and return
363 static std::vector<ada_component_up>
364 pop_components (int n)
366 std::vector<ada_component_up> result (n);
367 for (int i = 1; i <= n; ++i)
368 result[n - i] = pop_component ();
372 /* The associations being constructed during this parse. */
373 static std::vector<ada_association_up> associations;
375 /* Create a new ada_association_up of the indicated type and
376 arguments, and push it on the global 'associations' vector. */
377 template<typename T, typename... Arg>
379 push_association (Arg... args)
381 associations.emplace_back (new T (std::forward<Arg> (args)...));
384 /* Pop the most recent association from the global stack, and return
386 static ada_association_up
389 ada_association_up result = std::move (associations.back ());
390 associations.pop_back ();
394 /* Pop the N most recent associations from the global stack, and
395 return them in a vector. */
396 static std::vector<ada_association_up>
397 pop_associations (int n)
399 std::vector<ada_association_up> result (n);
400 for (int i = 1; i <= n; ++i)
401 result[n - i] = pop_association ();
420 const struct block *bval;
421 struct internalvar *ivar;
424 %type <lval> positional_list component_groups component_associations
425 %type <lval> aggregate_component_list
426 %type <tval> var_or_type type_prefix opt_type_prefix
428 %token <typed_val> INT NULL_PTR CHARLIT
429 %token <typed_val_float> FLOAT
430 %token TRUEKEYWORD FALSEKEYWORD
432 %token <sval> STRING NAME DOT_ID
434 %type <lval> arglist tick_arglist
436 %type <tval> save_qualifier
440 /* Special type cases, put in to allow the parser to distinguish different
442 %token <sval> DOLLAR_VARIABLE
445 %left _AND_ OR XOR THEN ELSE
446 %left '=' NOTEQUAL '<' '>' LEQ GEQ IN DOTDOT
450 %left '*' '/' MOD REM
451 %right STARSTAR ABS NOT
453 /* Artificial token to give NAME => ... and NAME | priority over reducing
454 NAME to <primary> and to give <primary>' priority over reducing <primary>
460 %right TICK_ACCESS TICK_ADDRESS TICK_FIRST TICK_LAST TICK_LENGTH
461 %right TICK_MAX TICK_MIN TICK_MODULUS
462 %right TICK_POS TICK_RANGE TICK_SIZE TICK_TAG TICK_VAL
463 /* The following are right-associative only so that reductions at this
464 precedence have lower precedence than '.' and '('. The syntax still
465 forces a.b.c, e.g., to be LEFT-associated. */
466 %right '.' '(' '[' DOT_ID DOT_ALL
476 /* Expressions, including the sequencing operator. */
479 { ada_wrap2<comma_operation> (BINOP_COMMA); }
480 | primary ASSIGN exp /* Extension for convenience */
482 operation_up rhs = pstate->pop ();
483 operation_up lhs = ada_pop ();
485 = lhs->evaluate (nullptr, pstate->expout.get (),
486 EVAL_AVOID_SIDE_EFFECTS);
487 rhs = resolve (std::move (rhs), true,
488 value_type (lhs_val));
489 pstate->push_new<ada_assign_operation>
490 (std::move (lhs), std::move (rhs));
494 /* Expressions, not including the sequencing operator. */
495 primary : primary DOT_ALL
496 { ada_wrap<ada_unop_ind_operation> (); }
499 primary : primary DOT_ID
501 operation_up arg = ada_pop ();
502 pstate->push_new<ada_structop_operation>
503 (std::move (arg), copy_name ($2));
507 primary : primary '(' arglist ')'
508 { ada_funcall ($3); }
509 | var_or_type '(' arglist ')'
514 error (_("Invalid conversion"));
515 operation_up arg = ada_pop ();
516 pstate->push_new<unop_cast_operation>
517 (std::move (arg), $1);
524 primary : var_or_type '\'' save_qualifier { type_qualifier = $1; }
528 error (_("Type required for qualification"));
529 operation_up arg = ada_pop (true,
531 pstate->push_new<ada_qual_operation>
532 (std::move (arg), $1);
537 save_qualifier : { $$ = type_qualifier; }
541 primary '(' simple_exp DOTDOT simple_exp ')'
542 { ada_wrap3<ada_ternop_slice_operation> (); }
543 | var_or_type '(' simple_exp DOTDOT simple_exp ')'
545 ada_wrap3<ada_ternop_slice_operation> ();
547 error (_("Cannot slice a type"));
551 primary : '(' exp1 ')' { }
554 /* The following rule causes a conflict with the type conversion
556 To get around it, we give '(' higher priority and add bridge rules for
557 var_or_type (exp, exp, ...)
558 var_or_type (exp .. exp)
559 We also have the action for var_or_type(exp) generate a function call
560 when the first symbol does not denote a type. */
562 primary : var_or_type %prec VAR
564 pstate->push_new<type_operation> ($1);
568 primary : DOLLAR_VARIABLE /* Various GDB extensions */
569 { pstate->push_dollar ($1); }
574 pstate->push_new<ada_aggregate_operation>
582 simple_exp : '-' simple_exp %prec UNARY
583 { ada_wrap_overload<ada_neg_operation> (UNOP_NEG); }
586 simple_exp : '+' simple_exp %prec UNARY
588 operation_up arg = ada_pop ();
591 /* If an overloaded operator was found, use
592 it. Otherwise, unary + has no effect and
593 the argument can be pushed instead. */
594 operation_up call = maybe_overload (UNOP_PLUS, arg,
597 arg = std::move (call);
598 pstate->push (std::move (arg));
602 simple_exp : NOT simple_exp %prec UNARY
604 ada_wrap_overload<unary_logical_not_operation>
609 simple_exp : ABS simple_exp %prec UNARY
610 { ada_wrap_overload<ada_abs_operation> (UNOP_ABS); }
613 arglist : { $$ = 0; }
622 | arglist ',' NAME ARROW exp
626 primary : '{' var_or_type '}' primary %prec '.'
630 error (_("Type required within braces in coercion"));
631 operation_up arg = ada_pop ();
632 pstate->push_new<unop_memval_operation>
633 (std::move (arg), $2);
637 /* Binary operators in order of decreasing precedence. */
639 simple_exp : simple_exp STARSTAR simple_exp
640 { ada_wrap2<ada_binop_exp_operation> (BINOP_EXP); }
643 simple_exp : simple_exp '*' simple_exp
644 { ada_wrap2<ada_binop_mul_operation> (BINOP_MUL); }
647 simple_exp : simple_exp '/' simple_exp
648 { ada_wrap2<ada_binop_div_operation> (BINOP_DIV); }
651 simple_exp : simple_exp REM simple_exp /* May need to be fixed to give correct Ada REM */
652 { ada_wrap2<ada_binop_rem_operation> (BINOP_REM); }
655 simple_exp : simple_exp MOD simple_exp
656 { ada_wrap2<ada_binop_mod_operation> (BINOP_MOD); }
659 simple_exp : simple_exp '@' simple_exp /* GDB extension */
660 { ada_wrap2<repeat_operation> (BINOP_REPEAT); }
663 simple_exp : simple_exp '+' simple_exp
664 { ada_wrap_op<ada_binop_addsub_operation> (BINOP_ADD); }
667 simple_exp : simple_exp '&' simple_exp
668 { ada_wrap2<concat_operation> (BINOP_CONCAT); }
671 simple_exp : simple_exp '-' simple_exp
672 { ada_wrap_op<ada_binop_addsub_operation> (BINOP_SUB); }
675 relation : simple_exp
678 relation : simple_exp '=' simple_exp
679 { ada_wrap_op<ada_binop_equal_operation> (BINOP_EQUAL); }
682 relation : simple_exp NOTEQUAL simple_exp
683 { ada_wrap_op<ada_binop_equal_operation> (BINOP_NOTEQUAL); }
686 relation : simple_exp LEQ simple_exp
687 { ada_un_wrap2<leq_operation> (BINOP_LEQ); }
690 relation : simple_exp IN simple_exp DOTDOT simple_exp
691 { ada_wrap3<ada_ternop_range_operation> (); }
692 | simple_exp IN primary TICK_RANGE tick_arglist
694 operation_up rhs = ada_pop ();
695 operation_up lhs = ada_pop ();
696 pstate->push_new<ada_binop_in_bounds_operation>
697 (std::move (lhs), std::move (rhs), $5);
699 | simple_exp IN var_or_type %prec TICK_ACCESS
702 error (_("Right operand of 'in' must be type"));
703 operation_up arg = ada_pop ();
704 pstate->push_new<ada_unop_range_operation>
705 (std::move (arg), $3);
707 | simple_exp NOT IN simple_exp DOTDOT simple_exp
708 { ada_wrap3<ada_ternop_range_operation> ();
709 ada_wrap<unary_logical_not_operation> (); }
710 | simple_exp NOT IN primary TICK_RANGE tick_arglist
712 operation_up rhs = ada_pop ();
713 operation_up lhs = ada_pop ();
714 pstate->push_new<ada_binop_in_bounds_operation>
715 (std::move (lhs), std::move (rhs), $6);
716 ada_wrap<unary_logical_not_operation> ();
718 | simple_exp NOT IN var_or_type %prec TICK_ACCESS
721 error (_("Right operand of 'in' must be type"));
722 operation_up arg = ada_pop ();
723 pstate->push_new<ada_unop_range_operation>
724 (std::move (arg), $4);
725 ada_wrap<unary_logical_not_operation> ();
729 relation : simple_exp GEQ simple_exp
730 { ada_un_wrap2<geq_operation> (BINOP_GEQ); }
733 relation : simple_exp '<' simple_exp
734 { ada_un_wrap2<less_operation> (BINOP_LESS); }
737 relation : simple_exp '>' simple_exp
738 { ada_un_wrap2<gtr_operation> (BINOP_GTR); }
750 relation _AND_ relation
751 { ada_wrap2<ada_bitwise_and_operation>
752 (BINOP_BITWISE_AND); }
753 | and_exp _AND_ relation
754 { ada_wrap2<ada_bitwise_and_operation>
755 (BINOP_BITWISE_AND); }
759 relation _AND_ THEN relation
760 { ada_wrap2<logical_and_operation>
761 (BINOP_LOGICAL_AND); }
762 | and_then_exp _AND_ THEN relation
763 { ada_wrap2<logical_and_operation>
764 (BINOP_LOGICAL_AND); }
769 { ada_wrap2<ada_bitwise_ior_operation>
770 (BINOP_BITWISE_IOR); }
772 { ada_wrap2<ada_bitwise_ior_operation>
773 (BINOP_BITWISE_IOR); }
777 relation OR ELSE relation
778 { ada_wrap2<logical_or_operation> (BINOP_LOGICAL_OR); }
779 | or_else_exp OR ELSE relation
780 { ada_wrap2<logical_or_operation> (BINOP_LOGICAL_OR); }
783 xor_exp : relation XOR relation
784 { ada_wrap2<ada_bitwise_xor_operation>
785 (BINOP_BITWISE_XOR); }
786 | xor_exp XOR relation
787 { ada_wrap2<ada_bitwise_xor_operation>
788 (BINOP_BITWISE_XOR); }
791 /* Primaries can denote types (OP_TYPE). In cases such as
792 primary TICK_ADDRESS, where a type would be invalid, it will be
793 caught when evaluate_subexp in ada-lang.c tries to evaluate the
794 primary, expecting a value. Precedence rules resolve the ambiguity
795 in NAME TICK_ACCESS in favor of shifting to form a var_or_type. A
796 construct such as aType'access'access will again cause an error when
797 aType'access evaluates to a type that evaluate_subexp attempts to
799 primary : primary TICK_ACCESS
801 | primary TICK_ADDRESS
802 { ada_addrof (type_system_address (pstate)); }
803 | primary TICK_FIRST tick_arglist
805 operation_up arg = ada_pop ();
806 pstate->push_new<ada_unop_atr_operation>
807 (std::move (arg), OP_ATR_FIRST, $3);
809 | primary TICK_LAST tick_arglist
811 operation_up arg = ada_pop ();
812 pstate->push_new<ada_unop_atr_operation>
813 (std::move (arg), OP_ATR_LAST, $3);
815 | primary TICK_LENGTH tick_arglist
817 operation_up arg = ada_pop ();
818 pstate->push_new<ada_unop_atr_operation>
819 (std::move (arg), OP_ATR_LENGTH, $3);
822 { ada_wrap<ada_atr_size_operation> (); }
824 { ada_wrap<ada_atr_tag_operation> (); }
825 | opt_type_prefix TICK_MIN '(' exp ',' exp ')'
826 { ada_wrap2<ada_binop_min_operation> (BINOP_MIN); }
827 | opt_type_prefix TICK_MAX '(' exp ',' exp ')'
828 { ada_wrap2<ada_binop_max_operation> (BINOP_MAX); }
829 | opt_type_prefix TICK_POS '(' exp ')'
830 { ada_wrap<ada_pos_operation> (); }
831 | type_prefix TICK_VAL '(' exp ')'
833 operation_up arg = ada_pop ();
834 pstate->push_new<ada_atr_val_operation>
835 ($1, std::move (arg));
837 | type_prefix TICK_MODULUS
839 struct type *type_arg = check_typedef ($1);
840 if (!ada_is_modular_type (type_arg))
841 error (_("'modulus must be applied to modular type"));
842 write_int (pstate, ada_modulus (type_arg),
843 TYPE_TARGET_TYPE (type_arg));
847 tick_arglist : %prec '('
857 error (_("Prefix must be type"));
866 { $$ = parse_type (pstate)->builtin_void; }
871 { write_int (pstate, (LONGEST) $1.val, $1.type); }
876 convert_char_literal (type_qualifier, $1.val),
877 (type_qualifier == NULL)
878 ? $1.type : type_qualifier);
885 std::copy (std::begin ($1.val), std::end ($1.val),
887 pstate->push_new<float_const_operation>
889 ada_wrap<ada_wrapped_operation> ();
895 struct type *null_ptr_type
896 = lookup_pointer_type (parse_type (pstate)->builtin_int0);
897 write_int (pstate, 0, null_ptr_type);
903 pstate->push_new<ada_string_operation>
908 primary : TRUEKEYWORD
909 { write_int (pstate, 1, type_boolean (pstate)); }
911 { write_int (pstate, 0, type_boolean (pstate)); }
915 { error (_("NEW not implemented.")); }
918 var_or_type: NAME %prec VAR
919 { $$ = write_var_or_type (pstate, NULL, $1); }
920 | block NAME %prec VAR
921 { $$ = write_var_or_type (pstate, $1, $2); }
924 $$ = write_var_or_type (pstate, NULL, $1);
928 $$ = lookup_pointer_type ($$);
930 | block NAME TICK_ACCESS
932 $$ = write_var_or_type (pstate, $1, $2);
936 $$ = lookup_pointer_type ($$);
941 block : NAME COLONCOLON
942 { $$ = block_lookup (NULL, $1.ptr); }
943 | block NAME COLONCOLON
944 { $$ = block_lookup ($1, $2.ptr); }
948 '(' aggregate_component_list ')'
950 std::vector<ada_component_up> components
951 = pop_components ($2);
953 push_component<ada_aggregate_component>
954 (std::move (components));
958 aggregate_component_list :
959 component_groups { $$ = $1; }
960 | positional_list exp
962 push_component<ada_positional_component>
966 | positional_list component_groups
973 push_component<ada_positional_component>
977 | positional_list exp ','
979 push_component<ada_positional_component>
987 | component_group { $$ = 1; }
988 | component_group ',' component_groups
992 others : OTHERS ARROW exp
994 push_component<ada_others_component> (ada_pop ());
999 component_associations
1001 ada_choices_component *choices = choice_component ();
1002 choices->set_associations (pop_associations ($1));
1006 /* We use this somewhat obscure definition in order to handle NAME => and
1007 NAME | differently from exp => and exp |. ARROW and '|' have a precedence
1008 above that of the reduction of NAME to var_or_type. By delaying
1009 decisions until after the => or '|', we convert the ambiguity to a
1010 resolved shift/reduce conflict. */
1011 component_associations :
1014 push_component<ada_choices_component> (ada_pop ());
1015 write_name_assoc (pstate, $1);
1018 | simple_exp ARROW exp
1020 push_component<ada_choices_component> (ada_pop ());
1021 push_association<ada_name_association> (ada_pop ());
1024 | simple_exp DOTDOT simple_exp ARROW exp
1026 push_component<ada_choices_component> (ada_pop ());
1027 operation_up rhs = ada_pop ();
1028 operation_up lhs = ada_pop ();
1029 push_association<ada_discrete_range_association>
1030 (std::move (lhs), std::move (rhs));
1033 | NAME '|' component_associations
1035 write_name_assoc (pstate, $1);
1038 | simple_exp '|' component_associations
1040 push_association<ada_name_association> (ada_pop ());
1043 | simple_exp DOTDOT simple_exp '|' component_associations
1046 operation_up rhs = ada_pop ();
1047 operation_up lhs = ada_pop ();
1048 push_association<ada_discrete_range_association>
1049 (std::move (lhs), std::move (rhs));
1054 /* Some extensions borrowed from C, for the benefit of those who find they
1055 can't get used to Ada notation in GDB. */
1057 primary : '*' primary %prec '.'
1058 { ada_wrap<ada_unop_ind_operation> (); }
1059 | '&' primary %prec '.'
1061 | primary '[' exp ']'
1063 ada_wrap2<subscript_operation> (BINOP_SUBSCRIPT);
1064 ada_wrap<ada_wrapped_operation> ();
1070 /* yylex defined in ada-lex.c: Reads one token, getting characters */
1071 /* through lexptr. */
1073 /* Remap normal flex interface names (yylex) as well as gratuitiously */
1074 /* global symbol names, so we can have multiple flex-generated parsers */
1077 /* (See note above on previous definitions for YACC.) */
1079 #define yy_create_buffer ada_yy_create_buffer
1080 #define yy_delete_buffer ada_yy_delete_buffer
1081 #define yy_init_buffer ada_yy_init_buffer
1082 #define yy_load_buffer_state ada_yy_load_buffer_state
1083 #define yy_switch_to_buffer ada_yy_switch_to_buffer
1084 #define yyrestart ada_yyrestart
1085 #define yytext ada_yytext
1087 static struct obstack temp_parse_space;
1089 /* The following kludge was found necessary to prevent conflicts between */
1090 /* defs.h and non-standard stdlib.h files. */
1091 #define qsort __qsort__dummy
1092 #include "ada-lex.c"
1095 ada_parse (struct parser_state *par_state)
1097 /* Setting up the parser state. */
1098 scoped_restore pstate_restore = make_scoped_restore (&pstate);
1099 gdb_assert (par_state != NULL);
1102 lexer_init (yyin); /* (Re-)initialize lexer. */
1103 type_qualifier = NULL;
1104 obstack_free (&temp_parse_space, NULL);
1105 obstack_init (&temp_parse_space);
1106 components.clear ();
1107 associations.clear ();
1109 int result = yyparse ();
1112 struct type *context_type = nullptr;
1113 if (par_state->void_context_p)
1114 context_type = parse_type (par_state)->builtin_void;
1115 pstate->set_operation (ada_pop (true, context_type));
1121 yyerror (const char *msg)
1123 error (_("Error in expression, near `%s'."), pstate->lexptr);
1126 /* Emit expression to access an instance of SYM, in block BLOCK (if
1130 write_var_from_sym (struct parser_state *par_state, block_symbol sym)
1132 if (symbol_read_needs_frame (sym.symbol))
1133 par_state->block_tracker->update (sym.block, INNERMOST_BLOCK_FOR_SYMBOLS);
1135 par_state->push_new<ada_var_value_operation> (sym);
1138 /* Write integer or boolean constant ARG of type TYPE. */
1141 write_int (struct parser_state *par_state, LONGEST arg, struct type *type)
1143 pstate->push_new<long_const_operation> (type, arg);
1144 ada_wrap<ada_wrapped_operation> ();
1147 /* Emit expression corresponding to the renamed object named
1148 * designated by RENAMED_ENTITY[0 .. RENAMED_ENTITY_LEN-1] in the
1149 * context of ORIG_LEFT_CONTEXT, to which is applied the operations
1150 * encoded by RENAMING_EXPR. MAX_DEPTH is the maximum number of
1151 * cascaded renamings to allow. If ORIG_LEFT_CONTEXT is null, it
1152 * defaults to the currently selected block. ORIG_SYMBOL is the
1153 * symbol that originally encoded the renaming. It is needed only
1154 * because its prefix also qualifies any index variables used to index
1155 * or slice an array. It should not be necessary once we go to the
1156 * new encoding entirely (FIXME pnh 7/20/2007). */
1159 write_object_renaming (struct parser_state *par_state,
1160 const struct block *orig_left_context,
1161 const char *renamed_entity, int renamed_entity_len,
1162 const char *renaming_expr, int max_depth)
1165 enum { SIMPLE_INDEX, LOWER_BOUND, UPPER_BOUND } slice_state;
1166 struct block_symbol sym_info;
1169 error (_("Could not find renamed symbol"));
1171 if (orig_left_context == NULL)
1172 orig_left_context = get_selected_block (NULL);
1174 name = obstack_strndup (&temp_parse_space, renamed_entity,
1175 renamed_entity_len);
1176 ada_lookup_encoded_symbol (name, orig_left_context, VAR_DOMAIN, &sym_info);
1177 if (sym_info.symbol == NULL)
1178 error (_("Could not find renamed variable: %s"), ada_decode (name).c_str ());
1179 else if (SYMBOL_CLASS (sym_info.symbol) == LOC_TYPEDEF)
1180 /* We have a renaming of an old-style renaming symbol. Don't
1181 trust the block information. */
1182 sym_info.block = orig_left_context;
1185 const char *inner_renamed_entity;
1186 int inner_renamed_entity_len;
1187 const char *inner_renaming_expr;
1189 switch (ada_parse_renaming (sym_info.symbol, &inner_renamed_entity,
1190 &inner_renamed_entity_len,
1191 &inner_renaming_expr))
1193 case ADA_NOT_RENAMING:
1194 write_var_from_sym (par_state, sym_info);
1196 case ADA_OBJECT_RENAMING:
1197 write_object_renaming (par_state, sym_info.block,
1198 inner_renamed_entity, inner_renamed_entity_len,
1199 inner_renaming_expr, max_depth - 1);
1206 slice_state = SIMPLE_INDEX;
1207 while (*renaming_expr == 'X')
1211 switch (*renaming_expr) {
1214 ada_wrap<ada_unop_ind_operation> ();
1217 slice_state = LOWER_BOUND;
1221 if (isdigit (*renaming_expr))
1224 long val = strtol (renaming_expr, &next, 10);
1225 if (next == renaming_expr)
1227 renaming_expr = next;
1228 write_int (par_state, val, type_int (par_state));
1234 struct block_symbol index_sym_info;
1236 end = strchr (renaming_expr, 'X');
1238 end = renaming_expr + strlen (renaming_expr);
1240 index_name = obstack_strndup (&temp_parse_space, renaming_expr,
1241 end - renaming_expr);
1242 renaming_expr = end;
1244 ada_lookup_encoded_symbol (index_name, orig_left_context,
1245 VAR_DOMAIN, &index_sym_info);
1246 if (index_sym_info.symbol == NULL)
1247 error (_("Could not find %s"), index_name);
1248 else if (SYMBOL_CLASS (index_sym_info.symbol) == LOC_TYPEDEF)
1249 /* Index is an old-style renaming symbol. */
1250 index_sym_info.block = orig_left_context;
1251 write_var_from_sym (par_state, index_sym_info);
1253 if (slice_state == SIMPLE_INDEX)
1255 else if (slice_state == LOWER_BOUND)
1256 slice_state = UPPER_BOUND;
1257 else if (slice_state == UPPER_BOUND)
1259 ada_wrap3<ada_ternop_slice_operation> ();
1260 slice_state = SIMPLE_INDEX;
1270 if (slice_state != SIMPLE_INDEX)
1272 end = strchr (renaming_expr, 'X');
1274 end = renaming_expr + strlen (renaming_expr);
1276 operation_up arg = ada_pop ();
1277 pstate->push_new<ada_structop_operation>
1278 (std::move (arg), std::string (renaming_expr,
1279 end - renaming_expr));
1280 renaming_expr = end;
1288 if (slice_state == SIMPLE_INDEX)
1292 error (_("Internal error in encoding of renaming declaration"));
1295 static const struct block*
1296 block_lookup (const struct block *context, const char *raw_name)
1299 struct symtab *symtab;
1300 const struct block *result = NULL;
1302 std::string name_storage;
1303 if (raw_name[0] == '\'')
1310 name_storage = ada_encode (raw_name);
1311 name = name_storage.c_str ();
1314 std::vector<struct block_symbol> syms
1315 = ada_lookup_symbol_list (name, context, VAR_DOMAIN);
1318 && (syms.empty () || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK))
1319 symtab = lookup_symtab (name);
1324 result = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), STATIC_BLOCK);
1325 else if (syms.empty () || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK)
1327 if (context == NULL)
1328 error (_("No file or function \"%s\"."), raw_name);
1330 error (_("No function \"%s\" in specified context."), raw_name);
1334 if (syms.size () > 1)
1335 warning (_("Function name \"%s\" ambiguous here"), raw_name);
1336 result = SYMBOL_BLOCK_VALUE (syms[0].symbol);
1342 static struct symbol*
1343 select_possible_type_sym (const std::vector<struct block_symbol> &syms)
1346 int preferred_index;
1347 struct type *preferred_type;
1349 preferred_index = -1; preferred_type = NULL;
1350 for (i = 0; i < syms.size (); i += 1)
1351 switch (SYMBOL_CLASS (syms[i].symbol))
1354 if (ada_prefer_type (SYMBOL_TYPE (syms[i].symbol), preferred_type))
1356 preferred_index = i;
1357 preferred_type = SYMBOL_TYPE (syms[i].symbol);
1363 case LOC_REGPARM_ADDR:
1370 if (preferred_type == NULL)
1372 return syms[preferred_index].symbol;
1376 find_primitive_type (struct parser_state *par_state, const char *name)
1379 type = language_lookup_primitive_type (par_state->language (),
1380 par_state->gdbarch (),
1382 if (type == NULL && strcmp ("system__address", name) == 0)
1383 type = type_system_address (par_state);
1387 /* Check to see if we have a regular definition of this
1388 type that just didn't happen to have been read yet. */
1390 char *expanded_name =
1391 (char *) alloca (strlen (name) + sizeof ("standard__"));
1392 strcpy (expanded_name, "standard__");
1393 strcat (expanded_name, name);
1394 sym = ada_lookup_symbol (expanded_name, NULL, VAR_DOMAIN).symbol;
1395 if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1396 type = SYMBOL_TYPE (sym);
1403 chop_selector (char *name, int end)
1406 for (i = end - 1; i > 0; i -= 1)
1407 if (name[i] == '.' || (name[i] == '_' && name[i+1] == '_'))
1412 /* If NAME is a string beginning with a separator (either '__', or
1413 '.'), chop this separator and return the result; else, return
1417 chop_separator (char *name)
1422 if (name[0] == '_' && name[1] == '_')
1428 /* Given that SELS is a string of the form (<sep><identifier>)*, where
1429 <sep> is '__' or '.', write the indicated sequence of
1430 STRUCTOP_STRUCT expression operators. */
1432 write_selectors (struct parser_state *par_state, char *sels)
1434 while (*sels != '\0')
1436 char *p = chop_separator (sels);
1438 while (*sels != '\0' && *sels != '.'
1439 && (sels[0] != '_' || sels[1] != '_'))
1441 operation_up arg = ada_pop ();
1442 pstate->push_new<ada_structop_operation>
1443 (std::move (arg), std::string (p, sels - p));
1447 /* Write a variable access (OP_VAR_VALUE) to ambiguous encoded name
1448 NAME[0..LEN-1], in block context BLOCK, to be resolved later. Writes
1449 a temporary symbol that is valid until the next call to ada_parse.
1452 write_ambiguous_var (struct parser_state *par_state,
1453 const struct block *block, char *name, int len)
1455 struct symbol *sym = new (&temp_parse_space) symbol ();
1457 SYMBOL_DOMAIN (sym) = UNDEF_DOMAIN;
1458 sym->set_linkage_name (obstack_strndup (&temp_parse_space, name, len));
1459 sym->set_language (language_ada, nullptr);
1461 block_symbol bsym { sym, block };
1462 par_state->push_new<ada_var_value_operation> (bsym);
1465 /* A convenient wrapper around ada_get_field_index that takes
1466 a non NUL-terminated FIELD_NAME0 and a FIELD_NAME_LEN instead
1467 of a NUL-terminated field name. */
1470 ada_nget_field_index (const struct type *type, const char *field_name0,
1471 int field_name_len, int maybe_missing)
1473 char *field_name = (char *) alloca ((field_name_len + 1) * sizeof (char));
1475 strncpy (field_name, field_name0, field_name_len);
1476 field_name[field_name_len] = '\0';
1477 return ada_get_field_index (type, field_name, maybe_missing);
1480 /* If encoded_field_name is the name of a field inside symbol SYM,
1481 then return the type of that field. Otherwise, return NULL.
1483 This function is actually recursive, so if ENCODED_FIELD_NAME
1484 doesn't match one of the fields of our symbol, then try to see
1485 if ENCODED_FIELD_NAME could not be a succession of field names
1486 (in other words, the user entered an expression of the form
1487 TYPE_NAME.FIELD1.FIELD2.FIELD3), in which case we evaluate
1488 each field name sequentially to obtain the desired field type.
1489 In case of failure, we return NULL. */
1491 static struct type *
1492 get_symbol_field_type (struct symbol *sym, char *encoded_field_name)
1494 char *field_name = encoded_field_name;
1495 char *subfield_name;
1496 struct type *type = SYMBOL_TYPE (sym);
1499 if (type == NULL || field_name == NULL)
1501 type = check_typedef (type);
1503 while (field_name[0] != '\0')
1505 field_name = chop_separator (field_name);
1507 fieldno = ada_get_field_index (type, field_name, 1);
1509 return type->field (fieldno).type ();
1511 subfield_name = field_name;
1512 while (*subfield_name != '\0' && *subfield_name != '.'
1513 && (subfield_name[0] != '_' || subfield_name[1] != '_'))
1516 if (subfield_name[0] == '\0')
1519 fieldno = ada_nget_field_index (type, field_name,
1520 subfield_name - field_name, 1);
1524 type = type->field (fieldno).type ();
1525 field_name = subfield_name;
1531 /* Look up NAME0 (an unencoded identifier or dotted name) in BLOCK (or
1532 expression_block_context if NULL). If it denotes a type, return
1533 that type. Otherwise, write expression code to evaluate it as an
1534 object and return NULL. In this second case, NAME0 will, in general,
1535 have the form <name>(.<selector_name>)*, where <name> is an object
1536 or renaming encoded in the debugging data. Calls error if no
1537 prefix <name> matches a name in the debugging data (i.e., matches
1538 either a complete name or, as a wild-card match, the final
1542 write_var_or_type (struct parser_state *par_state,
1543 const struct block *block, struct stoken name0)
1550 block = par_state->expression_context_block;
1552 std::string name_storage = ada_encode (name0.ptr);
1553 name_len = name_storage.size ();
1554 encoded_name = obstack_strndup (&temp_parse_space, name_storage.c_str (),
1556 for (depth = 0; depth < MAX_RENAMING_CHAIN_LENGTH; depth += 1)
1560 tail_index = name_len;
1561 while (tail_index > 0)
1563 struct symbol *type_sym;
1564 struct symbol *renaming_sym;
1565 const char* renaming;
1567 const char* renaming_expr;
1568 int terminator = encoded_name[tail_index];
1570 encoded_name[tail_index] = '\0';
1571 std::vector<struct block_symbol> syms
1572 = ada_lookup_symbol_list (encoded_name, block, VAR_DOMAIN);
1573 encoded_name[tail_index] = terminator;
1575 type_sym = select_possible_type_sym (syms);
1577 if (type_sym != NULL)
1578 renaming_sym = type_sym;
1579 else if (syms.size () == 1)
1580 renaming_sym = syms[0].symbol;
1582 renaming_sym = NULL;
1584 switch (ada_parse_renaming (renaming_sym, &renaming,
1585 &renaming_len, &renaming_expr))
1587 case ADA_NOT_RENAMING:
1589 case ADA_PACKAGE_RENAMING:
1590 case ADA_EXCEPTION_RENAMING:
1591 case ADA_SUBPROGRAM_RENAMING:
1593 int alloc_len = renaming_len + name_len - tail_index + 1;
1595 = (char *) obstack_alloc (&temp_parse_space, alloc_len);
1596 strncpy (new_name, renaming, renaming_len);
1597 strcpy (new_name + renaming_len, encoded_name + tail_index);
1598 encoded_name = new_name;
1599 name_len = renaming_len + name_len - tail_index;
1600 goto TryAfterRenaming;
1602 case ADA_OBJECT_RENAMING:
1603 write_object_renaming (par_state, block, renaming, renaming_len,
1604 renaming_expr, MAX_RENAMING_CHAIN_LENGTH);
1605 write_selectors (par_state, encoded_name + tail_index);
1608 internal_error (__FILE__, __LINE__,
1609 _("impossible value from ada_parse_renaming"));
1612 if (type_sym != NULL)
1614 struct type *field_type;
1616 if (tail_index == name_len)
1617 return SYMBOL_TYPE (type_sym);
1619 /* We have some extraneous characters after the type name.
1620 If this is an expression "TYPE_NAME.FIELD0.[...].FIELDN",
1621 then try to get the type of FIELDN. */
1623 = get_symbol_field_type (type_sym, encoded_name + tail_index);
1624 if (field_type != NULL)
1627 error (_("Invalid attempt to select from type: \"%s\"."),
1630 else if (tail_index == name_len && syms.empty ())
1632 struct type *type = find_primitive_type (par_state,
1639 if (syms.size () == 1)
1641 write_var_from_sym (par_state, syms[0]);
1642 write_selectors (par_state, encoded_name + tail_index);
1645 else if (syms.empty ())
1647 struct bound_minimal_symbol msym
1648 = ada_lookup_simple_minsym (encoded_name);
1649 if (msym.minsym != NULL)
1651 par_state->push_new<ada_var_msym_value_operation> (msym);
1652 /* Maybe cause error here rather than later? FIXME? */
1653 write_selectors (par_state, encoded_name + tail_index);
1657 if (tail_index == name_len
1658 && strncmp (encoded_name, "standard__",
1659 sizeof ("standard__") - 1) == 0)
1660 error (_("No definition of \"%s\" found."), name0.ptr);
1662 tail_index = chop_selector (encoded_name, tail_index);
1666 write_ambiguous_var (par_state, block, encoded_name,
1668 write_selectors (par_state, encoded_name + tail_index);
1673 if (!have_full_symbols () && !have_partial_symbols () && block == NULL)
1674 error (_("No symbol table is loaded. Use the \"file\" command."));
1675 if (block == par_state->expression_context_block)
1676 error (_("No definition of \"%s\" in current context."), name0.ptr);
1678 error (_("No definition of \"%s\" in specified context."), name0.ptr);
1683 error (_("Could not find renamed symbol \"%s\""), name0.ptr);
1687 /* Write a left side of a component association (e.g., NAME in NAME =>
1688 exp). If NAME has the form of a selected component, write it as an
1689 ordinary expression. If it is a simple variable that unambiguously
1690 corresponds to exactly one symbol that does not denote a type or an
1691 object renaming, also write it normally as an OP_VAR_VALUE.
1692 Otherwise, write it as an OP_NAME.
1694 Unfortunately, we don't know at this point whether NAME is supposed
1695 to denote a record component name or the value of an array index.
1696 Therefore, it is not appropriate to disambiguate an ambiguous name
1697 as we normally would, nor to replace a renaming with its referent.
1698 As a result, in the (one hopes) rare case that one writes an
1699 aggregate such as (R => 42) where R renames an object or is an
1700 ambiguous name, one must write instead ((R) => 42). */
1703 write_name_assoc (struct parser_state *par_state, struct stoken name)
1705 if (strchr (name.ptr, '.') == NULL)
1707 std::vector<struct block_symbol> syms
1708 = ada_lookup_symbol_list (name.ptr,
1709 par_state->expression_context_block,
1712 if (syms.size () != 1 || SYMBOL_CLASS (syms[0].symbol) == LOC_TYPEDEF)
1713 pstate->push_new<ada_string_operation> (copy_name (name));
1715 write_var_from_sym (par_state, syms[0]);
1718 if (write_var_or_type (par_state, NULL, name) != NULL)
1719 error (_("Invalid use of type."));
1721 push_association<ada_name_association> (ada_pop ());
1724 /* Convert the character literal whose ASCII value would be VAL to the
1725 appropriate value of type TYPE, if there is a translation.
1726 Otherwise return VAL. Hence, in an enumeration type ('A', 'B'),
1727 the literal 'A' (VAL == 65), returns 0. */
1730 convert_char_literal (struct type *type, LONGEST val)
1737 type = check_typedef (type);
1738 if (type->code () != TYPE_CODE_ENUM)
1741 if ((val >= 'a' && val <= 'z') || (val >= '0' && val <= '9'))
1742 xsnprintf (name, sizeof (name), "Q%c", (int) val);
1744 xsnprintf (name, sizeof (name), "QU%02x", (int) val);
1745 size_t len = strlen (name);
1746 for (f = 0; f < type->num_fields (); f += 1)
1748 /* Check the suffix because an enum constant in a package will
1749 have a name like "pkg__QUxx". This is safe enough because we
1750 already have the correct type, and because mangling means
1751 there can't be clashes. */
1752 const char *ename = TYPE_FIELD_NAME (type, f);
1753 size_t elen = strlen (ename);
1755 if (elen >= len && strcmp (name, ename + elen - len) == 0)
1756 return TYPE_FIELD_ENUMVAL (type, f);
1761 static struct type *
1762 type_int (struct parser_state *par_state)
1764 return parse_type (par_state)->builtin_int;
1767 static struct type *
1768 type_long (struct parser_state *par_state)
1770 return parse_type (par_state)->builtin_long;
1773 static struct type *
1774 type_long_long (struct parser_state *par_state)
1776 return parse_type (par_state)->builtin_long_long;
1779 static struct type *
1780 type_long_double (struct parser_state *par_state)
1782 return parse_type (par_state)->builtin_long_double;
1785 static struct type *
1786 type_char (struct parser_state *par_state)
1788 return language_string_char_type (par_state->language (),
1789 par_state->gdbarch ());
1792 static struct type *
1793 type_boolean (struct parser_state *par_state)
1795 return parse_type (par_state)->builtin_bool;
1798 static struct type *
1799 type_system_address (struct parser_state *par_state)
1802 = language_lookup_primitive_type (par_state->language (),
1803 par_state->gdbarch (),
1805 return type != NULL ? type : parse_type (par_state)->builtin_data_ptr;
1808 void _initialize_ada_exp ();
1810 _initialize_ada_exp ()
1812 obstack_init (&temp_parse_space);