/* YACC parser for Ada expressions, for GDB.
- Copyright (C) 1986, 1989, 1990, 1991, 1993, 1994, 1997, 2000, 2003
- Free Software Foundation, Inc.
+ Copyright (C) 1986, 1989, 1990, 1991, 1993, 1994, 1997, 2000, 2003,
+ 2004 Free Software Foundation, Inc.
This file is part of GDB.
with include files (<malloc.h> and <stdlib.h> for example) just became
too messy, particularly when such includes can be inserted at random
times by the parser generator. */
-
+
%{
#include "defs.h"
-#include <string.h>
+#include "gdb_string.h"
#include <ctype.h>
#include "expression.h"
#include "value.h"
yacc generated parsers in gdb. These are only the variables
produced by yacc. If other parser generators (bison, byacc, etc) produce
additional global names that conflict at link time, then those parser
- generators need to be fixed instead of adding those names to this list. */
+ generators need to be fixed instead of adding those names to this list. */
-/* NOTE: This is clumsy, especially since BISON and FLEX provide --prefix
+/* NOTE: This is clumsy, especially since BISON and FLEX provide --prefix
options. I presume we are maintaining it to accommodate systems
without BISON? (PNH) */
#define yylval ada_lval
#define yychar ada_char
#define yydebug ada_debug
-#define yypact ada_pact
-#define yyr1 ada_r1
-#define yyr2 ada_r2
-#define yydef ada_def
-#define yychk ada_chk
-#define yypgo ada_pgo
-#define yyact ada_act
+#define yypact ada_pact
+#define yyr1 ada_r1
+#define yyr2 ada_r2
+#define yydef ada_def
+#define yychk ada_chk
+#define yypgo ada_pgo
+#define yyact ada_act
#define yyexca ada_exca
#define yyerrflag ada_errflag
#define yynerrs ada_nerrs
#define YYFPRINTF parser_fprintf
struct name_info {
- struct symbol* sym;
- struct minimal_symbol* msym;
- struct block* block;
+ struct symbol *sym;
+ struct minimal_symbol *msym;
+ struct block *block;
struct stoken stoken;
};
/* If expression is in the context of TYPE'(...), then TYPE, else
- * NULL. */
-static struct type* type_qualifier;
+ * NULL. */
+static struct type *type_qualifier;
int yyparse (void);
static struct stoken string_to_operator (struct stoken);
-static void write_attribute_call0 (enum ada_attribute);
+static void write_int (LONGEST, struct type *);
-static void write_attribute_call1 (enum ada_attribute, LONGEST);
+static void write_object_renaming (struct block *, struct symbol *, int);
-static void write_attribute_calln (enum ada_attribute, int);
+static void write_var_from_name (struct block *, struct name_info);
-static void write_object_renaming (struct block*, struct symbol*);
+static LONGEST convert_char_literal (struct type *, LONGEST);
-static void write_var_from_name (struct block*, struct name_info);
+static struct type *type_int (void);
-static LONGEST
-convert_char_literal (struct type*, LONGEST);
-%}
+static struct type *type_long (void);
+
+static struct type *type_long_long (void);
+
+static struct type *type_float (void);
+
+static struct type *type_double (void);
+
+static struct type *type_long_double (void);
+
+static struct type *type_char (void);
+
+static struct type *type_system_address (void);
+%}
%union
{
Contexts where this distinction is not important can use the
nonterminal "name", which matches either NAME or TYPENAME. */
-%token <sval> STRING
+%token <sval> STRING
%token <ssym> NAME DOT_ID OBJECT_RENAMING
-%type <bval> block
+%type <bval> block
%type <lval> arglist tick_arglist
%type <tval> save_qualifier
/* Special type cases, put in to allow the parser to distinguish different
legal basetypes. */
-%token <lval> LAST REGNAME
-
-%token <ivar> INTERNAL_VARIABLE
+%token <sval> SPECIAL_VARIABLE
%nonassoc ASSIGN
%left _AND_ OR XOR THEN ELSE
%left UNARY
%left '*' '/' MOD REM
%right STARSTAR ABS NOT
- /* The following are right-associative only so that reductions at this
- precedence have lower precedence than '.' and '('. The syntax still
- forces a.b.c, e.g., to be LEFT-associated. */
+ /* The following are right-associative only so that reductions at this
+ precedence have lower precedence than '.' and '('. The syntax still
+ forces a.b.c, e.g., to be LEFT-associated. */
%right TICK_ACCESS TICK_ADDRESS TICK_FIRST TICK_LAST TICK_LENGTH
%right TICK_MAX TICK_MIN TICK_MODULUS
%right TICK_POS TICK_RANGE TICK_SIZE TICK_TAG TICK_VAL
simple_exp : simple_exp DOT_ID
{ write_exp_elt_opcode (STRUCTOP_STRUCT);
write_exp_string ($2.stoken);
- write_exp_elt_opcode (STRUCTOP_STRUCT);
+ write_exp_elt_opcode (STRUCTOP_STRUCT);
}
;
{
write_exp_elt_opcode (UNOP_CAST);
write_exp_elt_type ($1);
- write_exp_elt_opcode (UNOP_CAST);
+ write_exp_elt_opcode (UNOP_CAST);
}
;
simple_exp : type '\'' save_qualifier { type_qualifier = $1; } '(' exp ')'
{
- /* write_exp_elt_opcode (UNOP_QUAL); */
- /* FIXME: UNOP_QUAL should be defined in expression.h */
+ write_exp_elt_opcode (UNOP_QUAL);
write_exp_elt_type ($1);
- /* write_exp_elt_opcode (UNOP_QUAL); */
- /* FIXME: UNOP_QUAL should be defined in expression.h */
+ write_exp_elt_opcode (UNOP_QUAL);
type_qualifier = $3;
}
;
simple_exp : '(' exp1 ')' { }
;
-simple_exp : variable
+simple_exp : variable
;
-simple_exp: REGNAME /* GDB extension */
- { write_exp_elt_opcode (OP_REGISTER);
- write_exp_elt_longcst ((LONGEST) $1);
- write_exp_elt_opcode (OP_REGISTER);
- }
+simple_exp: SPECIAL_VARIABLE /* Various GDB extensions */
+ { write_dollar_variable ($1); }
;
-simple_exp: INTERNAL_VARIABLE /* GDB extension */
- { write_exp_elt_opcode (OP_INTERNALVAR);
- write_exp_elt_intern ($1);
- write_exp_elt_opcode (OP_INTERNALVAR);
- }
- ;
-
-
exp : simple_exp
;
-simple_exp: LAST
- { write_exp_elt_opcode (OP_LAST);
- write_exp_elt_longcst ((LONGEST) $1);
- write_exp_elt_opcode (OP_LAST);
- }
- ;
-
exp : exp ASSIGN exp /* Extension for convenience */
{ write_exp_elt_opcode (BINOP_ASSIGN); }
;
/* GDB extension */
{ write_exp_elt_opcode (UNOP_MEMVAL);
write_exp_elt_type ($2);
- write_exp_elt_opcode (UNOP_MEMVAL);
+ write_exp_elt_opcode (UNOP_MEMVAL);
}
;
;
exp : exp IN exp DOTDOT exp
- { /*write_exp_elt_opcode (TERNOP_MBR); */ }
- /* FIXME: TERNOP_MBR should be defined in
- expression.h */
+ { write_exp_elt_opcode (TERNOP_IN_RANGE); }
| exp IN exp TICK_RANGE tick_arglist
- { /*write_exp_elt_opcode (BINOP_MBR); */
- /* FIXME: BINOP_MBR should be defined in expression.h */
+ { write_exp_elt_opcode (BINOP_IN_BOUNDS);
write_exp_elt_longcst ((LONGEST) $5);
- /*write_exp_elt_opcode (BINOP_MBR); */
+ write_exp_elt_opcode (BINOP_IN_BOUNDS);
}
| exp IN TYPENAME %prec TICK_ACCESS
- { /*write_exp_elt_opcode (UNOP_MBR); */
- /* FIXME: UNOP_QUAL should be defined in expression.h */
+ { write_exp_elt_opcode (UNOP_IN_RANGE);
write_exp_elt_type ($3);
- /* write_exp_elt_opcode (UNOP_MBR); */
- /* FIXME: UNOP_MBR should be defined in expression.h */
+ write_exp_elt_opcode (UNOP_IN_RANGE);
}
| exp NOT IN exp DOTDOT exp
- { /*write_exp_elt_opcode (TERNOP_MBR); */
- /* FIXME: TERNOP_MBR should be defined in expression.h */
- write_exp_elt_opcode (UNOP_LOGICAL_NOT);
+ { write_exp_elt_opcode (TERNOP_IN_RANGE);
+ write_exp_elt_opcode (UNOP_LOGICAL_NOT);
}
| exp NOT IN exp TICK_RANGE tick_arglist
- { /* write_exp_elt_opcode (BINOP_MBR); */
- /* FIXME: BINOP_MBR should be defined in expression.h */
+ { write_exp_elt_opcode (BINOP_IN_BOUNDS);
write_exp_elt_longcst ((LONGEST) $6);
- /*write_exp_elt_opcode (BINOP_MBR);*/
- /* FIXME: BINOP_MBR should be defined in expression.h */
- write_exp_elt_opcode (UNOP_LOGICAL_NOT);
+ write_exp_elt_opcode (BINOP_IN_BOUNDS);
+ write_exp_elt_opcode (UNOP_LOGICAL_NOT);
}
| exp NOT IN TYPENAME %prec TICK_ACCESS
- { /*write_exp_elt_opcode (UNOP_MBR);*/
- /* FIXME: UNOP_MBR should be defined in expression.h */
+ { write_exp_elt_opcode (UNOP_IN_RANGE);
write_exp_elt_type ($4);
- /* write_exp_elt_opcode (UNOP_MBR);*/
- /* FIXME: UNOP_MBR should be defined in expression.h */
- write_exp_elt_opcode (UNOP_LOGICAL_NOT);
+ write_exp_elt_opcode (UNOP_IN_RANGE);
+ write_exp_elt_opcode (UNOP_LOGICAL_NOT);
}
;
{ write_exp_elt_opcode (BINOP_GTR); }
;
-exp : exp _AND_ exp /* Fix for Ada elementwise AND. */
+exp : exp _AND_ exp /* Fix for Ada elementwise AND. */
{ write_exp_elt_opcode (BINOP_BITWISE_AND); }
;
{ write_exp_elt_opcode (BINOP_BITWISE_IOR); }
;
-exp : exp OR ELSE exp
+exp : exp OR ELSE exp
{ write_exp_elt_opcode (BINOP_LOGICAL_OR); }
;
| simple_exp TICK_ADDRESS
{ write_exp_elt_opcode (UNOP_ADDR);
write_exp_elt_opcode (UNOP_CAST);
- write_exp_elt_type (builtin_type_ada_system_address);
+ write_exp_elt_type (type_system_address ());
write_exp_elt_opcode (UNOP_CAST);
}
| simple_exp TICK_FIRST tick_arglist
- { write_attribute_call1 (ATR_FIRST, $3); }
+ { write_int ($3, type_int ());
+ write_exp_elt_opcode (OP_ATR_FIRST); }
| simple_exp TICK_LAST tick_arglist
- { write_attribute_call1 (ATR_LAST, $3); }
+ { write_int ($3, type_int ());
+ write_exp_elt_opcode (OP_ATR_LAST); }
| simple_exp TICK_LENGTH tick_arglist
- { write_attribute_call1 (ATR_LENGTH, $3); }
- | simple_exp TICK_SIZE
- { write_attribute_call0 (ATR_SIZE); }
+ { write_int ($3, type_int ());
+ write_exp_elt_opcode (OP_ATR_LENGTH); }
+ | simple_exp TICK_SIZE
+ { write_exp_elt_opcode (OP_ATR_SIZE); }
| simple_exp TICK_TAG
- { write_attribute_call0 (ATR_TAG); }
+ { write_exp_elt_opcode (OP_ATR_TAG); }
| opt_type_prefix TICK_MIN '(' exp ',' exp ')'
- { write_attribute_calln (ATR_MIN, 2); }
+ { write_exp_elt_opcode (OP_ATR_MIN); }
| opt_type_prefix TICK_MAX '(' exp ',' exp ')'
- { write_attribute_calln (ATR_MAX, 2); }
+ { write_exp_elt_opcode (OP_ATR_MAX); }
| opt_type_prefix TICK_POS '(' exp ')'
- { write_attribute_calln (ATR_POS, 1); }
+ { write_exp_elt_opcode (OP_ATR_POS); }
| type_prefix TICK_FIRST tick_arglist
- { write_attribute_call1 (ATR_FIRST, $3); }
+ { write_int ($3, type_int ());
+ write_exp_elt_opcode (OP_ATR_FIRST); }
| type_prefix TICK_LAST tick_arglist
- { write_attribute_call1 (ATR_LAST, $3); }
+ { write_int ($3, type_int ());
+ write_exp_elt_opcode (OP_ATR_LAST); }
| type_prefix TICK_LENGTH tick_arglist
- { write_attribute_call1 (ATR_LENGTH, $3); }
+ { write_int ($3, type_int ());
+ write_exp_elt_opcode (OP_ATR_LENGTH); }
| type_prefix TICK_VAL '(' exp ')'
- { write_attribute_calln (ATR_VAL, 1); }
- | type_prefix TICK_MODULUS
- { write_attribute_call0 (ATR_MODULUS); }
+ { write_exp_elt_opcode (OP_ATR_VAL); }
+ | type_prefix TICK_MODULUS
+ { write_exp_elt_opcode (OP_ATR_MODULUS); }
;
tick_arglist : %prec '('
opt_type_prefix :
type_prefix
- | /* EMPTY */
+ | /* EMPTY */
{ write_exp_elt_opcode (OP_TYPE);
write_exp_elt_type (builtin_type_void);
write_exp_elt_opcode (OP_TYPE); }
;
-
+
exp : INT
- { write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type ($1.type);
- write_exp_elt_longcst ((LONGEST)($1.val));
- write_exp_elt_opcode (OP_LONG);
- }
+ { write_int ((LONGEST) $1.val, $1.type); }
;
exp : CHARLIT
- { write_exp_elt_opcode (OP_LONG);
- if (type_qualifier == NULL)
- write_exp_elt_type ($1.type);
- else
- write_exp_elt_type (type_qualifier);
- write_exp_elt_longcst
- (convert_char_literal (type_qualifier, $1.val));
- write_exp_elt_opcode (OP_LONG);
- }
+ { write_int (convert_char_literal (type_qualifier, $1.val),
+ (type_qualifier == NULL)
+ ? $1.type : type_qualifier);
+ }
;
-
+
exp : FLOAT
{ write_exp_elt_opcode (OP_DOUBLE);
write_exp_elt_type ($1.type);
write_exp_elt_dblcst ($1.dval);
- write_exp_elt_opcode (OP_DOUBLE);
+ write_exp_elt_opcode (OP_DOUBLE);
}
;
exp : NULL_PTR
- { write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (builtin_type_int);
- write_exp_elt_longcst ((LONGEST)(0));
- write_exp_elt_opcode (OP_LONG);
- }
+ { write_int (0, type_int ()); }
;
exp : STRING
- { /* Ada strings are converted into array constants
- a lower bound of 1. Thus, the array upper bound
- is the string length. */
- char *sp = $1.ptr; int count;
- if ($1.length == 0)
- { /* One dummy character for the type */
- write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (builtin_type_ada_char);
- write_exp_elt_longcst ((LONGEST)(0));
- write_exp_elt_opcode (OP_LONG);
- }
- for (count = $1.length; count > 0; count -= 1)
- {
- write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (builtin_type_ada_char);
- write_exp_elt_longcst ((LONGEST)(*sp));
- sp += 1;
- write_exp_elt_opcode (OP_LONG);
- }
- write_exp_elt_opcode (OP_ARRAY);
- write_exp_elt_longcst ((LONGEST) 1);
- write_exp_elt_longcst ((LONGEST) ($1.length));
- write_exp_elt_opcode (OP_ARRAY);
- }
+ {
+ write_exp_elt_opcode (OP_STRING);
+ write_exp_string ($1);
+ write_exp_elt_opcode (OP_STRING);
+ }
;
exp : NEW TYPENAME
variable: NAME { write_var_from_name (NULL, $1); }
| block NAME /* GDB extension */
{ write_var_from_name ($1, $2); }
- | OBJECT_RENAMING { write_object_renaming (NULL, $1.sym); }
- | block OBJECT_RENAMING
- { write_object_renaming ($1, $2.sym); }
+ | OBJECT_RENAMING
+ { write_object_renaming (NULL, $1.sym,
+ MAX_RENAMING_CHAIN_LENGTH); }
+ | block OBJECT_RENAMING
+ { write_object_renaming ($1, $2.sym,
+ MAX_RENAMING_CHAIN_LENGTH); }
;
any_name : NAME { }
type : TYPENAME { $$ = $1; }
| block TYPENAME { $$ = $2; }
- | TYPENAME TICK_ACCESS
+ | TYPENAME TICK_ACCESS
{ $$ = lookup_pointer_type ($1); }
| block TYPENAME TICK_ACCESS
{ $$ = lookup_pointer_type ($2); }
;
/* Some extensions borrowed from C, for the benefit of those who find they
- can't get used to Ada notation in GDB. */
+ can't get used to Ada notation in GDB. */
exp : '*' exp %prec '.'
{ write_exp_elt_opcode (UNOP_IND); }
#define yytext ada_yytext
#define yywrap ada_yywrap
+static struct obstack temp_parse_space;
+
/* The following kludge was found necessary to prevent conflicts between */
/* defs.h and non-standard stdlib.h files. */
#define qsort __qsort__dummy
#include "ada-lex.c"
int
-ada_parse ()
+ada_parse (void)
{
- lexer_init (yyin); /* (Re-)initialize lexer. */
+ lexer_init (yyin); /* (Re-)initialize lexer. */
left_block_context = NULL;
type_qualifier = NULL;
-
+ obstack_free (&temp_parse_space, NULL);
+ obstack_init (&temp_parse_space);
+
return _ada_parse ();
}
void
-yyerror (msg)
- char *msg;
+yyerror (char *msg)
{
error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
}
-/* The operator name corresponding to operator symbol STRING (adds
+/* The operator name corresponding to operator symbol STRING (adds
quotes and maps to lower-case). Destroys the previous contents of
the array pointed to by STRING.ptr. Error if STRING does not match
a valid Ada operator. Assumes that STRING.ptr points to a
null-terminated string and that, if STRING is a valid operator
symbol, the array pointed to by STRING.ptr contains at least
- STRING.length+3 characters. */
+ STRING.length+3 characters. */
static struct stoken
-string_to_operator (string)
- struct stoken string;
+string_to_operator (struct stoken string)
{
int i;
- for (i = 0; ada_opname_table[i].mangled != NULL; i += 1)
+ for (i = 0; ada_opname_table[i].encoded != NULL; i += 1)
{
- if (string.length == strlen (ada_opname_table[i].demangled)-2
- && strncasecmp (string.ptr, ada_opname_table[i].demangled+1,
+ if (string.length == strlen (ada_opname_table[i].decoded)-2
+ && strncasecmp (string.ptr, ada_opname_table[i].decoded+1,
string.length) == 0)
{
- strncpy (string.ptr, ada_opname_table[i].demangled,
+ strncpy (string.ptr, ada_opname_table[i].decoded,
string.length+2);
string.length += 2;
return string;
}
/* Emit expression to access an instance of SYM, in block BLOCK (if
- * non-NULL), and with :: qualification ORIG_LEFT_CONTEXT. */
+ * non-NULL), and with :: qualification ORIG_LEFT_CONTEXT. */
static void
-write_var_from_sym (orig_left_context, block, sym)
- struct block* orig_left_context;
- struct block* block;
- struct symbol* sym;
+write_var_from_sym (struct block *orig_left_context,
+ struct block *block,
+ struct symbol *sym)
{
if (orig_left_context == NULL && symbol_read_needs_frame (sym))
{
- if (innermost_block == 0 ||
- contained_in (block, innermost_block))
+ if (innermost_block == 0
+ || contained_in (block, innermost_block))
innermost_block = block;
}
write_exp_elt_opcode (OP_VAR_VALUE);
- /* We want to use the selected frame, not another more inner frame
- which happens to be in the same block */
- write_exp_elt_block (NULL);
+ write_exp_elt_block (block);
write_exp_elt_sym (sym);
write_exp_elt_opcode (OP_VAR_VALUE);
}
-/* Emit expression to access an instance of NAME. */
+/* Emit expression to access an instance of NAME in :: context
+ * ORIG_LEFT_CONTEXT. If no unique symbol for NAME has been found,
+ * output a dummy symbol (good to the next call of ada_parse) for NAME
+ * in the UNDEF_DOMAIN, for later resolution by ada_resolve. */
static void
-write_var_from_name (orig_left_context, name)
- struct block* orig_left_context;
- struct name_info name;
+write_var_from_name (struct block *orig_left_context,
+ struct name_info name)
{
if (name.msym != NULL)
{
- write_exp_msymbol (name.msym,
- lookup_function_type (builtin_type_int),
- builtin_type_int);
+ write_exp_msymbol (name.msym,
+ lookup_function_type (type_int ()),
+ type_int ());
}
- else if (name.sym == NULL)
+ else if (name.sym == NULL)
{
- /* Multiple matches: record name and starting block for later
- resolution by ada_resolve. */
- /* write_exp_elt_opcode (OP_UNRESOLVED_VALUE); */
- /* FIXME: OP_UNRESOLVED_VALUE should be defined in expression.h */
+ /* Multiple matches: record name and starting block for later
+ resolution by ada_resolve. */
+ char *encoded_name = ada_encode (name.stoken.ptr);
+ struct symbol *sym =
+ obstack_alloc (&temp_parse_space, sizeof (struct symbol));
+ memset (sym, 0, sizeof (struct symbol));
+ SYMBOL_DOMAIN (sym) = UNDEF_DOMAIN;
+ SYMBOL_LINKAGE_NAME (sym)
+ = obsavestring (encoded_name, strlen (encoded_name), &temp_parse_space);
+ SYMBOL_LANGUAGE (sym) = language_ada;
+
+ write_exp_elt_opcode (OP_VAR_VALUE);
write_exp_elt_block (name.block);
- /* write_exp_elt_name (name.stoken.ptr); */
- /* FIXME: write_exp_elt_name should be defined in defs.h, located in parse.c */
- /* write_exp_elt_opcode (OP_UNRESOLVED_VALUE); */
- /* FIXME: OP_UNRESOLVED_VALUE should be defined in expression.h */
+ write_exp_elt_sym (sym);
+ write_exp_elt_opcode (OP_VAR_VALUE);
}
else
write_var_from_sym (orig_left_context, name.block, name.sym);
}
-/* Write a call on parameterless attribute ATR. */
-
-static void
-write_attribute_call0 (atr)
- enum ada_attribute atr;
-{
- /* write_exp_elt_opcode (OP_ATTRIBUTE); */
- /* FIXME: OP_ATTRIBUTE should be defined in expression.h */
- write_exp_elt_longcst ((LONGEST) 0);
- write_exp_elt_longcst ((LONGEST) atr);
- /* write_exp_elt_opcode (OP_ATTRIBUTE); */
- /* FIXME: OP_ATTRIBUTE should be defined in expression.h */
-}
-
-/* Write a call on an attribute ATR with one constant integer
- * parameter. */
+/* Write integer constant ARG of type TYPE. */
static void
-write_attribute_call1 (atr, arg)
- enum ada_attribute atr;
- LONGEST arg;
+write_int (LONGEST arg, struct type *type)
{
write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (builtin_type_int);
+ write_exp_elt_type (type);
write_exp_elt_longcst (arg);
write_exp_elt_opcode (OP_LONG);
- /*write_exp_elt_opcode (OP_ATTRIBUTE);*/
- /* FIXME: OP_ATTRIBUTE should be defined in expression.h */
- write_exp_elt_longcst ((LONGEST) 1);
- write_exp_elt_longcst ((LONGEST) atr);
- /*write_exp_elt_opcode (OP_ATTRIBUTE);*/
- /* FIXME: OP_ATTRIBUTE should be defined in expression.h */
-}
-
-/* Write a call on an attribute ATR with N parameters, whose code must have
- * been generated previously. */
+}
-static void
-write_attribute_calln (atr, n)
- enum ada_attribute atr;
- int n;
-{
- /*write_exp_elt_opcode (OP_ATTRIBUTE);*/
- /* FIXME: OP_ATTRIBUTE should be defined in expression.h */
- write_exp_elt_longcst ((LONGEST) n);
- write_exp_elt_longcst ((LONGEST) atr);
- /* write_exp_elt_opcode (OP_ATTRIBUTE);*/
- /* FIXME: OP_ATTRIBUTE should be defined in expression.h */
-}
-
-/* Emit expression corresponding to the renamed object designated by
+/* Emit expression corresponding to the renamed object designated by
* the type RENAMING, which must be the referent of an object renaming
- * type, in the context of ORIG_LEFT_CONTEXT (?). */
+ * type, in the context of ORIG_LEFT_CONTEXT. MAX_DEPTH is the maximum
+ * number of cascaded renamings to allow. */
static void
-write_object_renaming (orig_left_context, renaming)
- struct block* orig_left_context;
- struct symbol* renaming;
+write_object_renaming (struct block *orig_left_context,
+ struct symbol *renaming, int max_depth)
{
- const char* qualification = DEPRECATED_SYMBOL_NAME (renaming);
- const char* simple_tail;
- const char* expr = TYPE_FIELD_NAME (SYMBOL_TYPE (renaming), 0);
- const char* suffix;
- char* name;
- struct symbol* sym;
+ const char *qualification = SYMBOL_LINKAGE_NAME (renaming);
+ const char *simple_tail;
+ const char *expr = TYPE_FIELD_NAME (SYMBOL_TYPE (renaming), 0);
+ const char *suffix;
+ char *name;
+ struct symbol *sym;
enum { SIMPLE_INDEX, LOWER_BOUND, UPPER_BOUND } slice_state;
+ if (max_depth <= 0)
+ error ("Could not find renamed symbol");
+
/* if orig_left_context is null, then use the currently selected
- block, otherwise we might fail our symbol lookup below */
+ block; otherwise we might fail our symbol lookup below. */
if (orig_left_context == NULL)
orig_left_context = get_selected_block (NULL);
- for (simple_tail = qualification + strlen (qualification);
+ for (simple_tail = qualification + strlen (qualification);
simple_tail != qualification; simple_tail -= 1)
{
if (*simple_tail == '.')
{
simple_tail += 1;
break;
- }
- else if (STREQN (simple_tail, "__", 2))
+ }
+ else if (strncmp (simple_tail, "__", 2) == 0)
{
simple_tail += 2;
break;
if (suffix == NULL)
goto BadEncoding;
- name = (char*) malloc (suffix - expr + 1);
- /* add_name_string_cleanup (name); */
- /* FIXME: add_name_string_cleanup should be defined in
- parser-defs.h, implemented in parse.c */
+ name = (char *) obstack_alloc (&temp_parse_space, suffix - expr + 1);
strncpy (name, expr, suffix-expr);
name[suffix-expr] = '\000';
- sym = lookup_symbol (name, orig_left_context, VAR_NAMESPACE, 0, NULL);
- /* if (sym == NULL)
- error ("Could not find renamed variable: %s", ada_demangle (name));
- */
- /* FIXME: ada_demangle should be defined in defs.h, implemented in ada-lang.c */
- write_var_from_sym (orig_left_context, block_found, sym);
+ sym = lookup_symbol (name, orig_left_context, VAR_DOMAIN, 0, NULL);
+ if (sym == NULL)
+ error ("Could not find renamed variable: %s", ada_decode (name));
+ if (ada_is_object_renaming (sym))
+ write_object_renaming (orig_left_context, sym, max_depth-1);
+ else
+ write_var_from_sym (orig_left_context, block_found, sym);
suffix += 5;
slice_state = SIMPLE_INDEX;
- while (*suffix == 'X')
+ while (*suffix == 'X')
{
suffix += 1;
switch (*suffix) {
+ case 'A':
+ suffix += 1;
+ write_exp_elt_opcode (UNOP_IND);
+ break;
case 'L':
slice_state = LOWER_BOUND;
case 'S':
suffix += 1;
- if (isdigit (*suffix))
+ if (isdigit (*suffix))
{
- char* next;
+ char *next;
long val = strtol (suffix, &next, 10);
- if (next == suffix)
+ if (next == suffix)
goto BadEncoding;
suffix = next;
write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (builtin_type_ada_int);
+ write_exp_elt_type (type_int ());
write_exp_elt_longcst ((LONGEST) val);
write_exp_elt_opcode (OP_LONG);
- }
+ }
else
{
- const char* end;
- char* index_name;
+ const char *end;
+ char *index_name;
int index_len;
- struct symbol* index_sym;
+ struct symbol *index_sym;
end = strchr (suffix, 'X');
- if (end == NULL)
+ if (end == NULL)
end = suffix + strlen (suffix);
-
+
index_len = simple_tail - qualification + 2 + (suffix - end) + 1;
- index_name = (char*) malloc (index_len);
+ index_name
+ = (char *) obstack_alloc (&temp_parse_space, index_len);
memset (index_name, '\000', index_len);
- /* add_name_string_cleanup (index_name);*/
- /* FIXME: add_name_string_cleanup should be defined in
- parser-defs.h, implemented in parse.c */
strncpy (index_name, qualification, simple_tail - qualification);
index_name[simple_tail - qualification] = '\000';
strncat (index_name, suffix, suffix-end);
suffix = end;
- index_sym =
- lookup_symbol (index_name, NULL, VAR_NAMESPACE, 0, NULL);
+ index_sym =
+ lookup_symbol (index_name, NULL, VAR_DOMAIN, 0, NULL);
if (index_sym == NULL)
error ("Could not find %s", index_name);
write_var_from_sym (NULL, block_found, sym);
}
if (slice_state == SIMPLE_INDEX)
- {
+ {
write_exp_elt_opcode (OP_FUNCALL);
write_exp_elt_longcst ((LONGEST) 1);
write_exp_elt_opcode (OP_FUNCALL);
case 'R':
{
struct stoken field_name;
- const char* end;
+ const char *end;
suffix += 1;
-
+
if (slice_state != SIMPLE_INDEX)
goto BadEncoding;
end = strchr (suffix, 'X');
- if (end == NULL)
+ if (end == NULL)
end = suffix + strlen (suffix);
field_name.length = end - suffix;
- field_name.ptr = (char*) malloc (end - suffix + 1);
+ field_name.ptr = xmalloc (end - suffix + 1);
strncpy (field_name.ptr, suffix, end - suffix);
field_name.ptr[end - suffix] = '\000';
suffix = end;
write_exp_elt_opcode (STRUCTOP_STRUCT);
write_exp_string (field_name);
- write_exp_elt_opcode (STRUCTOP_STRUCT);
+ write_exp_elt_opcode (STRUCTOP_STRUCT);
break;
}
-
+
default:
goto BadEncoding;
}
BadEncoding:
error ("Internal error in encoding of renaming declaration: %s",
- DEPRECATED_SYMBOL_NAME (renaming));
+ SYMBOL_LINKAGE_NAME (renaming));
}
/* Convert the character literal whose ASCII value would be VAL to the
appropriate value of type TYPE, if there is a translation.
- Otherwise return VAL. Hence, in an enumeration type ('A', 'B'),
- the literal 'A' (VAL == 65), returns 0. */
+ Otherwise return VAL. Hence, in an enumeration type ('A', 'B'),
+ the literal 'A' (VAL == 65), returns 0. */
static LONGEST
-convert_char_literal (struct type* type, LONGEST val)
+convert_char_literal (struct type *type, LONGEST val)
{
char name[7];
int f;
if (type == NULL || TYPE_CODE (type) != TYPE_CODE_ENUM)
return val;
sprintf (name, "QU%02x", (int) val);
- for (f = 0; f < TYPE_NFIELDS (type); f += 1)
+ for (f = 0; f < TYPE_NFIELDS (type); f += 1)
{
- if (STREQ (name, TYPE_FIELD_NAME (type, f)))
+ if (strcmp (name, TYPE_FIELD_NAME (type, f)) == 0)
return TYPE_FIELD_BITPOS (type, f);
}
return val;
}
+
+static struct type *
+type_int (void)
+{
+ return builtin_type (current_gdbarch)->builtin_int;
+}
+
+static struct type *
+type_long (void)
+{
+ return builtin_type (current_gdbarch)->builtin_long;
+}
+
+static struct type *
+type_long_long (void)
+{
+ return builtin_type (current_gdbarch)->builtin_long_long;
+}
+
+static struct type *
+type_float (void)
+{
+ return builtin_type (current_gdbarch)->builtin_float;
+}
+
+static struct type *
+type_double (void)
+{
+ return builtin_type (current_gdbarch)->builtin_double;
+}
+
+static struct type *
+type_long_double (void)
+{
+ return builtin_type (current_gdbarch)->builtin_long_double;
+}
+
+static struct type *
+type_char (void)
+{
+ return language_string_char_type (current_language, current_gdbarch);
+}
+
+static struct type *
+type_system_address (void)
+{
+ struct type *type
+ = language_lookup_primitive_type_by_name (current_language,
+ current_gdbarch,
+ "system__address");
+ return type != NULL ? type : lookup_pointer_type (builtin_type_void);
+}
+
+void
+_initialize_ada_exp (void)
+{
+ obstack_init (&temp_parse_space);
+}
+
+/* FIXME: hilfingr/2004-10-05: Hack to remove warning. The function
+ string_to_operator is supposed to be used for cases where one
+ calls an operator function with prefix notation, as in
+ "+" (a, b), but at some point, this code seems to have gone
+ missing. */
+
+struct stoken (*dummy_string_to_ada_operator) (struct stoken)
+ = string_to_operator;
+