X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fm2-exp.y;h=bbbdda48f7786253fd05ea7a0dd129cc4daaab9e;hb=52e895cbb4ca54301e9bd239967f7f42407eeea4;hp=2274b1613d75d6746bbf59ec52cc93efe2269c64;hpb=4a11eef2ebf99f527ee5452386a5f2a099ed6b8b;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y index 2274b1613d..bbbdda48f7 100644 --- a/gdb/m2-exp.y +++ b/gdb/m2-exp.y @@ -1,5 +1,6 @@ /* YACC grammar for Modula-2 expressions, for GDB. - Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc. + Copyright (C) 1986, 1989, 1990, 1991, 1993, 1994 + Free Software Foundation, Inc. Generated from expread.y (now c-exp.y) and contributed by the Department of Computer Science at the State University of New York at Buffalo, 1991. @@ -26,31 +27,36 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ See expression.h for the details of the format. What is important here is that it can be built up sequentially during the process of parsing; the lower levels of the tree always - come first in the result. */ + come first in the result. + + Note that malloc's and realloc's in this file are transformed to + xmalloc and xrealloc respectively by the same sed command in the + makefile that remaps any other malloc/realloc inserted by the parser + generator. Doing this with #defines and trying to control the interaction + with include files ( and for example) just became + too messy, particularly when such includes can be inserted at random + times by the parser generator. */ %{ -#include -#include + #include "defs.h" -#include "symtab.h" -#include "gdbtypes.h" -#include "frame.h" +#include #include "expression.h" #include "language.h" #include "value.h" #include "parser-defs.h" -#include "bfd.h" -#include "symfile.h" -#include "objfiles.h" +#include "m2-lang.h" +#include "bfd.h" /* Required by objfiles.h. */ +#include "symfile.h" /* Required by objfiles.h. */ +#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ + +/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), + as well as gratuitiously global symbol names, so we can have multiple + yacc generated parsers in gdb. Note that 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. */ -/* Ensure that if the generated parser contains any calls to malloc/realloc, - that they get mapped to xmalloc/xrealloc. */ - -#define malloc xmalloc -#define realloc xrealloc - -/* These MUST be included in any grammar file!!!! - Please choose unique names! */ #define yymaxdepth m2_maxdepth #define yyparse m2_parse #define yylex m2_lex @@ -66,8 +72,8 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #define yypgo m2_pgo #define yyact m2_act #define yyexca m2_exca -#define yyerrflag m2_errflag -#define yynerrs m2_nerrs +#define yyerrflag m2_errflag +#define yynerrs m2_nerrs #define yyps m2_ps #define yypv m2_pv #define yys m2_s @@ -78,32 +84,38 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #define yy_yyv m2_yyv #define yyval m2_val #define yylloc m2_lloc +#define yyreds m2_reds /* With YYDEBUG defined */ +#define yytoks m2_toks /* With YYDEBUG defined */ -#if 0 -static char * -make_qualname PARAMS ((char *, char *)); +#ifndef YYDEBUG +#define YYDEBUG 0 /* Default to no yydebug support */ #endif -static int -parse_number PARAMS ((int)); +int +yyparse PARAMS ((void)); static int yylex PARAMS ((void)); -static void +void yyerror PARAMS ((char *)); -int -yyparse PARAMS ((void)); +#if 0 +static char * +make_qualname PARAMS ((char *, char *)); +#endif + +static int +parse_number PARAMS ((int)); /* The sign of the number being parsed. */ -int number_sign = 1; +static int number_sign = 1; /* The block that the module specified by the qualifer on an identifer is contained in, */ -struct block *modblock=0; - -/* #define YYDEBUG 1 */ +#if 0 +static struct block *modblock=0; +#endif %} @@ -135,7 +147,7 @@ struct block *modblock=0; %type fblock %token INT HEX ERROR -%token UINT TRUE FALSE CHAR +%token UINT M2_TRUE M2_FALSE CHAR %token FLOAT /* Both NAME and TYPENAME tokens represent symbols in the input, @@ -167,7 +179,7 @@ struct block *modblock=0; %nonassoc ASSIGN %left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN %left OROR -%left ANDAND '&' +%left LOGICAL_AND '&' %left '@' %left '+' '-' %left '*' '/' DIV MOD @@ -178,6 +190,8 @@ struct block *modblock=0; /* This is not an actual token ; it is used for precedence. %right QID */ + + %% start : exp @@ -208,7 +222,7 @@ exp : '+' exp %prec UNARY ; exp : not_exp exp %prec UNARY - { write_exp_elt_opcode (UNOP_ZEROP); } + { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } ; not_exp : NOT @@ -324,9 +338,9 @@ exp : exp '[' function types */ { start_arglist(); } non_empty_arglist ']' %prec DOT - { write_exp_elt_opcode (BINOP_MULTI_SUBSCRIPT); + { write_exp_elt_opcode (MULTI_SUBSCRIPT); write_exp_elt_longcst ((LONGEST) end_arglist()); - write_exp_elt_opcode (BINOP_MULTI_SUBSCRIPT); } + write_exp_elt_opcode (MULTI_SUBSCRIPT); } ; exp : exp '(' @@ -435,16 +449,12 @@ exp : exp '>' exp { write_exp_elt_opcode (BINOP_GTR); } ; -exp : exp ANDAND exp - { write_exp_elt_opcode (BINOP_AND); } - ; - -exp : exp '&' exp - { write_exp_elt_opcode (BINOP_AND); } +exp : exp LOGICAL_AND exp + { write_exp_elt_opcode (BINOP_LOGICAL_AND); } ; exp : exp OROR exp - { write_exp_elt_opcode (BINOP_OR); } + { write_exp_elt_opcode (BINOP_LOGICAL_OR); } ; exp : exp ASSIGN exp @@ -454,13 +464,13 @@ exp : exp ASSIGN exp /* 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); } @@ -554,6 +564,7 @@ fblock : block COLONCOLON BLOCKNAME /* Useful for assigning to PROCEDURE variables */ variable: fblock { write_exp_elt_opcode(OP_VAR_VALUE); + write_exp_elt_block (NULL); write_exp_elt_sym ($1); write_exp_elt_opcode (OP_VAR_VALUE); } ; @@ -575,6 +586,8 @@ variable: block COLONCOLON NAME copy_name ($3)); write_exp_elt_opcode (OP_VAR_VALUE); + /* block_found is set by lookup_symbol. */ + write_exp_elt_block (block_found); write_exp_elt_sym (sym); write_exp_elt_opcode (OP_VAR_VALUE); } ; @@ -591,32 +604,19 @@ variable: NAME NULL); if (sym) { - switch (sym->class) + if (symbol_read_needs_frame (sym)) { - 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, + 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); + /* 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_sym (sym); write_exp_elt_opcode (OP_VAR_VALUE); } @@ -625,23 +625,13 @@ variable: NAME struct minimal_symbol *msymbol; register char *arg = copy_name ($1); - msymbol = lookup_minimal_symbol (arg, - (struct objfile *) NULL); + msymbol = lookup_minimal_symbol (arg, NULL); if (msymbol != NULL) { - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (builtin_type_int); - write_exp_elt_longcst ((LONGEST) msymbol -> address); - write_exp_elt_opcode (OP_LONG); - write_exp_elt_opcode (UNOP_MEMVAL); - if (msymbol -> type == mst_data || - msymbol -> type == mst_bss) - write_exp_elt_type (builtin_type_int); - 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); + write_exp_msymbol + (msymbol, + lookup_function_type (builtin_type_int), + builtin_type_int); } else if (!have_full_symbols () && !have_partial_symbols ()) error ("No symbol table is loaded. Use the \"symbol-file\" command."); @@ -785,11 +775,11 @@ static struct int token; } tokentab2[] = { - {"<>", NOTEQUAL }, - {":=", ASSIGN }, - {"<=", LEQ }, - {">=", GEQ }, - {"::", COLONCOLON }, + { {'<', '>'}, NOTEQUAL }, + { {':', '='}, ASSIGN }, + { {'<', '='}, LEQ }, + { {'>', '='}, GEQ }, + { {':', ':'}, COLONCOLON }, }; @@ -804,7 +794,7 @@ static struct keyword keytab[] = { {"OR" , OROR }, {"IN", IN },/* Note space after IN */ - {"AND", ANDAND }, + {"AND", LOGICAL_AND}, {"ABS", ABS }, {"CHR", CHR }, {"DEC", DEC }, @@ -848,7 +838,7 @@ yylex () /* See if it is a special token of length 2 */ for( i = 0 ; i < sizeof tokentab2 / sizeof tokentab2[0] ; i++) - if(!strncmp(tokentab2[i].name, tokstart, 2)) + if(STREQN(tokentab2[i].name, tokstart, 2)) { lexptr += 2; return tokentab2[i].token; @@ -973,7 +963,7 @@ yylex () { 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); } @@ -1043,14 +1033,14 @@ yylex () if (*tokstart == '$') { for (c = 0; c < NUM_REGS; c++) if (namelen - 1 == strlen (reg_names[c]) - && !strncmp (tokstart + 1, reg_names[c], namelen - 1)) + && STREQN (tokstart + 1, reg_names[c], namelen - 1)) { yylval.lval = c; return REGNAME; } 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)) + && STREQN (tokstart + 1, std_regs[c].name, namelen - 1)) { yylval.lval = std_regs[c].regnum; return REGNAME; @@ -1060,7 +1050,7 @@ yylex () /* Lookup special keywords */ for(i = 0 ; i < sizeof(keytab) / sizeof(keytab[0]) ; i++) - if(namelen == strlen(keytab[i].keyw) && !strncmp(tokstart,keytab[i].keyw,namelen)) + if(namelen == strlen(keytab[i].keyw) && STREQN(tokstart,keytab[i].keyw,namelen)) return keytab[i].token; yylval.sval.ptr = tokstart; @@ -1104,10 +1094,14 @@ yylex () case LOC_ARG: case LOC_REF_ARG: case LOC_REGPARM: + case LOC_REGPARM_ADDR: case LOC_LOCAL: case LOC_LOCAL_ARG: + case LOC_BASEREG: + case LOC_BASEREG_ARG: case LOC_CONST: case LOC_CONST_BYTES: + case LOC_OPTIMIZED_OUT: return NAME; case LOC_TYPEDEF: @@ -1126,15 +1120,15 @@ yylex () else { /* Built-in BOOLEAN type. This is sort of a hack. */ - if(!strncmp(tokstart,"TRUE",4)) + if(STREQN(tokstart,"TRUE",4)) { yylval.ulval = 1; - return TRUE; + return M2_TRUE; } - else if(!strncmp(tokstart,"FALSE",5)) + else if(STREQN(tokstart,"FALSE",5)) { yylval.ulval = 0; - return FALSE; + return M2_FALSE; } } @@ -1148,7 +1142,7 @@ static char * make_qualname(mod,ident) char *mod, *ident; { - char *new = xmalloc(strlen(mod)+strlen(ident)+2); + char *new = malloc(strlen(mod)+strlen(ident)+2); strcpy(new,mod); strcat(new,"."); @@ -1157,113 +1151,9 @@ make_qualname(mod,ident) } #endif /* 0 */ -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"); -} - -/* Table of operators and their precedences for printing expressions. */ - -const static struct op_print m2_op_print_tab[] = { - {"+", BINOP_ADD, PREC_ADD, 0}, - {"+", UNOP_PLUS, PREC_PREFIX, 0}, - {"-", BINOP_SUB, PREC_ADD, 0}, - {"-", UNOP_NEG, PREC_PREFIX, 0}, - {"*", BINOP_MUL, PREC_MUL, 0}, - {"/", BINOP_DIV, PREC_MUL, 0}, - {"DIV", BINOP_INTDIV, PREC_MUL, 0}, - {"MOD", BINOP_REM, PREC_MUL, 0}, - {":=", BINOP_ASSIGN, PREC_ASSIGN, 1}, - {"OR", BINOP_OR, PREC_OR, 0}, - {"AND", BINOP_AND, PREC_AND, 0}, - {"NOT", UNOP_ZEROP, PREC_PREFIX, 0}, - {"=", BINOP_EQUAL, PREC_EQUAL, 0}, - {"<>", BINOP_NOTEQUAL, PREC_EQUAL, 0}, - {"<=", BINOP_LEQ, PREC_ORDER, 0}, - {">=", BINOP_GEQ, PREC_ORDER, 0}, - {">", BINOP_GTR, PREC_ORDER, 0}, - {"<", BINOP_LESS, PREC_ORDER, 0}, - {"^", UNOP_IND, PREC_PREFIX, 0}, - {"@", BINOP_REPEAT, PREC_REPEAT, 0}, -}; - -/* The built-in types of Modula-2. */ - -struct type *builtin_type_m2_char; -struct type *builtin_type_m2_int; -struct type *builtin_type_m2_card; -struct type *builtin_type_m2_real; -struct type *builtin_type_m2_bool; - -struct type ** const (m2_builtin_types[]) = -{ - &builtin_type_m2_char, - &builtin_type_m2_int, - &builtin_type_m2_card, - &builtin_type_m2_real, - &builtin_type_m2_bool, - 0 -}; - -const struct language_defn m2_language_defn = { - "modula-2", - language_m2, - m2_builtin_types, - range_check_on, - type_check_on, - m2_parse, /* parser */ - m2_error, /* parser error function */ - &builtin_type_m2_int, /* longest signed integral type */ - &builtin_type_m2_card, /* longest unsigned integral type */ - &builtin_type_m2_real, /* longest floating point type */ - "0%XH", "0%", "XH", /* Hex format string, prefix, suffix */ - "%oB", "%", "oB", /* Octal format string, prefix, suffix */ - m2_op_print_tab, /* expression operators for printing */ - LANG_MAGIC -}; - -/* Initialization for Modula-2 */ - void -_initialize_m2_exp () +yyerror (msg) + char *msg; { - /* Modula-2 "pervasive" types. NOTE: these can be redefined!!! */ - builtin_type_m2_int = - init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_FUND_TYPE, - "INTEGER", (struct objfile *) NULL); - builtin_type_m2_card = - init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED, - "CARDINAL", (struct objfile *) NULL); - builtin_type_m2_real = - init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_FUND_TYPE, - "REAL", (struct objfile *) NULL); - builtin_type_m2_char = - init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED, - "CHAR", (struct objfile *) NULL); - builtin_type_m2_bool = - init_type (TYPE_CODE_BOOL, TARGET_INT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED, - "BOOLEAN", (struct objfile *) NULL); - - TYPE_NFIELDS(builtin_type_m2_bool) = 2; - TYPE_FIELDS(builtin_type_m2_bool) = - (struct field *) malloc (sizeof (struct field) * 2); - TYPE_FIELD_BITPOS(builtin_type_m2_bool,0) = 0; - TYPE_FIELD_NAME(builtin_type_m2_bool,0) = (char *)malloc(6); - strcpy(TYPE_FIELD_NAME(builtin_type_m2_bool,0),"FALSE"); - TYPE_FIELD_BITPOS(builtin_type_m2_bool,1) = 1; - TYPE_FIELD_NAME(builtin_type_m2_bool,1) = (char *)malloc(5); - strcpy(TYPE_FIELD_NAME(builtin_type_m2_bool,1),"TRUE"); - - add_language (&m2_language_defn); + error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr); }