/* Parse C expressions for GDB.
- Copyright (C) 1986 Free Software Foundation, Inc.
-
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY. No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License. A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities. It
-should be in a file named COPYING. Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther. Help stamp out software hoarding!
-*/
+ Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
\f
/* Parse a C expression from text in a string,
and return the result as a struct expression pointer.
come first in the result. */
%{
+#include <stdio.h>
#include "defs.h"
#include "param.h"
#include "symtab.h"
#include "frame.h"
#include "expression.h"
-
-#include <stdio.h>
+#include "value.h"
+#include "command.h"
static struct expression *expout;
static int expout_size;
static int expout_ptr;
static int yylex ();
-static yyerror ();
+static void yyerror ();
static void write_exp_elt ();
+static void write_exp_elt_opcode ();
+static void write_exp_elt_sym ();
+static void write_exp_elt_longcst ();
+static void write_exp_elt_dblcst ();
+static void write_exp_elt_type ();
+static void write_exp_elt_intern ();
static void write_exp_string ();
static void start_arglist ();
static int end_arglist ();
static void free_funcalls ();
static char *copy_name ();
+static int parse_number ();
/* If this is nonzero, this block is used as the lexical context
for symbol names. */
static struct block *expression_context_block;
+/* The innermost context required by the stack and register variables
+ we've encountered so far. */
+struct block *innermost_block;
+
+/* The block in which the most recently discovered symbol was found. */
+struct block *block_found;
+
/* Number of arguments seen so far in innermost function call. */
static int arglist_len;
char *ptr;
int length;
};
+
+struct ttype
+ {
+ struct stoken stoken;
+ struct type *type;
+ };
+
+struct symtoken
+ {
+ struct stoken stoken;
+ struct symbol *sym;
+ int is_a_field_of_this;
+ };
+
+/* For parsing of complicated types.
+ An array should be preceded in the list by the size of the array. */
+enum type_pieces
+ {tp_end = -1, tp_pointer, tp_reference, tp_array, tp_function};
+/* The stack can contain either an enum type_pieces or an int. */
+union type_stack_elt {
+ enum type_pieces piece;
+ int int_val;
+};
+static union type_stack_elt *type_stack;
+static int type_stack_depth, type_stack_size;
+
+static void push_type ();
+static void push_type_int ();
+static enum type_pieces pop_type ();
+static int pop_type_int ();
+
+/* Allow debugging of parsing. */
+#define YYDEBUG 1
%}
/* Although the yacc "value" of an expression is not used,
%union
{
- long lval;
+ LONGEST lval;
+ unsigned LONGEST ulval;
double dval;
struct symbol *sym;
struct type *tval;
struct stoken sval;
+ struct ttype tsym;
+ struct symtoken ssym;
int voidval;
struct block *bval;
enum exp_opcode opcode;
struct internalvar *ivar;
+
+ struct type **tvec;
+ int *ivec;
}
%type <voidval> exp exp1 start variable
%type <tval> type typebase
+%type <tvec> nonempty_typelist
%type <bval> block
+/* Fancy type parsing. */
+%type <voidval> func_mod direct_abs_decl abs_decl
+%type <tval> ptype
+%type <lval> array_mod
+
%token <lval> INT CHAR
+%token <ulval> UINT
%token <dval> FLOAT
/* Both NAME and TYPENAME tokens represent symbols in the input,
Contexts where this distinction is not important can use the
nonterminal "name", which matches either NAME or TYPENAME. */
-%token <sval> NAME TYPENAME STRING
+%token <sval> STRING
+%token <ssym> NAME BLOCKNAME
+%token <tsym> TYPENAME
%type <sval> name
+%type <ssym> name_not_typename
+%type <tsym> typename
+
+/* A NAME_OR_INT is a symbol which is not known in the symbol table,
+ but which would parse as a valid number in the current input radix.
+ E.g. "c" when input_radix==16. Depending on the parse, it will be
+ turned into a name or into a number. NAME_OR_UINT ditto. */
+
+%token <ssym> NAME_OR_INT NAME_OR_UINT
%token STRUCT UNION ENUM SIZEOF UNSIGNED COLONCOLON
+%token ERROR
+
+/* Special type cases, put in to allow the parser to distinguish different
+ legal basetypes. */
+%token SIGNED LONG SHORT INT_KEYWORD
%token <lval> LAST REGNAME
%token <opcode> ASSIGN_MODIFY
+/* C++ */
+%token THIS
+
%left ','
%left ABOVE_COMMA
%right '=' ASSIGN_MODIFY
+%right '?'
%left OR
%left AND
%left '|'
%left EQUAL NOTEQUAL
%left '<' '>' LEQ GEQ
%left LSH RSH
+%left '@'
%left '+' '-'
%left '*' '/' '%'
-%left '@'
%right UNARY INCREMENT DECREMENT
-%right ARROW '.' '['
+%right ARROW '.' '[' '('
%left COLONCOLON
\f
%%
/* Expressions, including the comma operator. */
exp1 : exp
| exp1 ',' exp
- { write_exp_elt (BINOP_COMMA); }
+ { write_exp_elt_opcode (BINOP_COMMA); }
;
/* Expressions, not including the comma operator. */
exp : '*' exp %prec UNARY
- { write_exp_elt (UNOP_IND); }
+ { write_exp_elt_opcode (UNOP_IND); }
exp : '&' exp %prec UNARY
- { write_exp_elt (UNOP_ADDR); }
+ { write_exp_elt_opcode (UNOP_ADDR); }
exp : '-' exp %prec UNARY
- { write_exp_elt (UNOP_NEG); }
+ { write_exp_elt_opcode (UNOP_NEG); }
;
exp : '!' exp %prec UNARY
- { write_exp_elt (UNOP_ZEROP); }
+ { write_exp_elt_opcode (UNOP_ZEROP); }
;
exp : '~' exp %prec UNARY
- { write_exp_elt (UNOP_LOGNOT); }
+ { write_exp_elt_opcode (UNOP_LOGNOT); }
;
exp : INCREMENT exp %prec UNARY
- { write_exp_elt (UNOP_PREINCREMENT); }
+ { write_exp_elt_opcode (UNOP_PREINCREMENT); }
;
exp : DECREMENT exp %prec UNARY
- { write_exp_elt (UNOP_PREDECREMENT); }
+ { write_exp_elt_opcode (UNOP_PREDECREMENT); }
;
exp : exp INCREMENT %prec UNARY
- { write_exp_elt (UNOP_POSTINCREMENT); }
+ { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
;
exp : exp DECREMENT %prec UNARY
- { write_exp_elt (UNOP_POSTDECREMENT); }
+ { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
;
exp : SIZEOF exp %prec UNARY
- { write_exp_elt (UNOP_SIZEOF); }
+ { write_exp_elt_opcode (UNOP_SIZEOF); }
;
exp : exp ARROW name
- { write_exp_elt (STRUCTOP_PTR);
+ { write_exp_elt_opcode (STRUCTOP_PTR);
write_exp_string ($3);
- write_exp_elt (STRUCTOP_PTR); }
+ write_exp_elt_opcode (STRUCTOP_PTR); }
+ ;
+
+exp : exp ARROW '*' exp
+ { write_exp_elt_opcode (STRUCTOP_MPTR); }
;
exp : exp '.' name
- { write_exp_elt (STRUCTOP_STRUCT);
+ { write_exp_elt_opcode (STRUCTOP_STRUCT);
write_exp_string ($3);
- write_exp_elt (STRUCTOP_STRUCT); }
+ write_exp_elt_opcode (STRUCTOP_STRUCT); }
+ ;
+
+exp : exp '.' '*' exp
+ { write_exp_elt_opcode (STRUCTOP_MEMBER); }
;
exp : exp '[' exp1 ']'
- { write_exp_elt (BINOP_SUBSCRIPT); }
+ { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
;
exp : exp '('
/* This is to save the value of arglist_len
being accumulated by an outer function call. */
{ start_arglist (); }
- arglist ')'
- { write_exp_elt (OP_FUNCALL);
- write_exp_elt (end_arglist ());
- write_exp_elt (OP_FUNCALL); }
+ arglist ')' %prec ARROW
+ { write_exp_elt_opcode (OP_FUNCALL);
+ write_exp_elt_longcst ((LONGEST) end_arglist ());
+ write_exp_elt_opcode (OP_FUNCALL); }
;
arglist :
;
exp : '{' type '}' exp %prec UNARY
- { write_exp_elt (UNOP_MEMVAL);
- write_exp_elt ($2);
- write_exp_elt (UNOP_MEMVAL); }
+ { write_exp_elt_opcode (UNOP_MEMVAL);
+ write_exp_elt_type ($2);
+ write_exp_elt_opcode (UNOP_MEMVAL); }
;
exp : '(' type ')' exp %prec UNARY
- { write_exp_elt (UNOP_CAST);
- write_exp_elt ($2);
- write_exp_elt (UNOP_CAST); }
+ { write_exp_elt_opcode (UNOP_CAST);
+ write_exp_elt_type ($2);
+ write_exp_elt_opcode (UNOP_CAST); }
;
exp : '(' exp1 ')'
/* Binary operators in order of decreasing precedence. */
exp : exp '@' exp
- { write_exp_elt (BINOP_REPEAT); }
+ { write_exp_elt_opcode (BINOP_REPEAT); }
;
exp : exp '*' exp
- { write_exp_elt (BINOP_MUL); }
+ { write_exp_elt_opcode (BINOP_MUL); }
;
exp : exp '/' exp
- { write_exp_elt (BINOP_DIV); }
+ { write_exp_elt_opcode (BINOP_DIV); }
;
exp : exp '%' exp
- { write_exp_elt (BINOP_REM); }
+ { write_exp_elt_opcode (BINOP_REM); }
;
exp : exp '+' exp
- { write_exp_elt (BINOP_ADD); }
+ { write_exp_elt_opcode (BINOP_ADD); }
;
exp : exp '-' exp
- { write_exp_elt (BINOP_SUB); }
+ { write_exp_elt_opcode (BINOP_SUB); }
;
exp : exp LSH exp
- { write_exp_elt (BINOP_LSH); }
+ { write_exp_elt_opcode (BINOP_LSH); }
;
exp : exp RSH exp
- { write_exp_elt (BINOP_RSH); }
+ { write_exp_elt_opcode (BINOP_RSH); }
;
exp : exp EQUAL exp
- { write_exp_elt (BINOP_EQUAL); }
+ { write_exp_elt_opcode (BINOP_EQUAL); }
;
exp : exp NOTEQUAL exp
- { write_exp_elt (BINOP_NOTEQUAL); }
+ { write_exp_elt_opcode (BINOP_NOTEQUAL); }
;
exp : exp LEQ exp
- { write_exp_elt (BINOP_LEQ); }
+ { write_exp_elt_opcode (BINOP_LEQ); }
;
exp : exp GEQ exp
- { write_exp_elt (BINOP_GEQ); }
+ { write_exp_elt_opcode (BINOP_GEQ); }
;
exp : exp '<' exp
- { write_exp_elt (BINOP_LESS); }
+ { write_exp_elt_opcode (BINOP_LESS); }
;
exp : exp '>' exp
- { write_exp_elt (BINOP_GTR); }
+ { write_exp_elt_opcode (BINOP_GTR); }
;
exp : exp '&' exp
- { write_exp_elt (BINOP_LOGAND); }
+ { write_exp_elt_opcode (BINOP_LOGAND); }
;
exp : exp '^' exp
- { write_exp_elt (BINOP_LOGXOR); }
+ { write_exp_elt_opcode (BINOP_LOGXOR); }
;
exp : exp '|' exp
- { write_exp_elt (BINOP_LOGIOR); }
+ { write_exp_elt_opcode (BINOP_LOGIOR); }
;
exp : exp AND exp
- { write_exp_elt (BINOP_AND); }
+ { write_exp_elt_opcode (BINOP_AND); }
;
exp : exp OR exp
- { write_exp_elt (BINOP_OR); }
+ { write_exp_elt_opcode (BINOP_OR); }
;
-exp : exp '?' exp ':' exp
- { write_exp_elt (TERNOP_COND); }
+exp : exp '?' exp ':' exp %prec '?'
+ { write_exp_elt_opcode (TERNOP_COND); }
;
exp : exp '=' exp
- { write_exp_elt (BINOP_ASSIGN); }
+ { write_exp_elt_opcode (BINOP_ASSIGN); }
;
exp : exp ASSIGN_MODIFY exp
- { write_exp_elt (BINOP_ASSIGN_MODIFY);
- write_exp_elt ($2);
- write_exp_elt (BINOP_ASSIGN_MODIFY); }
+ { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
+ write_exp_elt_opcode ($2);
+ write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
;
exp : INT
- { write_exp_elt (OP_LONG);
- write_exp_elt (builtin_type_long);
- write_exp_elt ($1);
- write_exp_elt (OP_LONG); }
+ { write_exp_elt_opcode (OP_LONG);
+ if ($1 == (int) $1 || $1 == (unsigned int) $1)
+ write_exp_elt_type (builtin_type_int);
+ else
+ write_exp_elt_type (BUILTIN_TYPE_LONGEST);
+ write_exp_elt_longcst ((LONGEST) $1);
+ write_exp_elt_opcode (OP_LONG); }
+ ;
+
+exp : NAME_OR_INT
+ { YYSTYPE val;
+ parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
+ write_exp_elt_opcode (OP_LONG);
+ if (val.lval == (int) val.lval ||
+ val.lval == (unsigned int) val.lval)
+ write_exp_elt_type (builtin_type_int);
+ else
+ write_exp_elt_type (BUILTIN_TYPE_LONGEST);
+ write_exp_elt_longcst (val.lval);
+ write_exp_elt_opcode (OP_LONG); }
+ ;
+
+exp : UINT
+ {
+ write_exp_elt_opcode (OP_LONG);
+ if ($1 == (unsigned int) $1)
+ write_exp_elt_type (builtin_type_unsigned_int);
+ else
+ write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
+ write_exp_elt_longcst ((LONGEST) $1);
+ write_exp_elt_opcode (OP_LONG);
+ }
+ ;
+
+exp : NAME_OR_UINT
+ { YYSTYPE val;
+ parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
+ write_exp_elt_opcode (OP_LONG);
+ if (val.ulval == (unsigned int) val.ulval)
+ write_exp_elt_type (builtin_type_unsigned_int);
+ else
+ write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
+ write_exp_elt_longcst ((LONGEST)val.ulval);
+ write_exp_elt_opcode (OP_LONG);
+ }
;
exp : CHAR
- { write_exp_elt (OP_LONG);
- write_exp_elt (builtin_type_char);
- write_exp_elt ($1);
- write_exp_elt (OP_LONG); }
+ { write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_type (builtin_type_char);
+ write_exp_elt_longcst ((LONGEST) $1);
+ write_exp_elt_opcode (OP_LONG); }
;
exp : FLOAT
- { write_exp_elt (OP_DOUBLE);
- write_exp_elt (builtin_type_double);
- write_exp_elt ($1);
- write_exp_elt (OP_DOUBLE); }
+ { write_exp_elt_opcode (OP_DOUBLE);
+ write_exp_elt_type (builtin_type_double);
+ write_exp_elt_dblcst ($1);
+ write_exp_elt_opcode (OP_DOUBLE); }
;
exp : variable
;
exp : LAST
- { write_exp_elt (OP_LAST);
- write_exp_elt ($1);
- write_exp_elt (OP_LAST); }
+ { write_exp_elt_opcode (OP_LAST);
+ write_exp_elt_longcst ((LONGEST) $1);
+ write_exp_elt_opcode (OP_LAST); }
;
exp : REGNAME
- { write_exp_elt (OP_REGISTER);
- write_exp_elt ($1);
- write_exp_elt (OP_REGISTER); }
+ { write_exp_elt_opcode (OP_REGISTER);
+ write_exp_elt_longcst ((LONGEST) $1);
+ write_exp_elt_opcode (OP_REGISTER); }
;
exp : VARIABLE
- { write_exp_elt (OP_INTERNALVAR);
- write_exp_elt ($1);
- write_exp_elt (OP_INTERNALVAR); }
+ { write_exp_elt_opcode (OP_INTERNALVAR);
+ write_exp_elt_intern ($1);
+ write_exp_elt_opcode (OP_INTERNALVAR); }
;
-exp : SIZEOF '(' type ')'
- { write_exp_elt (OP_LONG);
- write_exp_elt (builtin_type_int);
- write_exp_elt ((long) TYPE_LENGTH ($3));
- write_exp_elt (OP_LONG); }
+exp : SIZEOF '(' type ')' %prec UNARY
+ { write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_type (builtin_type_int);
+ write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
+ write_exp_elt_opcode (OP_LONG); }
;
exp : STRING
- { write_exp_elt (OP_STRING);
+ { write_exp_elt_opcode (OP_STRING);
write_exp_string ($1);
- write_exp_elt (OP_STRING); }
+ write_exp_elt_opcode (OP_STRING); }
;
-block : name
- { struct symtab *tem = lookup_symtab (copy_name ($1));
- struct symbol *sym;
-
- if (tem)
- $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), 1);
+/* C++. */
+exp : THIS
+ { write_exp_elt_opcode (OP_THIS);
+ write_exp_elt_opcode (OP_THIS); }
+ ;
+
+/* end of C++. */
+
+block : BLOCKNAME
+ {
+ if ($1.sym != 0)
+ $$ = SYMBOL_BLOCK_VALUE ($1.sym);
else
{
- sym = lookup_symbol (copy_name ($1),
- expression_context_block,
- VAR_NAMESPACE);
- if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
- $$ = SYMBOL_BLOCK_VALUE (sym);
+ struct symtab *tem =
+ lookup_symtab (copy_name ($1.stoken));
+ if (tem)
+ $$ = BLOCKVECTOR_BLOCK
+ (BLOCKVECTOR (tem), STATIC_BLOCK);
else
error ("No file or function \"%s\".",
- copy_name ($1));
- }}
+ copy_name ($1.stoken));
+ }
+ }
;
block : block COLONCOLON name
{ struct symbol *tem
- = lookup_symbol (copy_name ($3), $1, VAR_NAMESPACE);
+ = lookup_symbol (copy_name ($3), $1,
+ VAR_NAMESPACE, 0, NULL);
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error ("No function \"%s\" in specified context.",
copy_name ($3));
variable: block COLONCOLON name
{ struct symbol *sym;
- sym = lookup_symbol ($3, copy_name ($1), VAR_NAMESPACE);
+ sym = lookup_symbol (copy_name ($3), $1,
+ VAR_NAMESPACE, 0, NULL);
if (sym == 0)
error ("No symbol \"%s\" in specified context.",
copy_name ($3));
- write_exp_elt (OP_VAR_VALUE);
- write_exp_elt (sym);
- write_exp_elt (OP_VAR_VALUE); }
+ write_exp_elt_opcode (OP_VAR_VALUE);
+ write_exp_elt_sym (sym);
+ write_exp_elt_opcode (OP_VAR_VALUE); }
;
-variable: NAME
- { struct symbol *sym;
- sym = lookup_symbol (copy_name ($1),
- expression_context_block,
- VAR_NAMESPACE);
+variable: typebase COLONCOLON name
+ {
+ struct type *type = $1;
+ if (TYPE_CODE (type) != TYPE_CODE_STRUCT
+ && TYPE_CODE (type) != TYPE_CODE_UNION)
+ error ("`%s' is not defined as an aggregate type.",
+ TYPE_NAME (type));
+
+ write_exp_elt_opcode (OP_SCOPE);
+ write_exp_elt_type (type);
+ write_exp_string ($3);
+ write_exp_elt_opcode (OP_SCOPE);
+ }
+ | typebase COLONCOLON '~' name
+ {
+ struct type *type = $1;
+ if (TYPE_CODE (type) != TYPE_CODE_STRUCT
+ && TYPE_CODE (type) != TYPE_CODE_UNION)
+ error ("`%s' is not defined as an aggregate type.",
+ TYPE_NAME (type));
+
+ if (strcmp (type_name_no_tag (type), $4.ptr))
+ error ("invalid destructor `%s::~%s'",
+ type_name_no_tag (type), $4.ptr);
+
+ write_exp_elt_opcode (OP_SCOPE);
+ write_exp_elt_type (type);
+ write_exp_string ($4);
+ write_exp_elt_opcode (OP_SCOPE);
+ write_exp_elt_opcode (UNOP_LOGNOT);
+ }
+ | COLONCOLON name
+ {
+ char *name = copy_name ($2);
+ struct symbol *sym;
+ int i;
+
+ sym =
+ lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
+ if (sym)
+ {
+ write_exp_elt_opcode (OP_VAR_VALUE);
+ write_exp_elt_sym (sym);
+ write_exp_elt_opcode (OP_VAR_VALUE);
+ break;
+ }
+ for (i = 0; i < misc_function_count; i++)
+ if (!strcmp (misc_function_vector[i].name, name))
+ break;
+
+ if (i < misc_function_count)
+ {
+ enum misc_function_type mft =
+ misc_function_vector[i].type;
+
+ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_type (builtin_type_int);
+ write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
+ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_opcode (UNOP_MEMVAL);
+ if (mft == mf_data || mft == mf_bss)
+ write_exp_elt_type (builtin_type_int);
+ else if (mft == mf_text)
+ write_exp_elt_type (lookup_function_type (builtin_type_int));
+ else
+ write_exp_elt_type (builtin_type_char);
+ write_exp_elt_opcode (UNOP_MEMVAL);
+ }
+ else
+ if (symtab_list == 0
+ && partial_symtab_list == 0)
+ error ("No symbol table is loaded. Use the \"file\" command.");
+ else
+ error ("No symbol \"%s\" in current context.", name);
+ }
+ ;
+
+variable: name_not_typename
+ { struct symbol *sym = $1.sym;
+
if (sym)
{
- write_exp_elt (OP_VAR_VALUE);
- write_exp_elt (sym);
- write_exp_elt (OP_VAR_VALUE);
+ switch (sym->class)
+ {
+ case LOC_REGISTER:
+ case LOC_ARG:
+ case LOC_REF_ARG:
+ case LOC_REGPARM:
+ case LOC_LOCAL:
+ case LOC_LOCAL_ARG:
+ if (innermost_block == 0 ||
+ contained_in (block_found,
+ innermost_block))
+ innermost_block = block_found;
+ case LOC_UNDEF:
+ case LOC_CONST:
+ case LOC_STATIC:
+ case LOC_TYPEDEF:
+ case LOC_LABEL:
+ case LOC_BLOCK:
+ case LOC_CONST_BYTES:
+
+ /* In this case the expression can
+ be evaluated regardless of what
+ frame we are in, so there is no
+ need to check for the
+ innermost_block. These cases are
+ listed so that gcc -Wall will
+ report types that may not have
+ been considered. */
+
+ break;
+ }
+ write_exp_elt_opcode (OP_VAR_VALUE);
+ write_exp_elt_sym (sym);
+ write_exp_elt_opcode (OP_VAR_VALUE);
+ }
+ else if ($1.is_a_field_of_this)
+ {
+ /* C++: it hangs off of `this'. Must
+ not inadvertently convert from a method call
+ to data ref. */
+ if (innermost_block == 0 ||
+ contained_in (block_found, innermost_block))
+ innermost_block = block_found;
+ write_exp_elt_opcode (OP_THIS);
+ write_exp_elt_opcode (OP_THIS);
+ write_exp_elt_opcode (STRUCTOP_PTR);
+ write_exp_string ($1.stoken);
+ write_exp_elt_opcode (STRUCTOP_PTR);
}
else
{
- register char *arg = copy_name ($1);
register int i;
+ register char *arg = copy_name ($1.stoken);
+
+ /* FIXME, this search is linear! At least
+ optimize the strcmp with a 1-char cmp... */
for (i = 0; i < misc_function_count; i++)
if (!strcmp (misc_function_vector[i].name, arg))
break;
if (i < misc_function_count)
{
- write_exp_elt (OP_LONG);
- write_exp_elt (builtin_type_int);
- write_exp_elt (misc_function_vector[i].address);
- write_exp_elt (OP_LONG);
- write_exp_elt (UNOP_MEMVAL);
- write_exp_elt (builtin_type_char);
- write_exp_elt (UNOP_MEMVAL);
+ enum misc_function_type mft =
+ misc_function_vector[i].type;
+
+ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_type (builtin_type_int);
+ write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
+ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_opcode (UNOP_MEMVAL);
+ if (mft == mf_data || mft == mf_bss)
+ write_exp_elt_type (builtin_type_int);
+ else if (mft == mf_text)
+ write_exp_elt_type (lookup_function_type (builtin_type_int));
+ else
+ write_exp_elt_type (builtin_type_char);
+ write_exp_elt_opcode (UNOP_MEMVAL);
}
+ else if (symtab_list == 0
+ && partial_symtab_list == 0)
+ error ("No symbol table is loaded. Use the \"file\" command.");
else
- if (symtab_list == 0)
- error ("No symbol table is loaded. Use the \"symbol-file\" command.");
- else
- error ("No symbol \"%s\" in current context.",
- copy_name ($1));
+ error ("No symbol \"%s\" in current context.",
+ copy_name ($1.stoken));
}
}
;
-type : typebase
- | type '*'
- { $$ = lookup_pointer_type ($1); }
+
+ptype : typebase
+ | typebase abs_decl
+ {
+ /* This is where the interesting stuff happens. */
+ int done = 0;
+ int array_size;
+ struct type *follow_type = $1;
+
+ while (!done)
+ switch (pop_type ())
+ {
+ case tp_end:
+ done = 1;
+ break;
+ case tp_pointer:
+ follow_type = lookup_pointer_type (follow_type);
+ break;
+ case tp_reference:
+ follow_type = lookup_reference_type (follow_type);
+ break;
+ case tp_array:
+ array_size = pop_type_int ();
+ if (array_size != -1)
+ follow_type = create_array_type (follow_type,
+ array_size);
+ else
+ follow_type = lookup_pointer_type (follow_type);
+ break;
+ case tp_function:
+ follow_type = lookup_function_type (follow_type);
+ break;
+ }
+ $$ = follow_type;
+ }
+ ;
+
+abs_decl: '*'
+ { push_type (tp_pointer); $$ = 0; }
+ | '*' abs_decl
+ { push_type (tp_pointer); $$ = $2; }
+ | '&'
+ { push_type (tp_reference); $$ = 0; }
+ | '&' abs_decl
+ { push_type (tp_reference); $$ = $2; }
+ | direct_abs_decl
+ ;
+
+direct_abs_decl: '(' abs_decl ')'
+ { $$ = $2; }
+ | direct_abs_decl array_mod
+ {
+ push_type_int ($2);
+ push_type (tp_array);
+ }
+ | array_mod
+ {
+ push_type_int ($1);
+ push_type (tp_array);
+ $$ = 0;
+ }
+ | direct_abs_decl func_mod
+ { push_type (tp_function); }
+ | func_mod
+ { push_type (tp_function); }
+ ;
+
+array_mod: '[' ']'
+ { $$ = -1; }
+ | '[' INT ']'
+ { $$ = $2; }
+ ;
+
+func_mod: '(' ')'
+ { $$ = 0; }
+ ;
+
+type : ptype
+ | typebase COLONCOLON '*'
+ { $$ = lookup_member_type (builtin_type_int, $1); }
+ | type '(' typebase COLONCOLON '*' ')'
+ { $$ = lookup_member_type ($1, $3); }
+ | type '(' typebase COLONCOLON '*' ')' '(' ')'
+ { $$ = lookup_member_type
+ (lookup_function_type ($1), $3); }
+ | type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
+ { $$ = lookup_member_type
+ (lookup_function_type ($1), $3);
+ free ($8); }
;
typebase
: TYPENAME
- { $$ = lookup_typename (copy_name ($1),
- expression_context_block, 0); }
+ { $$ = $1.type; }
+ | INT_KEYWORD
+ { $$ = builtin_type_int; }
+ | LONG
+ { $$ = builtin_type_long; }
+ | SHORT
+ { $$ = builtin_type_short; }
+ | LONG INT_KEYWORD
+ { $$ = builtin_type_long; }
+ | UNSIGNED LONG INT_KEYWORD
+ { $$ = builtin_type_unsigned_long; }
+ | LONG LONG
+ { $$ = builtin_type_long_long; }
+ | LONG LONG INT_KEYWORD
+ { $$ = builtin_type_long_long; }
+ | UNSIGNED LONG LONG
+ { $$ = builtin_type_unsigned_long_long; }
+ | UNSIGNED LONG LONG INT_KEYWORD
+ { $$ = builtin_type_unsigned_long_long; }
+ | SHORT INT_KEYWORD
+ { $$ = builtin_type_short; }
+ | UNSIGNED SHORT INT_KEYWORD
+ { $$ = builtin_type_unsigned_short; }
| STRUCT name
{ $$ = lookup_struct (copy_name ($2),
expression_context_block); }
| ENUM name
{ $$ = lookup_enum (copy_name ($2),
expression_context_block); }
- | UNSIGNED name
- { $$ = lookup_unsigned_typename (copy_name ($2)); }
+ | UNSIGNED typename
+ { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
+ | UNSIGNED
+ { $$ = builtin_type_unsigned_int; }
+ | SIGNED typename
+ { $$ = $2.type; }
+ | SIGNED
+ { $$ = builtin_type_int; }
+ ;
+
+typename: TYPENAME
+ | INT_KEYWORD
+ {
+ $$.stoken.ptr = "int";
+ $$.stoken.length = 3;
+ $$.type = builtin_type_int;
+ }
+ | LONG
+ {
+ $$.stoken.ptr = "long";
+ $$.stoken.length = 4;
+ $$.type = builtin_type_long;
+ }
+ | SHORT
+ {
+ $$.stoken.ptr = "short";
+ $$.stoken.length = 5;
+ $$.type = builtin_type_short;
+ }
+ ;
+
+nonempty_typelist
+ : type
+ { $$ = (struct type **)xmalloc (sizeof (struct type *) * 2);
+ $$[0] = (struct type *)0;
+ $$[1] = $1;
+ }
+ | nonempty_typelist ',' type
+ { int len = sizeof (struct type *) * ++($<ivec>1[0]);
+ $$ = (struct type **)xrealloc ($1, len);
+ $$[$<ivec>$[0]] = $3;
+ }
;
-name : NAME
- | TYPENAME
+name : NAME { $$ = $1.stoken; }
+ | BLOCKNAME { $$ = $1.stoken; }
+ | TYPENAME { $$ = $1.stoken; }
+ | NAME_OR_INT { $$ = $1.stoken; }
+ | NAME_OR_UINT { $$ = $1.stoken; }
;
+
+name_not_typename : NAME
+ | BLOCKNAME
+/* These would be useful if name_not_typename was useful, but it is just
+ a fake for "variable", so these cause reduce/reduce conflicts because
+ the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
+ =exp) or just an exp. If name_not_typename was ever used in an lvalue
+ context where only a name could occur, this might be useful.
+ | NAME_OR_INT
+ | NAME_OR_UINT
+ */
+ ;
+
%%
\f
/* Begin counting arguments for a function call,
/* Add one element to the end of the expression. */
+/* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
+ a register through here */
+
static void
write_exp_elt (expelt)
union exp_element expelt;
expout->elts[expout_ptr++] = expelt;
}
+static void
+write_exp_elt_opcode (expelt)
+ enum exp_opcode expelt;
+{
+ union exp_element tmp;
+
+ tmp.opcode = expelt;
+
+ write_exp_elt (tmp);
+}
+
+static void
+write_exp_elt_sym (expelt)
+ struct symbol *expelt;
+{
+ union exp_element tmp;
+
+ tmp.symbol = expelt;
+
+ write_exp_elt (tmp);
+}
+
+static void
+write_exp_elt_longcst (expelt)
+ LONGEST expelt;
+{
+ union exp_element tmp;
+
+ tmp.longconst = expelt;
+
+ write_exp_elt (tmp);
+}
+
+static void
+write_exp_elt_dblcst (expelt)
+ double expelt;
+{
+ union exp_element tmp;
+
+ tmp.doubleconst = expelt;
+
+ write_exp_elt (tmp);
+}
+
+static void
+write_exp_elt_type (expelt)
+ struct type *expelt;
+{
+ union exp_element tmp;
+
+ tmp.type = expelt;
+
+ write_exp_elt (tmp);
+}
+
+static void
+write_exp_elt_intern (expelt)
+ struct internalvar *expelt;
+{
+ union exp_element tmp;
+
+ tmp.internalvar = expelt;
+
+ write_exp_elt (tmp);
+}
+
/* Add a string constant to the end of the expression.
Follow it by its length in bytes, as a separate exp_element. */
if (expout_ptr >= expout_size)
{
expout_size = max (expout_size * 2, expout_ptr + 10);
- expout = (struct expression *) xrealloc (expout,
- sizeof (struct expression)
- + expout_size * sizeof (union exp_element));
+ expout = (struct expression *)
+ xrealloc (expout, (sizeof (struct expression)
+ + (expout_size * sizeof (union exp_element))));
}
bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len);
((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
- write_exp_elt (len);
+ write_exp_elt_longcst ((LONGEST) len);
}
\f
/* During parsing of a C expression, the pointer to the next character
static char *namecopy;
+/* Current depth in parentheses within the expression. */
+
+static int paren_depth;
+
+/* Nonzero means stop parsing on first comma (if not within parentheses). */
+
+static int comma_terminates;
+
/* Take care of parsing a number (anything that starts with a digit).
Set yylval and return the token type; update lexptr.
LEN is the number of characters in it. */
/*** Needs some error checking for the float case ***/
static int
-parse_number (olen)
- int olen;
+parse_number (p, len, parsed_float, putithere)
+ register char *p;
+ register int len;
+ int parsed_float;
+ YYSTYPE *putithere;
{
- register char *p = lexptr;
- register long n = 0;
+ register LONGEST n = 0;
+ register int i;
register int c;
- register int base = 10;
- register int len = olen;
- char *err_copy;
+ register int base = input_radix;
+ int unsigned_p = 0;
extern double atof ();
- for (c = 0; c < len; c++)
- if (p[c] == '.')
- {
- /* It's a float since it contains a point. */
- yylval.dval = atof (p);
- lexptr += len;
- return FLOAT;
- }
-
- if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2)))
+ if (parsed_float)
{
- p += 2;
- base = 16;
- len -= 2;
+ /* It's a float since it contains a point or an exponent. */
+ putithere->dval = atof (p);
+ return FLOAT;
}
- else if (*p == '0')
- base = 8;
+
+ /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
+ if (p[0] == '0')
+ switch (p[1])
+ {
+ case 'x':
+ case 'X':
+ if (len >= 3)
+ {
+ p += 2;
+ base = 16;
+ len -= 2;
+ }
+ break;
+
+ case 't':
+ case 'T':
+ case 'd':
+ case 'D':
+ if (len >= 3)
+ {
+ p += 2;
+ base = 10;
+ len -= 2;
+ }
+ break;
+
+ default:
+ base = 8;
+ break;
+ }
while (len-- > 0)
{
c = *p++;
- n *= base;
+ if (c >= 'A' && c <= 'Z')
+ c += 'a' - 'A';
+ if (c != 'l' && c != 'u')
+ n *= base;
if (c >= '0' && c <= '9')
- n += c - '0';
+ n += i = c - '0';
else
{
- if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
- if (base == 16 && c >= 'a' && c <= 'f')
- n += c - 'a' + 10;
+ if (base > 10 && c >= 'a' && c <= 'f')
+ n += i = c - 'a' + 10;
else if (len == 0 && c == 'l')
;
+ else if (len == 0 && c == 'u')
+ unsigned_p = 1;
else
- {
- err_copy = (char *) alloca (olen + 1);
- bcopy (lexptr, err_copy, olen);
- err_copy[olen] = 0;
- error ("Invalid number \"%s\".", err_copy);
- }
+ return ERROR; /* Char not a digit */
}
+ if (i >= base)
+ return ERROR; /* Invalid digit in this base */
}
- lexptr = p;
- yylval.lval = n;
- return INT;
+ if (unsigned_p)
+ {
+ putithere->ulval = n;
+ return UINT;
+ }
+ else
+ {
+ putithere->lval = n;
+ return INT;
+ }
}
struct token
enum exp_opcode opcode;
};
-static struct token tokentab3[] =
+const static struct token tokentab3[] =
{
{">>=", ASSIGN_MODIFY, BINOP_RSH},
{"<<=", ASSIGN_MODIFY, BINOP_LSH}
};
-static struct token tokentab2[] =
+const static struct token tokentab2[] =
{
{"+=", ASSIGN_MODIFY, BINOP_ADD},
{"-=", ASSIGN_MODIFY, BINOP_SUB},
{">=", GEQ, BINOP_END}
};
+/* assign machine-independent names to certain registers
+ * (unless overridden by the REGISTER_NAMES table)
+ */
+struct std_regs {
+ char *name;
+ int regnum;
+} std_regs[] = {
+#ifdef PC_REGNUM
+ { "pc", PC_REGNUM },
+#endif
+#ifdef FP_REGNUM
+ { "fp", FP_REGNUM },
+#endif
+#ifdef SP_REGNUM
+ { "sp", SP_REGNUM },
+#endif
+#ifdef PS_REGNUM
+ { "ps", PS_REGNUM },
+#endif
+};
+
+#define NUM_STD_REGS (sizeof std_regs / sizeof std_regs[0])
+
/* Read one token, getting characters through lexptr. */
static int
{
register int c;
register int namelen;
- register int i;
+ register unsigned i;
register char *tokstart;
retry:
error ("Invalid character constant.");
return CHAR;
+ case '(':
+ paren_depth++;
+ lexptr++;
+ return c;
+
+ case ')':
+ if (paren_depth == 0)
+ return 0;
+ paren_depth--;
+ lexptr++;
+ return c;
+
+ case ',':
+ if (comma_terminates && paren_depth == 0)
+ return 0;
+ lexptr++;
+ return c;
+
+ case '.':
+ /* Might be a floating point number. */
+ if (lexptr[1] < '0' || lexptr[1] > '9')
+ goto symbol; /* Nope, must be a symbol. */
+ /* FALL THRU into number case. */
+
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ /* It's a number. */
+ int got_dot = 0, got_e = 0, toktype;
+ register char *p = tokstart;
+ int hex = input_radix > 10;
+
+ if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
+ {
+ p += 2;
+ hex = 1;
+ }
+ else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
+ {
+ p += 2;
+ hex = 0;
+ }
+
+ for (;; ++p)
+ {
+ if (!hex && !got_e && (*p == 'e' || *p == 'E'))
+ got_dot = got_e = 1;
+ else if (!hex && !got_dot && *p == '.')
+ got_dot = 1;
+ else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
+ && (*p == '-' || *p == '+'))
+ /* This is the sign of the exponent, not the end of the
+ number. */
+ continue;
+ /* We will take any letters or digits. parse_number will
+ complain if past the radix, or if L or U are not final. */
+ else if ((*p < '0' || *p > '9')
+ && ((*p < 'a' || *p > 'z')
+ && (*p < 'A' || *p > 'Z')))
+ break;
+ }
+ toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
+ if (toktype == ERROR)
+ {
+ char *err_copy = (char *) alloca (p - tokstart + 1);
+
+ bcopy (tokstart, err_copy, p - tokstart);
+ err_copy[p - tokstart] = 0;
+ error ("Invalid number \"%s\".", err_copy);
+ }
+ lexptr = p;
+ return toktype;
+ }
+
case '+':
case '-':
case '*':
case '@':
case '<':
case '>':
- case '(':
- case ')':
case '[':
case ']':
- case '.':
case '?':
case ':':
case '=':
case '{':
case '}':
- case ',':
+ symbol:
lexptr++;
return c;
lexptr += namelen + 1;
return STRING;
}
- if (c >= '0' && c <= '9')
- {
- /* It's a number */
- for (namelen = 0;
- c = tokstart[namelen],
- (c == '_' || c == '$' || c == '.' || (c >= '0' && c <= '9')
- || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
- namelen++)
- ;
- return parse_number (namelen);
- }
if (!(c == '_' || c == '$'
|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
- error ("Invalid token in expression.");
-
- /* It is a name. See how long it is. */
+ /* We must have come across a bad character (e.g. ';'). */
+ error ("Invalid character '%c' in expression.", c);
- for (namelen = 0;
- c = tokstart[namelen],
+ /* It's a name. See how long it is. */
+ namelen = 0;
+ for (c = tokstart[namelen];
(c == '_' || c == '$' || (c >= '0' && c <= '9')
|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
- namelen++)
+ c = tokstart[++namelen])
;
/* The token "if" terminates the expression and is NOT
/* Handle tokens that refer to machine registers:
$ followed by a register name. */
- if (*tokstart == '$')
+ if (*tokstart == '$') {
for (c = 0; c < NUM_REGS; c++)
if (namelen - 1 == strlen (reg_names[c])
&& !strncmp (tokstart + 1, reg_names[c], namelen - 1))
yylval.lval = c;
return REGNAME;
}
-
- if (namelen == 6 && !strncmp (tokstart, "struct", 6))
- {
- return STRUCT;
- }
- if (namelen == 5 && !strncmp (tokstart, "union", 5))
- {
- return UNION;
- }
- if (namelen == 4 && !strncmp (tokstart, "enum", 4))
- {
- return ENUM;
- }
- if (namelen == 6 && !strncmp (tokstart, "sizeof", 6))
- {
- return SIZEOF;
- }
- if (namelen == 8 && !strncmp (tokstart, "unsigned", 6))
+ for (c = 0; c < NUM_STD_REGS; c++)
+ if (namelen - 1 == strlen (std_regs[c].name)
+ && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1))
+ {
+ yylval.lval = std_regs[c].regnum;
+ return REGNAME;
+ }
+ }
+ /* Catch specific keywords. Should be done with a data structure. */
+ switch (namelen)
{
- return UNSIGNED;
+ case 8:
+ if (!strncmp (tokstart, "unsigned", 8))
+ return UNSIGNED;
+ break;
+ case 6:
+ if (!strncmp (tokstart, "struct", 6))
+ return STRUCT;
+ if (!strncmp (tokstart, "signed", 6))
+ return SIGNED;
+ if (!strncmp (tokstart, "sizeof", 6))
+ return SIZEOF;
+ break;
+ case 5:
+ if (!strncmp (tokstart, "union", 5))
+ return UNION;
+ if (!strncmp (tokstart, "short", 5))
+ return SHORT;
+ break;
+ case 4:
+ if (!strncmp (tokstart, "enum", 4))
+ return ENUM;
+ if (!strncmp (tokstart, "long", 4))
+ return LONG;
+ if (!strncmp (tokstart, "this", 4))
+ {
+ static const char this_name[] =
+ { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
+
+ if (lookup_symbol (this_name, expression_context_block,
+ VAR_NAMESPACE, 0, NULL))
+ return THIS;
+ }
+ break;
+ case 3:
+ if (!strncmp (tokstart, "int", 3))
+ return INT_KEYWORD;
+ break;
+ default:
+ break;
}
+
yylval.sval.ptr = tokstart;
yylval.sval.length = namelen;
if (*tokstart == '$')
{
- yylval.ivar = (struct internalvar *) lookup_internalvar (copy_name (yylval.sval) + 1);
+ yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
return VARIABLE;
}
- /* Use token-type TYPENAME for symbols that happen to be defined
+ /* Use token-type BLOCKNAME for symbols that happen to be defined as
+ functions or symtabs. If this is not so, then ...
+ Use token-type TYPENAME for symbols that happen to be defined
currently as names of types; NAME for other symbols.
The caller is not constrained to care about the distinction. */
- if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
- return TYPENAME;
- return NAME;
+ {
+ char *tmp = copy_name (yylval.sval);
+ struct symbol *sym;
+ int is_a_field_of_this = 0;
+ int hextype;
+
+ sym = lookup_symbol (tmp, expression_context_block,
+ VAR_NAMESPACE, &is_a_field_of_this, NULL);
+ if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
+ lookup_partial_symtab (tmp))
+ {
+ yylval.ssym.sym = sym;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this;
+ return BLOCKNAME;
+ }
+ if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ {
+ yylval.tsym.type = SYMBOL_TYPE (sym);
+ return TYPENAME;
+ }
+ if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
+ return TYPENAME;
+
+ /* Input names that aren't symbols but ARE valid hex numbers,
+ when the input radix permits them, can be names or numbers
+ depending on the parse. Note we support radixes > 16 here. */
+ if (!sym &&
+ ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
+ (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
+ {
+ YYSTYPE newlval; /* Its value is ignored. */
+ hextype = parse_number (tokstart, namelen, 0, &newlval);
+ if (hextype == INT)
+ {
+ yylval.ssym.sym = sym;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this;
+ return NAME_OR_INT;
+ }
+ if (hextype == UINT)
+ {
+ yylval.ssym.sym = sym;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this;
+ return NAME_OR_UINT;
+ }
+ }
+
+ /* Any other kind of symbol */
+ yylval.ssym.sym = sym;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this;
+ return NAME;
+ }
}
-static
-yyerror ()
+/* ARGSUSED */
+static void
+yyerror (msg)
+ char *msg;
{
error ("Invalid syntax in expression.");
}
register int args = 0;
register int i;
+ if (endpos < 0)
+ error ("?error in length_of_subexp");
+
i = (int) expr->elts[endpos - 1].opcode;
switch (i)
{
+ /* C++ */
+ case OP_SCOPE:
+ oplen = 4 + ((expr->elts[endpos - 2].longconst
+ + sizeof (union exp_element))
+ / sizeof (union exp_element));
+ break;
+
case OP_LONG:
case OP_DOUBLE:
oplen = 4;
oplen = 3 + ((expr->elts[endpos - 2].longconst
+ sizeof (union exp_element))
/ sizeof (union exp_element));
-
break;
case TERNOP_COND:
args = 2;
break;
+ /* C++ */
+ case OP_THIS:
+ oplen = 2;
+ break;
+
default:
args = 1 + (i < (int) BINOP_END);
}
opcode = inexpr->elts[inend - 1].opcode;
switch (opcode)
{
+ /* C++ */
+ case OP_SCOPE:
+ oplen = 4 + ((inexpr->elts[inend - 2].longconst
+ + sizeof (union exp_element))
+ / sizeof (union exp_element));
+ break;
+
case OP_LONG:
case OP_DOUBLE:
oplen = 4;
args = 2;
break;
+ /* C++ */
+ case OP_THIS:
+ oplen = 2;
+ break;
+
default:
args = 1 + ((int) opcode < (int) BINOP_END);
}
if BLOCK is zero, use the block of the selected stack frame.
Meanwhile, advance *STRINGPTR to point after the expression,
at the first nonwhite character that is not part of the expression
- (possibly a null character). */
+ (possibly a null character).
+
+ If COMMA is nonzero, stop if a comma is reached. */
struct expression *
-parse_c_1 (stringptr, block)
+parse_c_1 (stringptr, block, comma)
char **stringptr;
struct block *block;
+ int comma;
{
struct cleanup *old_chain;
lexptr = *stringptr;
+ paren_depth = 0;
+ type_stack_depth = 0;
+
+ comma_terminates = comma;
+
if (lexptr == 0 || *lexptr == 0)
error_no_arg ("expression to compute");
namecopy = (char *) alloca (strlen (lexptr) + 1);
expout_size = 10;
expout_ptr = 0;
- expout = (struct expression *) xmalloc (sizeof (struct expression)
- + expout_size * sizeof (union exp_element));
+ expout = (struct expression *)
+ xmalloc (sizeof (struct expression)
+ + expout_size * sizeof (union exp_element));
make_cleanup (free_current_contents, &expout);
if (yyparse ())
- yyerror ();
+ yyerror (NULL);
discard_cleanups (old_chain);
expout->nelts = expout_ptr;
expout = (struct expression *)
char *string;
{
register struct expression *exp;
- exp = parse_c_1 (&string, 0);
+ exp = parse_c_1 (&string, 0, 0);
if (*string)
error ("Junk after end of expression.");
return exp;
}
+
+static void
+push_type (tp)
+ enum type_pieces tp;
+{
+ if (type_stack_depth == type_stack_size)
+ {
+ type_stack_size *= 2;
+ type_stack = (union type_stack_elt *)
+ xrealloc (type_stack, type_stack_size * sizeof (*type_stack));
+ }
+ type_stack[type_stack_depth++].piece = tp;
+}
+
+static void
+push_type_int (n)
+ int n;
+{
+ if (type_stack_depth == type_stack_size)
+ {
+ type_stack_size *= 2;
+ type_stack = (union type_stack_elt *)
+ xrealloc (type_stack, type_stack_size * sizeof (*type_stack));
+ }
+ type_stack[type_stack_depth++].int_val = n;
+}
+
+static enum type_pieces
+pop_type ()
+{
+ if (type_stack_depth)
+ return type_stack[--type_stack_depth].piece;
+ return tp_end;
+}
+
+static int
+pop_type_int ()
+{
+ if (type_stack_depth)
+ return type_stack[--type_stack_depth].int_val;
+ /* "Can't happen". */
+ return 0;
+}
+
+void
+_initialize_expread ()
+{
+ type_stack_size = 80;
+ type_stack_depth = 0;
+ type_stack = (union type_stack_elt *)
+ xmalloc (type_stack_size * sizeof (*type_stack));
+}
projects / deliverable / binutils-gdb.git / blobdiff