X-Git-Url: https://repo.jachan.dev/binutils.git/blobdiff_plain/f24adda313333714038bec83180443ffb4726786..838a1ac1a588c7460be9ef78b5ec43089c23c323:/gdb/c-exp.y diff --git a/gdb/c-exp.y b/gdb/c-exp.y index c7cf672c8a..654bf75c35 100644 --- a/gdb/c-exp.y +++ b/gdb/c-exp.y @@ -24,23 +24,33 @@ 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 "param.h" -#include "symtab.h" -#include "frame.h" #include "expression.h" #include "parser-defs.h" #include "value.h" #include "language.h" +#include "c-lang.h" -/* These MUST be included in any grammar file!!!! - Please choose unique names! */ +/* 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. */ + +#define yymaxdepth c_maxdepth #define yyparse c_parse #define yylex c_lex #define yyerror c_error @@ -55,13 +65,33 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #define yypgo c_pgo #define yyact c_act #define yyexca c_exca +#define yyerrflag c_errflag +#define yynerrs c_nerrs +#define yyps c_ps +#define yypv c_pv +#define yys c_s +#define yy_yys c_yys +#define yystate c_state +#define yytmp c_tmp +#define yyv c_v +#define yy_yyv c_yyv +#define yyval c_val +#define yylloc c_lloc +#define yyreds c_reds /* With YYDEBUG defined */ +#define yytoks c_toks /* With YYDEBUG defined */ + +#ifndef YYDEBUG +#define YYDEBUG 0 /* Default to no yydebug support */ +#endif -/* Forward decls */ -void yyerror (); -static int parse_number (); -int yyparse (); +int +yyparse PARAMS ((void)); -/* #define YYDEBUG 1 */ +static int +yylex PARAMS ((void)); + +void +yyerror PARAMS ((char *)); %} @@ -72,7 +102,10 @@ int yyparse (); %union { LONGEST lval; - unsigned LONGEST ulval; + struct { + LONGEST val; + struct type *type; + } typed_val; double dval; struct symbol *sym; struct type *tval; @@ -88,7 +121,14 @@ int yyparse (); int *ivec; } -%type exp exp1 type_exp start variable +%{ +/* YYSTYPE gets defined by %union */ +static int +parse_number PARAMS ((char *, int, int, YYSTYPE *)); +%} + +%type exp exp1 type_exp start variable qualified_name lcurly +%type rcurly %type type typebase %type nonempty_typelist /* %type block */ @@ -98,8 +138,7 @@ int yyparse (); %type ptype %type array_mod -%token INT CHAR -%token UINT +%token INT %token FLOAT /* Both NAME and TYPENAME tokens represent symbols in the input, @@ -120,17 +159,17 @@ int yyparse (); /* 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. */ + turned into a name or into a number. */ -%token NAME_OR_INT NAME_OR_UINT +%token NAME_OR_INT -%token STRUCT UNION ENUM SIZEOF UNSIGNED COLONCOLON +%token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON +%token TEMPLATE %token ERROR /* Special type cases, put in to allow the parser to distinguish different legal basetypes. */ -%token SIGNED LONG SHORT INT_KEYWORD - +%token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD %token LAST REGNAME %token VARIABLE @@ -144,8 +183,8 @@ int yyparse (); %left ABOVE_COMMA %right '=' ASSIGN_MODIFY %right '?' -%left OR -%left AND +%left OROR +%left ANDAND %left '|' %left '^' %left '&' @@ -160,6 +199,7 @@ int yyparse (); %token BLOCKNAME %type block %left COLONCOLON + %% @@ -191,11 +231,11 @@ exp : '-' exp %prec UNARY ; exp : '!' exp %prec UNARY - { write_exp_elt_opcode (UNOP_ZEROP); } + { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } ; exp : '~' exp %prec UNARY - { write_exp_elt_opcode (UNOP_LOGNOT); } + { write_exp_elt_opcode (UNOP_COMPLEMENT); } ; exp : INCREMENT exp %prec UNARY @@ -224,6 +264,13 @@ exp : exp ARROW name write_exp_elt_opcode (STRUCTOP_PTR); } ; +exp : exp ARROW qualified_name + { /* exp->type::name becomes exp->*(&type::name) */ + /* Note: this doesn't work if name is a + static member! FIXME */ + write_exp_elt_opcode (UNOP_ADDR); + write_exp_elt_opcode (STRUCTOP_MPTR); } + ; exp : exp ARROW '*' exp { write_exp_elt_opcode (STRUCTOP_MPTR); } ; @@ -234,6 +281,14 @@ exp : exp '.' name write_exp_elt_opcode (STRUCTOP_STRUCT); } ; +exp : exp '.' qualified_name + { /* exp.type::name becomes exp.*(&type::name) */ + /* Note: this doesn't work if name is a + static member! FIXME */ + write_exp_elt_opcode (UNOP_ADDR); + write_exp_elt_opcode (STRUCTOP_MEMBER); } + ; + exp : exp '.' '*' exp { write_exp_elt_opcode (STRUCTOP_MEMBER); } ; @@ -252,6 +307,10 @@ exp : exp '(' write_exp_elt_opcode (OP_FUNCALL); } ; +lcurly : '{' + { start_arglist (); } + ; + arglist : ; @@ -263,7 +322,17 @@ arglist : arglist ',' exp %prec ABOVE_COMMA { arglist_len++; } ; -exp : '{' type '}' exp %prec UNARY +rcurly : '}' + { $$ = end_arglist () - 1; } + ; +exp : lcurly arglist rcurly %prec ARROW + { write_exp_elt_opcode (OP_ARRAY); + write_exp_elt_longcst ((LONGEST) 0); + write_exp_elt_longcst ((LONGEST) $3); + write_exp_elt_opcode (OP_ARRAY); } + ; + +exp : lcurly type rcurly exp %prec UNARY { write_exp_elt_opcode (UNOP_MEMVAL); write_exp_elt_type ($2); write_exp_elt_opcode (UNOP_MEMVAL); } @@ -338,23 +407,23 @@ exp : exp '>' exp ; exp : exp '&' exp - { write_exp_elt_opcode (BINOP_LOGAND); } + { write_exp_elt_opcode (BINOP_BITWISE_AND); } ; exp : exp '^' exp - { write_exp_elt_opcode (BINOP_LOGXOR); } + { write_exp_elt_opcode (BINOP_BITWISE_XOR); } ; exp : exp '|' exp - { write_exp_elt_opcode (BINOP_LOGIOR); } + { write_exp_elt_opcode (BINOP_BITWISE_IOR); } ; -exp : exp AND exp - { write_exp_elt_opcode (BINOP_AND); } +exp : exp ANDAND exp + { write_exp_elt_opcode (BINOP_LOGICAL_AND); } ; -exp : exp OR exp - { write_exp_elt_opcode (BINOP_OR); } +exp : exp OROR exp + { write_exp_elt_opcode (BINOP_LOGICAL_OR); } ; exp : exp '?' exp ':' exp %prec '?' @@ -373,11 +442,8 @@ exp : exp ASSIGN_MODIFY exp exp : INT { 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_type ($1.type); + write_exp_elt_longcst ((LONGEST)($1.val)); write_exp_elt_opcode (OP_LONG); } ; @@ -385,46 +451,12 @@ 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_type (val.typed_val.type); + write_exp_elt_longcst ((LONGEST)val.typed_val.val); write_exp_elt_opcode (OP_LONG); } ; -exp : CHAR - { 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_opcode (OP_DOUBLE); @@ -462,9 +494,27 @@ exp : SIZEOF '(' type ')' %prec UNARY ; exp : STRING - { write_exp_elt_opcode (OP_STRING); - write_exp_string ($1); - write_exp_elt_opcode (OP_STRING); } + { /* C strings are converted into array constants with + an explicit null byte added at the end. Thus + the array upper bound is the string length. + There is no such thing in C as a completely empty + string. */ + char *sp = $1.ptr; int count = $1.length; + while (count-- > 0) + { + write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_char); + write_exp_elt_longcst ((LONGEST)(*sp++)); + write_exp_elt_opcode (OP_LONG); + } + write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_char); + write_exp_elt_longcst ((LONGEST)'\0'); + write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (OP_ARRAY); + write_exp_elt_longcst ((LONGEST) 0); + write_exp_elt_longcst ((LONGEST) ($1.length)); + write_exp_elt_opcode (OP_ARRAY); } ; /* C++. */ @@ -516,7 +566,7 @@ variable: block COLONCOLON name write_exp_elt_opcode (OP_VAR_VALUE); } ; -variable: typebase COLONCOLON name +qualified_name: typebase COLONCOLON name { struct type *type = $1; if (TYPE_CODE (type) != TYPE_CODE_STRUCT @@ -532,26 +582,34 @@ variable: typebase COLONCOLON name | typebase COLONCOLON '~' name { struct type *type = $1; + struct stoken tmp_token; 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)) + if (!STREQ (type_name_no_tag (type), $4.ptr)) error ("invalid destructor `%s::~%s'", type_name_no_tag (type), $4.ptr); + tmp_token.ptr = (char*) alloca ($4.length + 2); + tmp_token.length = $4.length + 1; + tmp_token.ptr[0] = '~'; + memcpy (tmp_token.ptr+1, $4.ptr, $4.length); + tmp_token.ptr[tmp_token.length] = 0; write_exp_elt_opcode (OP_SCOPE); write_exp_elt_type (type); - write_exp_string ($4); + write_exp_string (tmp_token); write_exp_elt_opcode (OP_SCOPE); - write_exp_elt_opcode (UNOP_LOGNOT); } + ; + +variable: qualified_name | COLONCOLON name { char *name = copy_name ($2); struct symbol *sym; - int i; + struct minimal_symbol *msymbol; sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL); @@ -562,31 +620,27 @@ variable: typebase COLONCOLON name 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) + msymbol = lookup_minimal_symbol (name, + (struct objfile *) NULL); + if (msymbol != NULL) { - 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_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol)); 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) + if (!have_full_symbols () && !have_partial_symbols ()) error ("No symbol table is loaded. Use the \"file\" command."); else error ("No symbol \"%s\" in current context.", name); @@ -598,7 +652,7 @@ variable: name_not_typename if (sym) { - switch (sym->class) + switch (SYMBOL_CLASS (sym)) { case LOC_REGISTER: case LOC_ARG: @@ -617,6 +671,7 @@ variable: name_not_typename case LOC_LABEL: case LOC_BLOCK: case LOC_CONST_BYTES: + case LOC_OPTIMIZED_OUT: /* In this case the expression can be evaluated regardless of what @@ -649,35 +704,28 @@ variable: name_not_typename } else { - register int i; + struct minimal_symbol *msymbol; 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) + msymbol = lookup_minimal_symbol (arg, + (struct objfile *) NULL); + if (msymbol != NULL) { - 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_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol)); 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 \"file\" command."); else error ("No symbol \"%s\" in current context.", @@ -694,6 +742,7 @@ ptype : typebase int done = 0; int array_size; struct type *follow_type = $1; + struct type *range_type; while (!done) switch (pop_type ()) @@ -710,8 +759,15 @@ ptype : typebase case tp_array: array_size = pop_type_int (); if (array_size != -1) - follow_type = create_array_type (follow_type, - array_size); + { + range_type = + create_range_type ((struct type *) NULL, + builtin_type_int, 0, + array_size - 1); + follow_type = + create_array_type ((struct type *) NULL, + follow_type, range_type); + } else follow_type = lookup_pointer_type (follow_type); break; @@ -756,11 +812,13 @@ direct_abs_decl: '(' abs_decl ')' array_mod: '[' ']' { $$ = -1; } | '[' INT ']' - { $$ = $2; } + { $$ = $2.val; } ; func_mod: '(' ')' { $$ = 0; } + | '(' nonempty_typelist ')' + { free ((PTR)$2); $$ = 0; } ; type : ptype @@ -774,10 +832,10 @@ type : ptype | type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')' { $$ = lookup_member_type (lookup_function_type ($1), $3); - free ($8); } + free ((PTR)$8); } ; -typebase +typebase /* Implements (approximately): (type-qualifier)* type-specifier */ : TYPENAME { $$ = $1.type; } | INT_KEYWORD @@ -805,6 +863,9 @@ typebase | STRUCT name { $$ = lookup_struct (copy_name ($2), expression_context_block); } + | CLASS name + { $$ = lookup_struct (copy_name ($2), + expression_context_block); } | UNION name { $$ = lookup_union (copy_name ($2), expression_context_block); } @@ -815,10 +876,17 @@ typebase { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); } | UNSIGNED { $$ = builtin_type_unsigned_int; } - | SIGNED typename - { $$ = $2.type; } - | SIGNED + | SIGNED_KEYWORD typename + { $$ = lookup_signed_typename (TYPE_NAME($2.type)); } + | SIGNED_KEYWORD { $$ = builtin_type_int; } + | TEMPLATE name '<' type '>' + { $$ = lookup_template_type(copy_name($2), $4, + expression_context_block); + } + /* "const" and "volatile" are curently ignored. */ + | CONST_KEYWORD typebase { $$ = $2; } + | VOLATILE_KEYWORD typebase { $$ = $2; } ; typename: TYPENAME @@ -844,13 +912,13 @@ typename: TYPENAME nonempty_typelist : type - { $$ = (struct type **)xmalloc (sizeof (struct type *) * 2); - $$[0] = (struct type *)0; + { $$ = (struct type **) malloc (sizeof (struct type *) * 2); + $$[0] = 1; /* Number of types in vector */ $$[1] = $1; } | nonempty_typelist ',' type - { int len = sizeof (struct type *) * ++($1[0]); - $$ = (struct type **)xrealloc ($1, len); + { int len = sizeof (struct type *) * (++($1[0]) + 1); + $$ = (struct type **) realloc ((char *) $1, len); $$[$$[0]] = $3; } ; @@ -859,7 +927,6 @@ name : NAME { $$ = $1.stoken; } | BLOCKNAME { $$ = $1.stoken; } | TYPENAME { $$ = $1.stoken; } | NAME_OR_INT { $$ = $1.stoken; } - | NAME_OR_UINT { $$ = $1.stoken; } ; name_not_typename : NAME @@ -870,7 +937,6 @@ name_not_typename : NAME =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 */ ; @@ -895,8 +961,10 @@ parse_number (p, len, parsed_float, putithere) register int c; register int base = input_radix; int unsigned_p = 0; - - extern double atof (); + int long_p = 0; + unsigned LONGEST high_bit; + struct type *signed_type; + struct type *unsigned_type; if (parsed_float) { @@ -949,8 +1017,8 @@ parse_number (p, len, parsed_float, putithere) { if (base > 10 && c >= 'a' && c <= 'f') n += i = c - 'a' + 10; - else if (len == 0 && c == 'l') - ; + else if (len == 0 && c == 'l') + long_p = 1; else if (len == 0 && c == 'u') unsigned_p = 1; else @@ -958,10 +1026,12 @@ parse_number (p, len, parsed_float, putithere) } if (i >= base) return ERROR; /* Invalid digit in this base */ - if(!unsigned_p && (prevn >= n)) + + /* Portably test for overflow (only works for nonzero values, so make + a second check for zero). */ + if((prevn >= n) && n != 0) unsigned_p=1; /* Try something unsigned */ - /* Don't do the range check if n==i and i==0, since that special - case will give an overflow error. */ + /* If range checking enabled, portably test for unsigned overflow. */ if(RANGE_CHECK && n!=0) { if((unsigned_p && (unsigned)prevn >= (unsigned)n)) @@ -969,17 +1039,49 @@ parse_number (p, len, parsed_float, putithere) } prevn=n; } - - if (unsigned_p) - { - putithere->ulval = n; - return UINT; - } - else - { - putithere->lval = n; - return INT; - } + + /* If the number is too big to be an int, or it's got an l suffix + then it's a long. Work out if this has to be a long by + shifting right and and seeing if anything remains, and the + target int size is different to the target long size. + + In the expression below, we could have tested + (n >> TARGET_INT_BIT) + to see if it was zero, + but too many compilers warn about that, when ints and longs + are the same size. So we shift it twice, with fewer bits + each time, for the same result. */ + + if ( (TARGET_INT_BIT != TARGET_LONG_BIT + && ((n >> 2) >> (TARGET_INT_BIT-2))) /* Avoid shift warning */ + || long_p) + { + high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1); + unsigned_type = builtin_type_unsigned_long; + signed_type = builtin_type_long; + } + else + { + high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1); + unsigned_type = builtin_type_unsigned_int; + signed_type = builtin_type_int; + } + + putithere->typed_val.val = n; + + /* If the high bit of the worked out type is set then this number + has to be unsigned. */ + + if (unsigned_p || (n & high_bit)) + { + putithere->typed_val.type = unsigned_type; + } + else + { + putithere->typed_val.type = signed_type; + } + + return INT; } struct token @@ -989,27 +1091,27 @@ struct token enum exp_opcode opcode; }; -const static struct token tokentab3[] = +static const struct token tokentab3[] = { {">>=", ASSIGN_MODIFY, BINOP_RSH}, {"<<=", ASSIGN_MODIFY, BINOP_LSH} }; -const static struct token tokentab2[] = +static const struct token tokentab2[] = { {"+=", ASSIGN_MODIFY, BINOP_ADD}, {"-=", ASSIGN_MODIFY, BINOP_SUB}, {"*=", ASSIGN_MODIFY, BINOP_MUL}, {"/=", ASSIGN_MODIFY, BINOP_DIV}, {"%=", ASSIGN_MODIFY, BINOP_REM}, - {"|=", ASSIGN_MODIFY, BINOP_LOGIOR}, - {"&=", ASSIGN_MODIFY, BINOP_LOGAND}, - {"^=", ASSIGN_MODIFY, BINOP_LOGXOR}, + {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR}, + {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND}, + {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR}, {"++", INCREMENT, BINOP_END}, {"--", DECREMENT, BINOP_END}, {"->", ARROW, BINOP_END}, - {"&&", AND, BINOP_END}, - {"||", OR, BINOP_END}, + {"&&", ANDAND, BINOP_END}, + {"||", OROR, BINOP_END}, {"::", COLONCOLON, BINOP_END}, {"<<", LSH, BINOP_END}, {">>", RSH, BINOP_END}, @@ -1021,20 +1123,24 @@ const static struct token tokentab2[] = /* Read one token, getting characters through lexptr. */ -int +static int yylex () { - register int c; - register int namelen; - register unsigned i; - register char *tokstart; - + int c; + int namelen; + unsigned int i; + char *tokstart; + char *tokptr; + int tempbufindex; + static char *tempbuf; + static int tempbufsize; + retry: tokstart = lexptr; /* See if it is a special token of length 3. */ for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++) - if (!strncmp (tokstart, tokentab3[i].operator, 3)) + if (STREQN (tokstart, tokentab3[i].operator, 3)) { lexptr += 3; yylval.opcode = tokentab3[i].opcode; @@ -1043,7 +1149,7 @@ yylex () /* See if it is a special token of length 2. */ for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++) - if (!strncmp (tokstart, tokentab2[i].operator, 2)) + if (STREQN (tokstart, tokentab2[i].operator, 2)) { lexptr += 2; yylval.opcode = tokentab2[i].opcode; @@ -1062,15 +1168,31 @@ yylex () goto retry; case '\'': + /* We either have a character constant ('0' or '\177' for example) + or we have a quoted symbol reference ('foo(int,int)' in C++ + for example). */ lexptr++; c = *lexptr++; if (c == '\\') c = parse_escape (&lexptr); - yylval.lval = c; + + yylval.typed_val.val = c; + yylval.typed_val.type = builtin_type_char; + c = *lexptr++; if (c != '\'') - error ("Invalid character constant."); - return CHAR; + { + namelen = skip_quoted (tokstart) - tokstart; + if (namelen > 2) + { + lexptr = tokstart + namelen; + namelen -= 2; + tokstart++; + goto tryname; + } + error ("Invalid character constant."); + } + return INT; case '(': paren_depth++; @@ -1146,7 +1268,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); } @@ -1179,21 +1301,55 @@ yylex () return c; case '"': - for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++) - if (c == '\\') + + /* Build the gdb internal form of the input string in tempbuf, + translating any standard C escape forms seen. Note that the + buffer is null byte terminated *only* for the convenience of + debugging gdb itself and printing the buffer contents when + the buffer contains no embedded nulls. Gdb does not depend + upon the buffer being null byte terminated, it uses the length + string instead. This allows gdb to handle C strings (as well + as strings in other languages) with embedded null bytes */ + + tokptr = ++tokstart; + tempbufindex = 0; + + do { + /* Grow the static temp buffer if necessary, including allocating + the first one on demand. */ + if (tempbufindex + 1 >= tempbufsize) { - c = tokstart[++namelen]; - if (c >= '0' && c <= '9') + tempbuf = (char *) realloc (tempbuf, tempbufsize += 64); + } + switch (*tokptr) + { + case '\0': + case '"': + /* Do nothing, loop will terminate. */ + break; + case '\\': + tokptr++; + c = parse_escape (&tokptr); + if (c == -1) { - c = tokstart[++namelen]; - if (c >= '0' && c <= '9') - c = tokstart[++namelen]; + continue; } + tempbuf[tempbufindex++] = c; + break; + default: + tempbuf[tempbufindex++] = *tokptr++; + break; } - yylval.sval.ptr = tokstart + 1; - yylval.sval.length = namelen - 1; - lexptr += namelen + 1; - return STRING; + } while ((*tokptr != '"') && (*tokptr != '\0')); + if (*tokptr++ != '"') + { + error ("Unterminated string in expression."); + } + tempbuf[tempbufindex] = '\0'; /* See note above */ + yylval.sval.ptr = tempbuf; + yylval.sval.length = tempbufindex; + lexptr = tokptr; + return (STRING); } if (!(c == '_' || c == '$' @@ -1222,6 +1378,7 @@ yylex () and $$digits (equivalent to $<-digits> if you could type that). Make token type LAST, and put the number (the digits) in yylval. */ + tryname: if (*tokstart == '$') { register int negate = 0; @@ -1258,14 +1415,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; @@ -1275,29 +1432,40 @@ yylex () switch (namelen) { case 8: - if (!strncmp (tokstart, "unsigned", 8)) + if (STREQN (tokstart, "unsigned", 8)) return UNSIGNED; + if (current_language->la_language == language_cplus + && STREQN (tokstart, "template", 8)) + return TEMPLATE; + if (STREQN (tokstart, "volatile", 8)) + return VOLATILE_KEYWORD; break; case 6: - if (!strncmp (tokstart, "struct", 6)) + if (STREQN (tokstart, "struct", 6)) return STRUCT; - if (!strncmp (tokstart, "signed", 6)) - return SIGNED; - if (!strncmp (tokstart, "sizeof", 6)) + if (STREQN (tokstart, "signed", 6)) + return SIGNED_KEYWORD; + if (STREQN (tokstart, "sizeof", 6)) return SIZEOF; break; case 5: - if (!strncmp (tokstart, "union", 5)) + if (current_language->la_language == language_cplus + && STREQN (tokstart, "class", 5)) + return CLASS; + if (STREQN (tokstart, "union", 5)) return UNION; - if (!strncmp (tokstart, "short", 5)) + if (STREQN (tokstart, "short", 5)) return SHORT; + if (STREQN (tokstart, "const", 5)) + return CONST_KEYWORD; break; case 4: - if (!strncmp (tokstart, "enum", 4)) + if (STREQN (tokstart, "enum", 4)) return ENUM; - if (!strncmp (tokstart, "long", 4)) + if (STREQN (tokstart, "long", 4)) return LONG; - if (!strncmp (tokstart, "this", 4)) + if (current_language->la_language == language_cplus + && STREQN (tokstart, "this", 4)) { static const char this_name[] = { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' }; @@ -1308,7 +1476,7 @@ yylex () } break; case 3: - if (!strncmp (tokstart, "int", 3)) + if (STREQN (tokstart, "int", 3)) return INT_KEYWORD; break; default: @@ -1338,7 +1506,10 @@ yylex () int hextype; sym = lookup_symbol (tmp, expression_context_block, - VAR_NAMESPACE, &is_a_field_of_this, NULL); + VAR_NAMESPACE, + current_language->la_language == language_cplus + ? &is_a_field_of_this : NULL, + NULL); if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) || lookup_partial_symtab (tmp)) { @@ -1369,12 +1540,6 @@ yylex () 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 */ @@ -1388,129 +1553,5 @@ void yyerror (msg) char *msg; { - error ("Invalid syntax in expression."); -} - -/* Table mapping opcodes into strings for printing operators - and precedences of the operators. */ - -const static struct op_print c_op_print_tab[] = - { - {",", BINOP_COMMA, PREC_COMMA, 0}, - {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, - {"||", BINOP_OR, PREC_OR, 0}, - {"&&", BINOP_AND, PREC_AND, 0}, - {"|", BINOP_LOGIOR, PREC_LOGIOR, 0}, - {"&", BINOP_LOGAND, PREC_LOGAND, 0}, - {"^", BINOP_LOGXOR, PREC_LOGXOR, 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}, - {">>", BINOP_RSH, PREC_SHIFT, 0}, - {"<<", BINOP_LSH, PREC_SHIFT, 0}, - {"+", BINOP_ADD, PREC_ADD, 0}, - {"-", BINOP_SUB, PREC_ADD, 0}, - {"*", BINOP_MUL, PREC_MUL, 0}, - {"/", BINOP_DIV, PREC_MUL, 0}, - {"%", BINOP_REM, PREC_MUL, 0}, - {"@", BINOP_REPEAT, PREC_REPEAT, 0}, - {"-", UNOP_NEG, PREC_PREFIX, 0}, - {"!", UNOP_ZEROP, PREC_PREFIX, 0}, - {"~", UNOP_LOGNOT, PREC_PREFIX, 0}, - {"*", UNOP_IND, PREC_PREFIX, 0}, - {"&", UNOP_ADDR, PREC_PREFIX, 0}, - {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0}, - {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0}, - {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0}, - /* C++ */ - {"::", BINOP_SCOPE, PREC_PREFIX, 0}, -}; - -/* These variables point to the objects - representing the predefined C data types. */ - -struct type *builtin_type_void; -struct type *builtin_type_char; -struct type *builtin_type_short; -struct type *builtin_type_int; -struct type *builtin_type_long; -struct type *builtin_type_long_long; -struct type *builtin_type_unsigned_char; -struct type *builtin_type_unsigned_short; -struct type *builtin_type_unsigned_int; -struct type *builtin_type_unsigned_long; -struct type *builtin_type_unsigned_long_long; -struct type *builtin_type_float; -struct type *builtin_type_double; - -struct type ** const (c_builtin_types[]) = -{ - &builtin_type_int, - &builtin_type_long, - &builtin_type_short, - &builtin_type_char, - &builtin_type_float, - &builtin_type_double, - &builtin_type_void, - &builtin_type_long_long, - &builtin_type_unsigned_char, - &builtin_type_unsigned_short, - &builtin_type_unsigned_int, - &builtin_type_unsigned_long, - &builtin_type_unsigned_long_long, - 0 -}; - -/* FIXME: Eventually do a separate defintion for C++. */ - -const struct language_defn c_language_defn = { - "c", /* Language name */ - language_c, - c_builtin_types, - range_check_off, - type_check_off, - c_parse, - c_error, - &BUILTIN_TYPE_LONGEST, /* longest signed integral type */ - &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */ - &builtin_type_double, /* longest floating point type */ - "0x%x", "0x%", "x", /* Hex format, prefix, suffix */ - "0%o", "0%", "o", /* Octal format, prefix, suffix */ - c_op_print_tab, /* expression operators for printing */ - LANG_MAGIC -}; - -void -_initialize_c_exp () -{ - /* FIXME: The code below assumes that the sizes of the basic data - types are the same on the host and target machines!!! */ - - builtin_type_void = init_type (TYPE_CODE_VOID, 1, 0, "void"); - - builtin_type_float = init_type (TYPE_CODE_FLT, sizeof (float), 0, "float"); - builtin_type_double = init_type (TYPE_CODE_FLT, sizeof (double), 0, "double"); - - builtin_type_char = init_type (TYPE_CODE_INT, sizeof (char), 0, "char"); - builtin_type_short = init_type (TYPE_CODE_INT, sizeof (short), 0, "short"); - builtin_type_long = init_type (TYPE_CODE_INT, sizeof (long), 0, "long"); - builtin_type_int = init_type (TYPE_CODE_INT, sizeof (int), 0, "int"); - - builtin_type_unsigned_char = init_type (TYPE_CODE_INT, sizeof (char), 1, "unsigned char"); - builtin_type_unsigned_short = init_type (TYPE_CODE_INT, sizeof (short), 1, "unsigned short"); - builtin_type_unsigned_long = init_type (TYPE_CODE_INT, sizeof (long), 1, "unsigned long"); - builtin_type_unsigned_int = init_type (TYPE_CODE_INT, sizeof (int), 1, "unsigned int"); - - builtin_type_long_long = - init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, - 0, "long long"); - builtin_type_unsigned_long_long = - init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, - 1, "unsigned long long"); - - add_language (&c_language_defn); - set_language (language_c); /* Make C the default language */ + error (msg ? msg : "Invalid syntax in expression."); }