#include <stdio.h>
#include <string.h>
#include "defs.h"
-#include "param.h"
#include "symtab.h"
+#include "gdbtypes.h"
#include "frame.h"
#include "expression.h"
#include "language.h"
+#include "value.h"
#include "parser-defs.h"
-
-/* These MUST be included in any grammar file!!!!
- Please choose unique names! */
+#include "bfd.h"
+#include "symfile.h"
+#include "objfiles.h"
+
+/* These MUST be included in any grammar file!!!! Please choose unique names!
+ Note that this are a combined list of variables that can be produced
+ by any one of bison, byacc, or yacc. */
+#define yymaxdepth m2_maxdepth
#define yyparse m2_parse
#define yylex m2_lex
#define yyerror m2_error
#define yypgo m2_pgo
#define yyact m2_act
#define yyexca m2_exca
+#define yyerrflag m2_errflag
+#define yynerrs m2_nerrs
+#define yyps m2_ps
+#define yypv m2_pv
+#define yys m2_s
+#define yy_yys m2_yys
+#define yystate m2_state
+#define yytmp m2_tmp
+#define yyv m2_v
+#define yy_yyv m2_yyv
+#define yyval m2_val
+#define yylloc m2_lloc
+#define yyss m2_yyss /* byacc */
+#define yyssp m2_yysp /* byacc */
+#define yyvs m2_yyvs /* byacc */
+#define yyvsp m2_yyvsp /* byacc */
+
+#if 0
+static char *
+make_qualname PARAMS ((char *, char *));
+#endif
+
+static int
+parse_number PARAMS ((int));
+
+static int
+yylex PARAMS ((void));
+
+static void
+yyerror PARAMS ((char *));
-void yyerror ();
-static int yylex ();
+int
+yyparse PARAMS ((void));
/* The sign of the number being parsed. */
int number_sign = 1;
contained in, */
struct block *modblock=0;
-char *make_qualname();
-
/* #define YYDEBUG 1 */
-
%}
/* Although the yacc "value" of an expression is not used,
%type <sym> fblock
%token <lval> INT HEX ERROR
-%token <ulval> UINT TRUE FALSE CHAR
+%token <ulval> UINT M2_TRUE M2_FALSE CHAR
%token <dval> FLOAT
/* Both NAME and TYPENAME tokens represent symbols in the input,
nonterminal "name", which matches either NAME or TYPENAME. */
%token <sval> STRING
-%token <sval> NAME BLOCKNAME IDENT CONST VARNAME
+%token <sval> NAME BLOCKNAME IDENT VARNAME
%token <sval> TYPENAME
-%token SIZE CAP ORD HIGH ABS MIN MAX FLOAT_FUNC VAL CHR ODD TRUNC
+%token SIZE CAP ORD HIGH ABS MIN_FUNC MAX_FUNC FLOAT_FUNC VAL CHR ODD TRUNC
%token INC DEC INCL EXCL
/* The GDB scope operator */
%left ABOVE_COMMA
%nonassoc ASSIGN
%left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN
-%left OR
-%left AND '&'
+%left OROR
+%left ANDAND '&'
%left '@'
%left '+' '-'
%left '*' '/' DIV MOD
/* This is not an actual token ; it is used for precedence.
%right QID
*/
+
+%{
+/* Ensure that if the generated parser contains any calls to malloc/realloc,
+ that they get mapped to xmalloc/xrealloc. We have to do this here
+ rather than earlier in the file because this is the first point after
+ the place where the SVR4 yacc includes <malloc.h>, and if we do it
+ before that, then the remapped declarations in <malloc.h> will collide
+ with the ones in "defs.h". */
+
+#define malloc xmalloc
+#define realloc xrealloc
+%}
+
%%
start : exp
{ write_exp_elt_opcode (UNOP_HIGH); }
;
-exp : MIN '(' type ')'
+exp : MIN_FUNC '(' type ')'
{ write_exp_elt_opcode (UNOP_MIN);
write_exp_elt_type ($3);
write_exp_elt_opcode (UNOP_MIN); }
;
-exp : MAX '(' type ')'
+exp : MAX_FUNC '(' type ')'
{ write_exp_elt_opcode (UNOP_MAX);
write_exp_elt_type ($3);
write_exp_elt_opcode (UNOP_MIN); }
{ write_exp_elt_opcode (BINOP_GTR); }
;
-exp : exp AND exp
+exp : exp ANDAND exp
{ write_exp_elt_opcode (BINOP_AND); }
;
{ write_exp_elt_opcode (BINOP_AND); }
;
-exp : exp OR exp
+exp : exp OROR exp
{ write_exp_elt_opcode (BINOP_OR); }
;
/* Constants */
-exp : TRUE
+exp : M2_TRUE
{ write_exp_elt_opcode (OP_BOOL);
write_exp_elt_longcst ((LONGEST) $1);
write_exp_elt_opcode (OP_BOOL); }
;
-exp : FALSE
+exp : M2_FALSE
{ write_exp_elt_opcode (OP_BOOL);
write_exp_elt_longcst ((LONGEST) $1);
write_exp_elt_opcode (OP_BOOL); }
case LOC_REGISTER:
case LOC_ARG:
case LOC_LOCAL:
+ case LOC_REF_ARG:
+ case LOC_REGPARM:
+ case LOC_LOCAL_ARG:
if (innermost_block == 0 ||
contained_in (block_found,
innermost_block))
innermost_block = block_found;
+ break;
+
+ case LOC_UNDEF:
+ case LOC_CONST:
+ case LOC_STATIC:
+ case LOC_TYPEDEF:
+ case LOC_LABEL: /* maybe should go above? */
+ case LOC_BLOCK:
+ case LOC_CONST_BYTES:
+ /* These are listed so gcc -Wall will reveal
+ un-handled cases. */
+ break;
}
write_exp_elt_opcode (OP_VAR_VALUE);
write_exp_elt_sym (sym);
}
else
{
- register int i;
+ struct minimal_symbol *msymbol;
register char *arg = copy_name ($1);
- for (i = 0; i < misc_function_count; i++)
- if (!strcmp (misc_function_vector[i].name, arg))
- break;
-
- if (i < misc_function_count)
+ msymbol = lookup_minimal_symbol (arg,
+ (struct objfile *) NULL);
+ if (msymbol != NULL)
{
- enum misc_function_type mft =
- (enum misc_function_type)
- 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_longcst ((LONGEST) msymbol -> address);
write_exp_elt_opcode (OP_LONG);
write_exp_elt_opcode (UNOP_MEMVAL);
- if (mft == mf_data || mft == mf_bss)
+ if (msymbol -> type == mst_data ||
+ msymbol -> type == mst_bss)
write_exp_elt_type (builtin_type_int);
- else if (mft == mf_text)
+ else if (msymbol -> type == mst_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)
+ else if (!have_full_symbols () && !have_partial_symbols ())
error ("No symbol table is loaded. Use the \"symbol-file\" command.");
else
error ("No symbol \"%s\" in current context.",
register int c,i,ischar=0;
register int base = input_radix;
register int len = olen;
- char *err_copy;
int unsigned_p = number_sign == 1 ? 1 : 0;
- extern double atof ();
-
if(p[len-1] == 'H')
{
base = 16;
int token;
} tokentab2[] =
{
- {"<>", NOTEQUAL },
- {":=", ASSIGN },
- {"<=", LEQ },
- {">=", GEQ },
- {"::", COLONCOLON },
+ { {'<', '>'}, NOTEQUAL },
+ { {':', '='}, ASSIGN },
+ { {'<', '='}, LEQ },
+ { {'>', '='}, GEQ },
+ { {':', ':'}, COLONCOLON },
};
static struct keyword keytab[] =
{
- {"OR" , OR },
+ {"OR" , OROR },
{"IN", IN },/* Note space after IN */
- {"AND", AND },
+ {"AND", ANDAND },
{"ABS", ABS },
{"CHR", CHR },
{"DEC", DEC },
{"NOT", NOT },
{"DIV", DIV },
{"INC", INC },
- {"MAX", MAX },
- {"MIN", MIN },
+ {"MAX", MAX_FUNC },
+ {"MIN", MIN_FUNC },
{"MOD", MOD },
{"ODD", ODD },
{"CAP", CAP },
{
char *err_copy = (char *) alloca (p - tokstart + 1);
- bcopy (tokstart, err_copy, p - tokstart);
+ memcpy (err_copy, tokstart, p - tokstart);
err_copy[p - tokstart] = 0;
error ("Invalid number \"%s\".", err_copy);
}
if(!strncmp(tokstart,"TRUE",4))
{
yylval.ulval = 1;
- return TRUE;
+ return M2_TRUE;
}
else if(!strncmp(tokstart,"FALSE",5))
{
yylval.ulval = 0;
- return FALSE;
+ return M2_FALSE;
}
}
}
}
-char *
+#if 0 /* Unused */
+static char *
make_qualname(mod,ident)
char *mod, *ident;
{
strcat(new,ident);
return new;
}
+#endif /* 0 */
-
-void
-yyerror()
+static void
+yyerror(msg)
+ char *msg; /* unused */
{
printf("Parsing: %s\n",lexptr);
if (yychar < 256)
error("Invalid syntax in expression near character '%c'.",yychar);
else
- error("Invalid syntax in expression near a '%s'.",
- yytname[yychar-255]);
+ error("Invalid syntax in expression");
}
\f
/* Table of operators and their precedences for printing expressions. */
void
_initialize_m2_exp ()
{
- /* FIXME: The code below assumes that the sizes of the basic data
- types are the same on the host and target machines!!! */
-
/* Modula-2 "pervasive" types. NOTE: these can be redefined!!! */
- builtin_type_m2_int = init_type (TYPE_CODE_INT, sizeof(int), 0, "INTEGER");
- builtin_type_m2_card = init_type (TYPE_CODE_INT, sizeof(int), 1, "CARDINAL");
- builtin_type_m2_real = init_type (TYPE_CODE_FLT, sizeof(float), 0, "REAL");
- builtin_type_m2_char = init_type (TYPE_CODE_CHAR, sizeof(char), 1, "CHAR");
+ builtin_type_m2_int =
+ init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+ 0,
+ "INTEGER", (struct objfile *) NULL);
+ builtin_type_m2_card =
+ init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+ TYPE_FLAG_UNSIGNED,
+ "CARDINAL", (struct objfile *) NULL);
+ builtin_type_m2_real =
+ init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
+ 0,
+ "REAL", (struct objfile *) NULL);
+ builtin_type_m2_char =
+ init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
+ TYPE_FLAG_UNSIGNED,
+ "CHAR", (struct objfile *) NULL);
+ builtin_type_m2_bool =
+ init_type (TYPE_CODE_BOOL, TARGET_INT_BIT / TARGET_CHAR_BIT,
+ TYPE_FLAG_UNSIGNED,
+ "BOOLEAN", (struct objfile *) NULL);
- builtin_type_m2_bool = init_type (TYPE_CODE_BOOL, sizeof(int), 1, "BOOLEAN");
TYPE_NFIELDS(builtin_type_m2_bool) = 2;
TYPE_FIELDS(builtin_type_m2_bool) =
(struct field *) malloc (sizeof (struct field) * 2);
projects / deliverable / binutils-gdb.git / blobdiff