X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fada-lang.c;h=c425c80d41f3fe0ebdc3e23def656683c5ea7a4e;hb=9a044a8903fdfe53411787984379191d15373019;hp=2142b16420605e41645fd665a5bf243e3c55912f;hpb=89eef114606ca0510db54cec2fc60946a91990e8;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 2142b16420..c425c80d41 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -214,7 +214,7 @@ static struct value *ada_coerce_ref (struct value *); static LONGEST pos_atr (struct value *); -static struct value *value_pos_atr (struct value *); +static struct value *value_pos_atr (struct type *, struct value *); static struct value *value_val_atr (struct type *, struct value *); @@ -1759,7 +1759,7 @@ struct type * ada_coerce_to_simple_array_type (struct type *type) { struct value *mark = value_mark (); - struct value *dummy = value_from_longest (builtin_type_long, 0); + struct value *dummy = value_from_longest (builtin_type_int32, 0); struct type *result; deprecated_set_value_type (dummy, type); result = ada_type_of_array (dummy, 0); @@ -1959,7 +1959,7 @@ value_subscript_packed (struct value *arr, int arity, struct value **ind) lowerbound = upperbound = 0; } - idx = value_as_long (value_pos_atr (ind[i])); + idx = pos_atr (ind[i]); if (idx < lowerbound || idx > upperbound) lim_warning (_("packed array index %ld out of bounds"), (long) idx); bits = TYPE_FIELD_BITSIZE (elt_type, 0); @@ -2335,7 +2335,7 @@ ada_value_subscript (struct value *arr, int arity, struct value **ind) { if (TYPE_CODE (elt_type) != TYPE_CODE_ARRAY) error (_("too many subscripts (%d expected)"), k); - elt = value_subscript (elt, value_pos_atr (ind[k])); + elt = value_subscript (elt, value_pos_atr (builtin_type_int32, ind[k])); } return elt; } @@ -2360,7 +2360,7 @@ ada_value_ptr_subscript (struct value *arr, struct type *type, int arity, arr = value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)), value_copy (arr)); get_discrete_bounds (TYPE_INDEX_TYPE (type), &lwb, &upb); - idx = value_pos_atr (ind[k]); + idx = value_pos_atr (builtin_type_int32, ind[k]); if (lwb != 0) idx = value_binop (idx, value_from_longest (value_type (idx), lwb), BINOP_SUB); @@ -2500,7 +2500,7 @@ ada_index_type (struct type *type, int n) has a target type of TYPE_CODE_UNDEF. We compensate here, but perhaps stabsread.c would make more sense. */ if (result_type == NULL || TYPE_CODE (result_type) == TYPE_CODE_UNDEF) - result_type = builtin_type_int; + result_type = builtin_type_int32; return result_type; } @@ -2528,7 +2528,7 @@ ada_array_bound_from_type (struct type * arr_type, int n, int which, if (arr_type == NULL || !ada_is_simple_array_type (arr_type)) { if (typep != NULL) - *typep = builtin_type_int; + *typep = builtin_type_int32; return (LONGEST) - which; } @@ -4396,7 +4396,29 @@ remove_extra_symbols (struct ada_symbol_info *syms, int nsyms) i = 0; while (i < nsyms) { - if (SYMBOL_LINKAGE_NAME (syms[i].sym) != NULL + int remove = 0; + + /* If two symbols have the same name and one of them is a stub type, + the get rid of the stub. */ + + if (TYPE_STUB (SYMBOL_TYPE (syms[i].sym)) + && SYMBOL_LINKAGE_NAME (syms[i].sym) != NULL) + { + for (j = 0; j < nsyms; j++) + { + if (j != i + && !TYPE_STUB (SYMBOL_TYPE (syms[j].sym)) + && SYMBOL_LINKAGE_NAME (syms[j].sym) != NULL + && strcmp (SYMBOL_LINKAGE_NAME (syms[i].sym), + SYMBOL_LINKAGE_NAME (syms[j].sym)) == 0) + remove = 1; + } + } + + /* Two symbols with the same name, same class and same address + should be identical. */ + + else if (SYMBOL_LINKAGE_NAME (syms[i].sym) != NULL && SYMBOL_CLASS (syms[i].sym) == LOC_STATIC && is_nondebugging_type (SYMBOL_TYPE (syms[i].sym))) { @@ -4409,18 +4431,18 @@ remove_extra_symbols (struct ada_symbol_info *syms, int nsyms) && SYMBOL_CLASS (syms[i].sym) == SYMBOL_CLASS (syms[j].sym) && SYMBOL_VALUE_ADDRESS (syms[i].sym) == SYMBOL_VALUE_ADDRESS (syms[j].sym)) - { - int k; - for (k = i + 1; k < nsyms; k += 1) - syms[k - 1] = syms[k]; - nsyms -= 1; - goto NextSymbol; - } + remove = 1; } } + + if (remove) + { + for (j = i + 1; j < nsyms; j += 1) + syms[j - 1] = syms[j]; + nsyms -= 1; + } + i += 1; - NextSymbol: - ; } return nsyms; } @@ -4650,6 +4672,70 @@ remove_irrelevant_renamings (struct ada_symbol_info *syms, return nsyms; } +/* Add to OBSTACKP all symbols from BLOCK (and its super-blocks) + whose name and domain match NAME and DOMAIN respectively. + If no match was found, then extend the search to "enclosing" + routines (in other words, if we're inside a nested function, + search the symbols defined inside the enclosing functions). + + Note: This function assumes that OBSTACKP has 0 (zero) element in it. */ + +static void +ada_add_local_symbols (struct obstack *obstackp, const char *name, + struct block *block, domain_enum domain, + int wild_match) +{ + int block_depth = 0; + + while (block != NULL) + { + block_depth += 1; + ada_add_block_symbols (obstackp, block, name, domain, NULL, wild_match); + + /* If we found a non-function match, assume that's the one. */ + if (is_nonfunction (defns_collected (obstackp, 0), + num_defns_collected (obstackp))) + return; + + block = BLOCK_SUPERBLOCK (block); + } + + /* If no luck so far, try to find NAME as a local symbol in some lexically + enclosing subprogram. */ + if (num_defns_collected (obstackp) == 0 && block_depth > 2) + add_symbols_from_enclosing_procs (obstackp, name, domain, wild_match); +} + +/* Add to OBSTACKP all non-local symbols whose name and domain match + NAME and DOMAIN respectively. The search is performed on GLOBAL_BLOCK + symbols if GLOBAL is non-zero, or on STATIC_BLOCK symbols otherwise. */ + +static void +ada_add_non_local_symbols (struct obstack *obstackp, const char *name, + domain_enum domain, int global, + int wild_match) +{ + struct objfile *objfile; + struct partial_symtab *ps; + + ALL_PSYMTABS (objfile, ps) + { + QUIT; + if (ps->readin + || ada_lookup_partial_symbol (ps, name, global, domain, wild_match)) + { + struct symtab *s = PSYMTAB_TO_SYMTAB (ps); + const int block_kind = global ? GLOBAL_BLOCK : STATIC_BLOCK; + + if (s == NULL || !s->primary) + continue; + ada_add_block_symbols (obstackp, + BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), block_kind), + name, domain, objfile, wild_match); + } + } +} + /* Find symbols in DOMAIN matching NAME0, in BLOCK0 and enclosing scope and in global scopes, returning the number of matches. Sets *RESULTS to point to a vector of (SYM,BLOCK) tuples, @@ -4670,16 +4756,10 @@ ada_lookup_symbol_list (const char *name0, const struct block *block0, struct ada_symbol_info **results) { struct symbol *sym; - struct symtab *s; - struct partial_symtab *ps; - struct blockvector *bv; - struct objfile *objfile; struct block *block; const char *name; - struct minimal_symbol *msymbol; int wild_match; int cacheIfUnique; - int block_depth; int ndefns; obstack_free (&symbol_list_obstack, NULL); @@ -4694,6 +4774,14 @@ ada_lookup_symbol_list (const char *name0, const struct block *block0, block = (struct block *) block0; /* FIXME: No cast ought to be needed, but adding const will have a cascade effect. */ + + /* Special case: If the user specifies a symbol name inside package + Standard, do a non-wild matching of the symbol name without + the "standard__" prefix. This was primarily introduced in order + to allow the user to specifically access the standard exceptions + using, for instance, Standard.Constraint_Error when Constraint_Error + is ambiguous (due to the user defining its own Constraint_Error + entity inside its program). */ if (strncmp (name0, "standard__", sizeof ("standard__") - 1) == 0) { wild_match = 0; @@ -4701,32 +4789,17 @@ ada_lookup_symbol_list (const char *name0, const struct block *block0, name = name0 + sizeof ("standard__") - 1; } - block_depth = 0; - while (block != NULL) - { - block_depth += 1; - ada_add_block_symbols (&symbol_list_obstack, block, name, - namespace, NULL, wild_match); - - /* If we found a non-function match, assume that's the one. */ - if (is_nonfunction (defns_collected (&symbol_list_obstack, 0), - num_defns_collected (&symbol_list_obstack))) - goto done; - - block = BLOCK_SUPERBLOCK (block); - } - - /* If no luck so far, try to find NAME as a local symbol in some lexically - enclosing subprogram. */ - if (num_defns_collected (&symbol_list_obstack) == 0 && block_depth > 2) - add_symbols_from_enclosing_procs (&symbol_list_obstack, - name, namespace, wild_match); - - /* If we found ANY matches among non-global symbols, we're done. */ + /* Check the non-global symbols. If we have ANY match, then we're done. */ + ada_add_local_symbols (&symbol_list_obstack, name, block, namespace, + wild_match); if (num_defns_collected (&symbol_list_obstack) > 0) goto done; + /* No non-global symbols found. Check our cache to see if we have + already performed this search before. If we have, then return + the same result. */ + cacheIfUnique = 1; if (lookup_cached_symbol (name0, namespace, &sym, &block)) { @@ -4735,114 +4808,17 @@ ada_lookup_symbol_list (const char *name0, const struct block *block0, goto done; } - /* Now add symbols from all global blocks: symbol tables, minimal symbol - tables, and psymtab's. */ - - ALL_PRIMARY_SYMTABS (objfile, s) - { - QUIT; - bv = BLOCKVECTOR (s); - block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - ada_add_block_symbols (&symbol_list_obstack, block, name, namespace, - objfile, wild_match); - } - - if (namespace == VAR_DOMAIN) - { - ALL_MSYMBOLS (objfile, msymbol) - { - if (ada_match_name (SYMBOL_LINKAGE_NAME (msymbol), name, wild_match)) - { - switch (MSYMBOL_TYPE (msymbol)) - { - case mst_solib_trampoline: - break; - default: - s = find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)); - if (s != NULL) - { - int ndefns0 = num_defns_collected (&symbol_list_obstack); - char *raw_name = SYMBOL_LINKAGE_NAME (msymbol); - char *name1; - const char *suffix; - QUIT; - suffix = strrchr (raw_name, '.'); - if (suffix == NULL) - suffix = strrchr (raw_name, '$'); - if (suffix != NULL && is_digits_suffix (suffix + 1)) - { - name1 = alloca (suffix - raw_name + 1); - strncpy (name1, raw_name, suffix - raw_name); - name1[suffix - raw_name] = '\0'; - } - else - name1 = raw_name; - - bv = BLOCKVECTOR (s); - block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - ada_add_block_symbols (&symbol_list_obstack, block, - name1, namespace, objfile, 0); - - if (num_defns_collected (&symbol_list_obstack) == ndefns0) - { - block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - ada_add_block_symbols (&symbol_list_obstack, block, - name1, namespace, objfile, 0); - } - } - } - } - } - } - - ALL_PSYMTABS (objfile, ps) - { - QUIT; - if (!ps->readin - && ada_lookup_partial_symbol (ps, name, 1, namespace, wild_match)) - { - s = PSYMTAB_TO_SYMTAB (ps); - if (!s->primary) - continue; - bv = BLOCKVECTOR (s); - block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - ada_add_block_symbols (&symbol_list_obstack, block, name, - namespace, objfile, wild_match); - } - } + /* Search symbols from all global blocks. */ + + ada_add_non_local_symbols (&symbol_list_obstack, name, namespace, 1, + wild_match); /* Now add symbols from all per-file blocks if we've gotten no hits - (Not strictly correct, but perhaps better than an error). - Do the symtabs first, then check the psymtabs. */ + (not strictly correct, but perhaps better than an error). */ if (num_defns_collected (&symbol_list_obstack) == 0) - { - - ALL_PRIMARY_SYMTABS (objfile, s) - { - QUIT; - bv = BLOCKVECTOR (s); - block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - ada_add_block_symbols (&symbol_list_obstack, block, name, namespace, - objfile, wild_match); - } - - ALL_PSYMTABS (objfile, ps) - { - QUIT; - if (!ps->readin - && ada_lookup_partial_symbol (ps, name, 0, namespace, wild_match)) - { - s = PSYMTAB_TO_SYMTAB (ps); - bv = BLOCKVECTOR (s); - if (!s->primary) - continue; - block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); - ada_add_block_symbols (&symbol_list_obstack, block, name, - namespace, objfile, wild_match); - } - } - } + ada_add_non_local_symbols (&symbol_list_obstack, name, namespace, 0, + wild_match); done: ndefns = num_defns_collected (&symbol_list_obstack); @@ -5842,7 +5818,7 @@ ada_variant_discrim_type (struct type *var_type, struct type *outer_type) struct type *type = ada_lookup_struct_elt_type (outer_type, name, 1, 1, NULL); if (type == NULL) - return builtin_type_int; + return builtin_type_int32; else return type; } @@ -7598,9 +7574,9 @@ pos_atr (struct value *arg) } static struct value * -value_pos_atr (struct value *arg) +value_pos_atr (struct type *type, struct value *arg) { - return value_from_longest (builtin_type_int, pos_atr (arg)); + return value_from_longest (type, pos_atr (arg)); } /* Evaluate the TYPE'VAL attribute applied to ARG. */ @@ -7882,8 +7858,7 @@ cast_to_fixed (struct type *type, struct value *arg) value_as_long (arg))); else { - DOUBLEST argd = - value_as_double (value_cast (builtin_type_double, value_copy (arg))); + DOUBLEST argd = value_as_double (arg); val = ada_float_to_fixed (type, argd); } @@ -7891,11 +7866,11 @@ cast_to_fixed (struct type *type, struct value *arg) } static struct value * -cast_from_fixed_to_double (struct value *arg) +cast_from_fixed (struct type *type, struct value *arg) { DOUBLEST val = ada_fixed_to_float (value_type (arg), value_as_long (arg)); - return value_from_double (builtin_type_double, val); + return value_from_double (type, val); } /* Coerce VAL as necessary for assignment to an lval of type TYPE, and @@ -8055,7 +8030,7 @@ assign_component (struct value *container, struct value *lhs, LONGEST index, struct value *elt; if (TYPE_CODE (value_type (lhs)) == TYPE_CODE_ARRAY) { - struct value *index_val = value_from_longest (builtin_type_int, index); + struct value *index_val = value_from_longest (builtin_type_int32, index); elt = unwrap_value (ada_value_subscript (lhs, 1, &index_val)); } else @@ -8349,7 +8324,7 @@ ada_value_cast (struct type *type, struct value *arg2, enum noside noside) return (cast_to_fixed (type, arg2)); if (ada_is_fixed_point_type (value_type (arg2))) - return value_cast (type, cast_from_fixed_to_double (arg2)); + return cast_from_fixed (type, arg2); return value_cast (type, arg2); } @@ -8463,6 +8438,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, type = value_type (arg1); while (TYPE_CODE (type) == TYPE_CODE_REF) type = TYPE_TARGET_TYPE (type); + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); return value_cast (type, value_binop (arg1, arg2, BINOP_ADD)); case BINOP_SUB: @@ -8484,6 +8460,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, type = value_type (arg1); while (TYPE_CODE (type) == TYPE_CODE_REF) type = TYPE_TARGET_TYPE (type); + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); return value_cast (type, value_binop (arg1, arg2, BINOP_SUB)); case BINOP_MUL: @@ -8497,10 +8474,12 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, return value_zero (value_type (arg1), not_lval); else { + type = builtin_type (exp->gdbarch)->builtin_double; if (ada_is_fixed_point_type (value_type (arg1))) - arg1 = cast_from_fixed_to_double (arg1); + arg1 = cast_from_fixed (type, arg1); if (ada_is_fixed_point_type (value_type (arg2))) - arg2 = cast_from_fixed_to_double (arg2); + arg2 = cast_from_fixed (type, arg2); + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); return ada_value_binop (arg1, arg2, op); } @@ -8514,7 +8493,10 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, && (op == BINOP_DIV || op == BINOP_REM || op == BINOP_MOD)) return value_zero (value_type (arg1), not_lval); else - return ada_value_binop (arg1, arg2, op); + { + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); + return ada_value_binop (arg1, arg2, op); + } case BINOP_EQUAL: case BINOP_NOTEQUAL: @@ -8525,7 +8507,10 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, if (noside == EVAL_AVOID_SIDE_EFFECTS) tem = 0; else - tem = ada_value_equal (arg1, arg2); + { + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); + tem = ada_value_equal (arg1, arg2); + } if (op == BINOP_NOTEQUAL) tem = !tem; type = language_bool_type (exp->language_defn, exp->gdbarch); @@ -8538,7 +8523,10 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, else if (ada_is_fixed_point_type (value_type (arg1))) return value_cast (value_type (arg1), value_neg (arg1)); else - return value_neg (arg1); + { + unop_promote (exp->language_defn, exp->gdbarch, &arg1); + return value_neg (arg1); + } case BINOP_LOGICAL_AND: case BINOP_LOGICAL_OR: @@ -8823,6 +8811,8 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, case TYPE_CODE_RANGE: arg2 = value_from_longest (type, TYPE_LOW_BOUND (type)); arg3 = value_from_longest (type, TYPE_HIGH_BOUND (type)); + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg3); type = language_bool_type (exp->language_defn, exp->gdbarch); return value_from_longest (type, @@ -8854,6 +8844,8 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, arg3 = ada_array_bound (arg2, tem, 1); arg2 = ada_array_bound (arg2, tem, 0); + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg3); type = language_bool_type (exp->language_defn, exp->gdbarch); return value_from_longest (type, @@ -8870,6 +8862,8 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, if (noside == EVAL_SKIP) goto nosideret; + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg3); type = language_bool_type (exp->language_defn, exp->gdbarch); return value_from_longest (type, @@ -9017,8 +9011,11 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, else if (noside == EVAL_AVOID_SIDE_EFFECTS) return value_zero (value_type (arg1), not_lval); else - return value_binop (arg1, arg2, - op == OP_ATR_MIN ? BINOP_MIN : BINOP_MAX); + { + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); + return value_binop (arg1, arg2, + op == OP_ATR_MIN ? BINOP_MIN : BINOP_MAX); + } case OP_ATR_MODULUS: { @@ -9041,10 +9038,11 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); if (noside == EVAL_SKIP) goto nosideret; - else if (noside == EVAL_AVOID_SIDE_EFFECTS) - return value_zero (builtin_type_int, not_lval); + type = builtin_type (exp->gdbarch)->builtin_int; + if (noside == EVAL_AVOID_SIDE_EFFECTS) + return value_zero (type, not_lval); else - return value_pos_atr (arg1); + return value_pos_atr (type, arg1); case OP_ATR_SIZE: arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); @@ -9076,7 +9074,16 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, else if (noside == EVAL_AVOID_SIDE_EFFECTS) return value_zero (value_type (arg1), not_lval); else - return value_binop (arg1, arg2, op); + { + /* For integer exponentiation operations, + only promote the first argument. */ + if (is_integral_type (value_type (arg2))) + unop_promote (exp->language_defn, exp->gdbarch, &arg1); + else + binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2); + + return value_binop (arg1, arg2, op); + } case UNOP_PLUS: arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); @@ -9089,6 +9096,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside); if (noside == EVAL_SKIP) goto nosideret; + unop_promote (exp->language_defn, exp->gdbarch, &arg1); if (value_less (arg1, value_zero (value_type (arg1), not_lval))) return value_neg (arg1); else @@ -9124,7 +9132,8 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, } else if (TYPE_CODE (type) == TYPE_CODE_INT) /* GDB allows dereferencing an int. */ - return value_zero (builtin_type_int, lval_memory); + return value_zero (builtin_type (exp->gdbarch)->builtin_int, + lval_memory); else error (_("Attempt to take contents of a non-pointer value.")); } @@ -9134,6 +9143,10 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, if (ada_is_array_descriptor_type (type)) /* GDB allows dereferencing GNAT array descriptors. */ return ada_coerce_to_simple_array (arg1); + else if (TYPE_CODE (type) == TYPE_CODE_INT) + /* GDB allows dereferencing an int. */ + return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int, + (CORE_ADDR) value_as_address (arg1)); else return ada_value_ind (arg1); @@ -9207,7 +9220,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp, } nosideret: - return value_from_longest (builtin_type_long, (LONGEST) 1); + return value_from_longest (builtin_type_int8, (LONGEST) 1); } @@ -9467,7 +9480,7 @@ to_fixed_range_type (char *name, struct value *dval, struct objfile *objfile) char *subtype_info; if (raw_type == NULL) - base_type = builtin_type_int; + base_type = builtin_type_int32; else if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE) base_type = TYPE_TARGET_TYPE (raw_type); else @@ -10922,6 +10935,7 @@ const struct language_defn ada_language_defn = { case_sensitive_on, /* Yes, Ada is case-insensitive, but that's not quite what this means. */ array_row_major, + macro_expansion_no, &ada_exp_descriptor, parse, ada_error, @@ -10930,6 +10944,7 @@ const struct language_defn ada_language_defn = { ada_printstr, /* Function to print string constant */ emit_char, /* Function to print single char (not used) */ ada_print_type, /* Print a type using appropriate syntax */ + default_print_typedef, /* Print a typedef using appropriate syntax */ ada_val_print, /* Print a value using appropriate syntax */ ada_value_print, /* Print a top-level value */ NULL, /* Language specific skip_trampoline */