diff options
Diffstat (limited to 'gdb')
| -rw-r--r-- | gdb/ChangeLog | 7 | ||||
| -rw-r--r-- | gdb/objc-exp.y | 1824 | ||||
| -rw-r--r-- | gdb/objc-lang.c | 1905 | ||||
| -rw-r--r-- | gdb/objc-lang.h | 61 |
4 files changed, 3797 insertions, 0 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 0dfd5f4..406e9a5 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,10 @@ +2002-09-18 Michael Snyder <msnyder@redhat.com> + + * objc-lang.c: New file, support for Objective-C. + Preliminary check-in, not yet integrated into gdb. + * objc-lang.h: New file. + * objc-exp.y: New file. + 2002-09-18 Andrew Cagney <ac131313@redhat.com> * infrun.c (signal_stop_update): Convert definition to ISO C. diff --git a/gdb/objc-exp.y b/gdb/objc-exp.y new file mode 100644 index 0000000..b0513bd --- /dev/null +++ b/gdb/objc-exp.y @@ -0,0 +1,1824 @@ +/* YACC parser for C expressions, for GDB. + Copyright (C) 1986, 1989, 1990, 1991, 1993, 1994 + 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* Parse a C expression from text in a string, + and return the result as a struct expression pointer. + That structure contains arithmetic operations in reverse polish, + with constants represented by operations that are followed by special data. + 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. + + 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 (<malloc.h> and <stdlib.h> for example) just became + too messy, particularly when such includes can be inserted at random + times by the parser generator. */ + +%{ + +#include "defs.h" +#include "gdb_string.h" +#include <ctype.h> +#include "expression.h" + +#include "objc-lang.h" /* for objc language constructs */ + +#include "value.h" +#include "parser-defs.h" +#include "language.h" +#include "c-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 */ +#include "top.h" +#include "completer.h" /* For skip_quoted(). */ + +/* 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 objc_maxdepth +#define yyparse objc_parse +#define yylex objc_lex +#define yyerror objc_error +#define yylval objc_lval +#define yychar objc_char +#define yydebug objc_debug +#define yypact objc_pact +#define yyr1 objc_r1 +#define yyr2 objc_r2 +#define yydef objc_def +#define yychk objc_chk +#define yypgo objc_pgo +#define yyact objc_act +#define yyexca objc_exca +#define yyerrflag objc_errflag +#define yynerrs objc_nerrs +#define yyps objc_ps +#define yypv objc_pv +#define yys objc_s +#define yy_yys objc_yys +#define yystate objc_state +#define yytmp objc_tmp +#define yyv objc_v +#define yy_yyv objc_yyv +#define yyval objc_val +#define yylloc objc_lloc +#define yyreds objc_reds /* With YYDEBUG defined */ +#define yytoks objc_toks /* With YYDEBUG defined */ +#define yyname objc_name /* With YYDEBUG defined */ +#define yyrule objc_rule /* With YYDEBUG defined */ +#define yylhs objc_yylhs +#define yylen objc_yylen +#define yydefred objc_yydefred +#define yydgoto objc_yydgoto +#define yysindex objc_yysindex +#define yyrindex objc_yyrindex +#define yygindex objc_yygindex +#define yytable objc_yytable +#define yycheck objc_yycheck + +#ifndef YYDEBUG +#define YYDEBUG 0 /* Default to no yydebug support */ +#endif + +int +yyparse PARAMS ((void)); + +static int +yylex PARAMS ((void)); + +void +yyerror PARAMS ((char *)); + +%} + +/* Although the yacc "value" of an expression is not used, + since the result is stored in the structure being created, + other node types do have values. */ + +%union + { + LONGEST lval; + struct { + LONGEST val; + struct type *type; + } typed_val_int; + struct { + DOUBLEST dval; + struct type *type; + } typed_val_float; + 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 objc_class_str class; + + struct type **tvec; + int *ivec; + } + +%{ +/* YYSTYPE gets defined by %union */ +static int +parse_number PARAMS ((char *, int, int, YYSTYPE *)); +%} + +%type <voidval> exp exp1 type_exp start variable qualified_name lcurly +%type <lval> rcurly +%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 <typed_val_int> INT +%token <typed_val_float> FLOAT + +/* Both NAME and TYPENAME tokens represent symbols in the input, + and both convey their data as strings. + But a TYPENAME is a string that happens to be defined as a typedef + or builtin type name (such as int or char) + and a NAME is any other symbol. + Contexts where this distinction is not important can use the + nonterminal "name", which matches either NAME or TYPENAME. */ + +%token <sval> STRING +%token <sval> NSSTRING /* ObjC Foundation "NSString" literal */ +%token <sval> SELECTOR /* ObjC "@selector" pseudo-operator */ +%token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */ +%token <tsym> TYPENAME +%token <class> CLASSNAME /* ObjC Class name */ +%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. */ + +%token <ssym> NAME_OR_INT + +%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_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD + +%token <voidval> VARIABLE + +%token <opcode> ASSIGN_MODIFY + +/* C++ */ +%token THIS + +%left ',' +%left ABOVE_COMMA +%right '=' ASSIGN_MODIFY +%right '?' +%left OROR +%left ANDAND +%left '|' +%left '^' +%left '&' +%left EQUAL NOTEQUAL +%left '<' '>' LEQ GEQ +%left LSH RSH +%left '@' +%left '+' '-' +%left '*' '/' '%' +%right UNARY INCREMENT DECREMENT +%right ARROW '.' '[' '(' +%token <ssym> BLOCKNAME +%type <bval> block +%left COLONCOLON + + +%% + +start : exp1 + | type_exp + ; + +type_exp: type + { write_exp_elt_opcode(OP_TYPE); + write_exp_elt_type($1); + write_exp_elt_opcode(OP_TYPE);} + ; + +/* Expressions, including the comma operator. */ +exp1 : exp + | exp1 ',' exp + { write_exp_elt_opcode (BINOP_COMMA); } + ; + +/* Expressions, not including the comma operator. */ +exp : '*' exp %prec UNARY + { write_exp_elt_opcode (UNOP_IND); } + +exp : '&' exp %prec UNARY + { write_exp_elt_opcode (UNOP_ADDR); } + +exp : '-' exp %prec UNARY + { write_exp_elt_opcode (UNOP_NEG); } + ; + +exp : '!' exp %prec UNARY + { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } + ; + +exp : '~' exp %prec UNARY + { write_exp_elt_opcode (UNOP_COMPLEMENT); } + ; + +exp : INCREMENT exp %prec UNARY + { write_exp_elt_opcode (UNOP_PREINCREMENT); } + ; + +exp : DECREMENT exp %prec UNARY + { write_exp_elt_opcode (UNOP_PREDECREMENT); } + ; + +exp : exp INCREMENT %prec UNARY + { write_exp_elt_opcode (UNOP_POSTINCREMENT); } + ; + +exp : exp DECREMENT %prec UNARY + { write_exp_elt_opcode (UNOP_POSTDECREMENT); } + ; + +exp : SIZEOF exp %prec UNARY + { write_exp_elt_opcode (UNOP_SIZEOF); } + ; + +exp : exp ARROW name + { write_exp_elt_opcode (STRUCTOP_PTR); + write_exp_string ($3); + 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); } + ; + +exp : exp '.' name + { write_exp_elt_opcode (STRUCTOP_STRUCT); + write_exp_string ($3); + 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); } + ; + +exp : exp '[' exp1 ']' + { write_exp_elt_opcode (BINOP_SUBSCRIPT); } + ; +/* + * The rules below parse ObjC message calls of the form: + * '[' target selector {':' argument}* ']' + */ + +exp : '[' TYPENAME + { + CORE_ADDR class; + + class = lookup_objc_class (copy_name ($2.stoken)); + if (class == 0) + error ("%s is not an ObjC Class", + copy_name ($2.stoken)); + write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_int); + write_exp_elt_longcst ((LONGEST) class); + write_exp_elt_opcode (OP_LONG); + start_msglist(); + } + msglist ']' + { write_exp_elt_opcode (OP_MSGCALL); + end_msglist(); + write_exp_elt_opcode (OP_MSGCALL); + } + ; + +exp : '[' CLASSNAME + { + write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_int); + write_exp_elt_longcst ((LONGEST) $2.class); + write_exp_elt_opcode (OP_LONG); + start_msglist(); + } + msglist ']' + { write_exp_elt_opcode (OP_MSGCALL); + end_msglist(); + write_exp_elt_opcode (OP_MSGCALL); + } + ; + +exp : '[' exp + { start_msglist(); } + msglist ']' + { write_exp_elt_opcode (OP_MSGCALL); + end_msglist(); + write_exp_elt_opcode (OP_MSGCALL); + } + ; + +msglist : name + { add_msglist(&$1, 0); } + | msgarglist + ; + +msgarglist : msgarg + | msgarglist msgarg + ; + +msgarg : name ':' exp + { add_msglist(&$1, 1); } + | ':' exp /* unnamed arg */ + { add_msglist(0, 1); } + | ',' exp /* variable number of args */ + { add_msglist(0, 0); } + ; + +exp : exp '(' + /* This is to save the value of arglist_len + being accumulated by an outer function call. */ + { start_arglist (); } + arglist ')' %prec ARROW + { write_exp_elt_opcode (OP_FUNCALL); + write_exp_elt_longcst ((LONGEST) end_arglist ()); + write_exp_elt_opcode (OP_FUNCALL); } + ; + +lcurly : '{' + { start_arglist (); } + ; + +arglist : + ; + +arglist : exp + { arglist_len = 1; } + ; + +arglist : arglist ',' exp %prec ABOVE_COMMA + { arglist_len++; } + ; + +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); } + ; + +exp : '(' type ')' exp %prec UNARY + { 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_opcode (BINOP_REPEAT); } + ; + +exp : exp '*' exp + { write_exp_elt_opcode (BINOP_MUL); } + ; + +exp : exp '/' exp + { write_exp_elt_opcode (BINOP_DIV); } + ; + +exp : exp '%' exp + { write_exp_elt_opcode (BINOP_REM); } + ; + +exp : exp '+' exp + { write_exp_elt_opcode (BINOP_ADD); } + ; + +exp : exp '-' exp + { write_exp_elt_opcode (BINOP_SUB); } + ; + +exp : exp LSH exp + { write_exp_elt_opcode (BINOP_LSH); } + ; + +exp : exp RSH exp + { write_exp_elt_opcode (BINOP_RSH); } + ; + +exp : exp EQUAL exp + { write_exp_elt_opcode (BINOP_EQUAL); } + ; + +exp : exp NOTEQUAL exp + { write_exp_elt_opcode (BINOP_NOTEQUAL); } + ; + +exp : exp LEQ exp + { write_exp_elt_opcode (BINOP_LEQ); } + ; + +exp : exp GEQ exp + { write_exp_elt_opcode (BINOP_GEQ); } + ; + +exp : exp '<' exp + { write_exp_elt_opcode (BINOP_LESS); } + ; + +exp : exp '>' exp + { write_exp_elt_opcode (BINOP_GTR); } + ; + +exp : exp '&' exp + { write_exp_elt_opcode (BINOP_BITWISE_AND); } + ; + +exp : exp '^' exp + { write_exp_elt_opcode (BINOP_BITWISE_XOR); } + ; + +exp : exp '|' exp + { write_exp_elt_opcode (BINOP_BITWISE_IOR); } + ; + +exp : exp ANDAND exp + { write_exp_elt_opcode (BINOP_LOGICAL_AND); } + ; + +exp : exp OROR exp + { write_exp_elt_opcode (BINOP_LOGICAL_OR); } + ; + +exp : exp '?' exp ':' exp %prec '?' + { write_exp_elt_opcode (TERNOP_COND); } + ; + +exp : exp '=' exp + { write_exp_elt_opcode (BINOP_ASSIGN); } + ; + +exp : exp ASSIGN_MODIFY exp + { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); + write_exp_elt_opcode ($2); + write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); } + ; + +exp : INT + { write_exp_elt_opcode (OP_LONG); + write_exp_elt_type ($1.type); + write_exp_elt_longcst ((LONGEST)($1.val)); + write_exp_elt_opcode (OP_LONG); } + ; + +exp : NAME_OR_INT + { YYSTYPE val; + parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val); + write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (val.typed_val_int.type); + write_exp_elt_longcst ((LONGEST)val.typed_val_int.val); + write_exp_elt_opcode (OP_LONG); + } + ; + + +exp : FLOAT + { write_exp_elt_opcode (OP_DOUBLE); + write_exp_elt_type ($1.type); + write_exp_elt_dblcst ($1.dval); + write_exp_elt_opcode (OP_DOUBLE); } + ; + +exp : variable + ; + +exp : VARIABLE + /* Already written by write_dollar_variable. */ + ; + +exp : SELECTOR + { + write_exp_elt_opcode (OP_SELECTOR); + write_exp_string ($1); + write_exp_elt_opcode (OP_SELECTOR); } + +exp : SIZEOF '(' type ')' %prec UNARY + { write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_int); + CHECK_TYPEDEF ($3); + write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3)); + write_exp_elt_opcode (OP_LONG); } + ; + +exp : 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); } + ; + +exp : NSSTRING /* ObjC NextStep NSString constant + * of the form '@' '"' string '"' + */ + { write_exp_elt_opcode (OP_NSSTRING); + write_exp_string ($1); + write_exp_elt_opcode (OP_NSSTRING); } + ; + +/* 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 + { + 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.stoken)); + } + } + ; + +block : block COLONCOLON name + { struct symbol *tem + = lookup_symbol (copy_name ($3), $1, + VAR_NAMESPACE, (int *) NULL, + (struct symtab **) NULL); + if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK) + error ("No function \"%s\" in specified context.", + copy_name ($3)); + $$ = SYMBOL_BLOCK_VALUE (tem); } + ; + +variable: block COLONCOLON name + { struct symbol *sym; + sym = lookup_symbol (copy_name ($3), $1, + VAR_NAMESPACE, (int *) NULL, + (struct symtab **) NULL); + if (sym == 0) + error ("No symbol \"%s\" in specified context.", + 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); } + ; + +qualified_name: 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; + 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 (!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 (tmp_token); + write_exp_elt_opcode (OP_SCOPE); + } + ; + +variable: qualified_name + | COLONCOLON name + { + char *name = copy_name ($2); + struct symbol *sym; + struct minimal_symbol *msymbol; + + sym = + lookup_symbol (name, (const struct block *) NULL, + VAR_NAMESPACE, (int *) NULL, + (struct symtab **) NULL); + if (sym) + { + write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_block (NULL); + write_exp_elt_sym (sym); + write_exp_elt_opcode (OP_VAR_VALUE); + break; + } + + msymbol = lookup_minimal_symbol (name, NULL, NULL); + if (msymbol != NULL) + { + 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 \"file\" command."); + else + error ("No symbol \"%s\" in current context.", name); + } + ; + +variable: name_not_typename + { struct symbol *sym = $1.sym; + + if (sym) + { + if (symbol_read_needs_frame (sym)) + { + if (innermost_block == 0 || + contained_in (block_found, + innermost_block)) + innermost_block = block_found; + } + + 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); + } + else if ($1.is_a_field_of_this) + { + /* C++/ObjC: it hangs off of `this'/'self'. + 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_SELF); + write_exp_elt_opcode (OP_SELF); + write_exp_elt_opcode (STRUCTOP_PTR); + write_exp_string ($1.stoken); + write_exp_elt_opcode (STRUCTOP_PTR); + } + else + { + struct minimal_symbol *msymbol; + register char *arg = copy_name ($1.stoken); + + msymbol = + lookup_minimal_symbol (arg, NULL, NULL); + if (msymbol != NULL) + { + 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 \"file\" command."); + else + error ("No symbol \"%s\" in current context.", + copy_name ($1.stoken)); + } + } + ; + + +ptype : typebase + /* "const" and "volatile" are curently ignored. A type qualifier + before the type is currently handled in the typebase rule. + The reason for recognizing these here (shift/reduce conflicts) + might be obsolete now that some pointer to member rules have + been deleted. */ + | typebase CONST_KEYWORD + | typebase VOLATILE_KEYWORD + | typebase abs_decl + { $$ = follow_types ($1); } + | typebase CONST_KEYWORD abs_decl + { $$ = follow_types ($1); } + | typebase VOLATILE_KEYWORD abs_decl + { $$ = follow_types ($1); } + ; + +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.val; } + ; + +func_mod: '(' ')' + { $$ = 0; } + | '(' nonempty_typelist ')' + { free ((PTR)$2); $$ = 0; } + ; + +/* We used to try to recognize more pointer to member types here, but + that didn't work (shift/reduce conflicts meant that these rules never + got executed). The problem is that + int (foo::bar::baz::bizzle) + is a function type but + int (foo::bar::baz::bizzle::*) + is a pointer to member type. Stroustrup loses again! */ + +type : ptype + | typebase COLONCOLON '*' + { $$ = lookup_member_type (builtin_type_int, $1); } + ; + +typebase /* Implements (approximately): (type-qualifier)* type-specifier */ + : TYPENAME + { $$ = $1.type; } + | CLASSNAME + { + if ($1.type == NULL) + error ("No symbol \"%s\" in current context.", + copy_name($1.stoken)); + else + $$ = $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; } + | DOUBLE_KEYWORD + { $$ = builtin_type_double; } + | LONG DOUBLE_KEYWORD + { $$ = builtin_type_long_double; } + | 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); } + | ENUM name + { $$ = lookup_enum (copy_name ($2), + expression_context_block); } + | UNSIGNED typename + { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); } + | UNSIGNED + { $$ = builtin_type_unsigned_int; } + | 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. A type qualifier + after the type is handled in the ptype rule. I think these could + be too. */ + | CONST_KEYWORD typebase { $$ = $2; } + | VOLATILE_KEYWORD typebase { $$ = $2; } + ; + +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 **) malloc (sizeof (struct type *) * 2); + $<ivec>$[0] = 1; /* Number of types in vector */ + $$[1] = $1; + } + | nonempty_typelist ',' type + { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1); + $$ = (struct type **) realloc ((char *) $1, len); + $$[$<ivec>$[0]] = $3; + } + ; + +name : NAME { $$ = $1.stoken; } + | BLOCKNAME { $$ = $1.stoken; } + | TYPENAME { $$ = $1.stoken; } + | CLASSNAME { $$ = $1.stoken; } + | NAME_OR_INT { $$ = $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 + */ + ; + +%% + +/* 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 (p, len, parsed_float, putithere) + register char *p; + register int len; + int parsed_float; + YYSTYPE *putithere; +{ + /* FIXME: Shouldn't these be unsigned? We don't deal with negative values + here, and we do kind of silly things like cast to unsigned. */ + register LONGEST n = 0; + register LONGEST prevn = 0; + unsigned LONGEST un; + + register int i = 0; + register int c; + register int base = input_radix; + int unsigned_p = 0; + + /* Number of "L" suffixes encountered. */ + int long_p = 0; + + /* We have found a "L" or "U" suffix. */ + int found_suffix = 0; + + unsigned LONGEST high_bit; + struct type *signed_type; + struct type *unsigned_type; + + if (parsed_float) + { + char c; + + /* It's a float since it contains a point or an exponent. */ + + if (sizeof (putithere->typed_val_float.dval) <= sizeof (float)) + sscanf (p, "%g", &putithere->typed_val_float.dval); + else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double)) + sscanf (p, "%lg", &putithere->typed_val_float.dval); + else + { +#ifdef PRINTF_HAS_LONG_DOUBLE + sscanf (p, "%Lg", &putithere->typed_val_float.dval); +#else + /* Scan it into a double, then assign it to the long double. + This at least wins with values representable in the range + of doubles. */ + double temp; + sscanf (p, "%lg", &temp); + putithere->typed_val_float.dval = temp; +#endif + } + + /* See if it has `f' or `l' suffix (float or long double). */ + + c = tolower (p[len - 1]); + + if (c == 'f') + putithere->typed_val_float.type = builtin_type_float; + else if (c == 'l') + putithere->typed_val_float.type = builtin_type_long_double; + else if (isdigit (c) || c == '.') + putithere->typed_val_float.type = builtin_type_double; + else + return ERROR; + + return FLOAT; + } + + /* 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++; + if (c >= 'A' && c <= 'Z') + c += 'a' - 'A'; + if (c != 'l' && c != 'u') + n *= base; + if (c >= '0' && c <= '9') + { + if (found_suffix) + return ERROR; + n += i = c - '0'; + } + else + { + if (base > 10 && c >= 'a' && c <= 'f') + { + if (found_suffix) + return ERROR; + n += i = c - 'a' + 10; + } + else if (c == 'l') + { + ++long_p; + found_suffix = 1; + } + else if (c == 'u') + { + unsigned_p = 1; + found_suffix = 1; + } + else + return ERROR; /* Char not a digit */ + } + if (i >= base) + return ERROR; /* Invalid digit in this base */ + + /* Portably test for overflow (only works for nonzero values, so make + a second check for zero). FIXME: Can't we just make n and prevn + unsigned and avoid this? */ + if (c != 'l' && c != 'u' && (prevn >= n) && n != 0) + unsigned_p = 1; /* Try something unsigned */ + + /* Portably test for unsigned overflow. + FIXME: This check is wrong; for example it doesn't find overflow + on 0x123456789 when LONGEST is 32 bits. */ + if (c != 'l' && c != 'u' && n != 0) + { + if ((unsigned_p && (unsigned LONGEST) prevn >= (unsigned LONGEST) n)) + error ("Numeric constant too large."); + } + prevn = n; + } + + /* An integer constant is an int, a long, or a long long. An L + suffix forces it to be long; an LL suffix forces it to be long + long. If not forced to a larger size, it gets the first type of + the above that it fits in. To figure out whether it fits, we + shift it right and see whether anything remains. Note that we + can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one + operation, because many compilers will warn about such a shift + (which always produces a zero result). Sometimes TARGET_INT_BIT + or TARGET_LONG_BIT will be that big, sometimes not. To deal with + the case where it is we just always shift the value more than + once, with fewer bits each time. */ + + un = (unsigned LONGEST)n >> 2; + if (long_p == 0 + && (un >> (TARGET_INT_BIT - 2)) == 0) + { + high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1); + + /* A large decimal (not hex or octal) constant (between INT_MAX + and UINT_MAX) is a long or unsigned long, according to ANSI, + never an unsigned int, but this code treats it as unsigned + int. This probably should be fixed. GCC gives a warning on + such constants. */ + + unsigned_type = builtin_type_unsigned_int; + signed_type = builtin_type_int; + } + else if (long_p <= 1 + && (un >> (TARGET_LONG_BIT - 2)) == 0) + { + 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_LONG_LONG_BIT - 32 - 1) + << 16 + << 16); + if (high_bit == 0) + /* A long long does not fit in a LONGEST. */ + high_bit = + (unsigned LONGEST)1 << (sizeof (LONGEST) * HOST_CHAR_BIT - 1); + unsigned_type = builtin_type_unsigned_long_long; + signed_type = builtin_type_long_long; + } + + putithere->typed_val_int.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_int.type = unsigned_type; + } + else + { + putithere->typed_val_int.type = signed_type; + } + + return INT; +} + +struct token +{ + char *operator; + int token; + enum exp_opcode opcode; +}; + +static const struct token tokentab3[] = + { + {">>=", ASSIGN_MODIFY, BINOP_RSH}, + {"<<=", ASSIGN_MODIFY, BINOP_LSH} + }; + +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_BITWISE_IOR}, + {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND}, + {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR}, + {"++", INCREMENT, BINOP_END}, + {"--", DECREMENT, BINOP_END}, + {"->", ARROW, BINOP_END}, + {"&&", ANDAND, BINOP_END}, + {"||", OROR, BINOP_END}, + {"::", COLONCOLON, BINOP_END}, + {"<<", LSH, BINOP_END}, + {">>", RSH, BINOP_END}, + {"==", EQUAL, BINOP_END}, + {"!=", NOTEQUAL, BINOP_END}, + {"<=", LEQ, BINOP_END}, + {">=", GEQ, BINOP_END} + }; + +/* Read one token, getting characters through lexptr. */ + +static int +yylex () +{ + int c, tokchr; + 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 (STREQN (tokstart, tokentab3[i].operator, 3)) + { + lexptr += 3; + yylval.opcode = tokentab3[i].opcode; + return tokentab3[i].token; + } + + /* See if it is a special token of length 2. */ + for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++) + if (STREQN (tokstart, tokentab2[i].operator, 2)) + { + lexptr += 2; + yylval.opcode = tokentab2[i].opcode; + return tokentab2[i].token; + } + + switch (tokchr = *tokstart) + { + case 0: + return 0; + + case ' ': + case '\t': + case '\n': + lexptr++; + 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); + else if (c == '\'') + error ("Empty character constant."); + + yylval.typed_val_int.val = c; + yylval.typed_val_int.type = builtin_type_char; + + c = *lexptr++; + if (c != '\'') + { + namelen = skip_quoted (tokstart, + get_gdb_completer_word_break_characters()) + - tokstart; + if (namelen > 2) + { + lexptr = tokstart + namelen; + if (lexptr[-1] != '\'') + error ("Unmatched single quote."); + namelen -= 2; + tokstart++; + goto tryname; + } + error ("Invalid character constant."); + } + return INT; + + case '(': + paren_depth++; + lexptr++; + return '('; + + case ')': + if (paren_depth == 0) + return 0; + paren_depth--; + lexptr++; + return ')'; + + case ',': + if (comma_terminates && paren_depth == 0) + return 0; + lexptr++; + return ','; + + 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 = FLOAT; + /* initialize toktype to anything other than ERROR. */ + register char *p = tokstart; + int hex = input_radix > 10; + int local_radix = input_radix; + if (tokchr == '0' && (p[1] == 'x' || p[1] == 'X')) + { + p += 2; + hex = 1; + local_radix = 16; + } + else if (tokchr == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D')) + { + p += 2; + hex = 0; + local_radix = 10; + } + + for (;; ++p) + { + /* This test includes !hex because 'e' is a valid hex digit + and thus does not indicate a floating point number when + the radix is hex. */ + + if (!hex && (*p == 'e' || *p == 'E')) + if (got_e) + toktype = ERROR; /* only one 'e' in a float */ + else + got_e = 1; + /* This test does not include !hex, because a '.' always indicates + a decimal floating point number regardless of the radix. */ + else if (*p == '.') + if (got_dot) + toktype = ERROR; /* only one '.' in a float */ + else + 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; + /* Always take decimal digits; parse_number handles radix error */ + else if (*p >= '0' && *p <= '9') + continue; + /* We will take letters only if hex is true, and only + up to what the input radix would permit. FSF was content + to rely on parse_number to validate; but it leaks. */ + else if (*p >= 'a' && *p <= 'z') { + if (!hex || *p >= ('a' + local_radix - 10)) + toktype = ERROR; + } + else if (*p >= 'A' && *p <= 'Z') { + if (!hex || *p >= ('A' + local_radix - 10)) + toktype = ERROR; + } + else break; + } + if (toktype != ERROR) + toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); + if (toktype == ERROR) + { + char *err_copy = (char *) alloca (p - tokstart + 1); + + memcpy (err_copy, tokstart, 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 '!': +#if 0 + case '@': /* moved out below */ +#endif + case '<': + case '>': + case '[': + case ']': + case '?': + case ':': + case '=': + case '{': + case '}': + symbol: + lexptr++; + return tokchr; + + case '@': + if (strncmp(tokstart, "@selector", 9) == 0) + { + tokptr = strchr(tokstart, '('); + if (tokptr == NULL) + { + error ("Missing '(' in @selector(...)"); + } + tempbufindex = 0; + tokptr++; /* skip the '(' */ + do { + /* Grow the static temp buffer if necessary, including allocating + the first one on demand. */ + if (tempbufindex + 1 >= tempbufsize) + { + tempbuf = (char *) realloc (tempbuf, tempbufsize += 64); + } + tempbuf[tempbufindex++] = *tokptr++; + } while ((*tokptr != ')') && (*tokptr != '\0')); + if (*tokptr++ != ')') + { + error ("Missing ')' in @selector(...)"); + } + tempbuf[tempbufindex] = '\0'; + yylval.sval.ptr = tempbuf; + yylval.sval.length = tempbufindex; + lexptr = tokptr; + return SELECTOR; + } + if (tokstart[1] != '"') + { + lexptr++; + return tokchr; + } + /* ObjC NextStep NSString constant: fall thru and parse like STRING */ + tokstart++; + + case '"': + + /* 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) + { + 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) + { + continue; + } + tempbuf[tempbufindex++] = c; + break; + default: + tempbuf[tempbufindex++] = *tokptr++; + break; + } + } 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 (tokchr == '@' ? NSSTRING : STRING); + } + + if (!(tokchr == '_' || tokchr == '$' || + (tokchr >= 'a' && tokchr <= 'z') || (tokchr >= 'A' && tokchr <= 'Z'))) + /* We must have come across a bad character (e.g. ';'). */ + error ("Invalid character '%c' in expression.", c); + + /* 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') || c == '<');) + { + if (c == '<') + { + int i = namelen; + while (tokstart[++i] && tokstart[i] != '>'); + if (tokstart[i] == '>') + namelen = i; + } + c = tokstart[++namelen]; + } + + /* The token "if" terminates the expression and is NOT + removed from the input stream. */ + if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') + { + return 0; + } + + lexptr += namelen; + + tryname: + + /* Catch specific keywords. Should be done with a data structure. */ + switch (namelen) + { + case 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 (STREQN (tokstart, "struct", 6)) + return STRUCT; + if (STREQN (tokstart, "signed", 6)) + return SIGNED_KEYWORD; + if (STREQN (tokstart, "sizeof", 6)) + return SIZEOF; + if (STREQN (tokstart, "double", 6)) + return DOUBLE_KEYWORD; + break; + case 5: + if ((current_language->la_language == language_cplus) + && STREQN (tokstart, "class", 5)) + return CLASS; + if (STREQN (tokstart, "union", 5)) + return UNION; + if (STREQN (tokstart, "short", 5)) + return SHORT; + if (STREQN (tokstart, "const", 5)) + return CONST_KEYWORD; + break; + case 4: + if (STREQN (tokstart, "enum", 4)) + return ENUM; + if (STREQN (tokstart, "long", 4)) + return LONG; + if (current_language->la_language == language_cplus + && STREQN (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, (int *) NULL, + (struct symtab **) NULL)) + return THIS; + } + break; + case 3: + if (STREQN (tokstart, "int", 3)) + return INT_KEYWORD; + break; + default: + break; + } + + yylval.sval.ptr = tokstart; + yylval.sval.length = namelen; + + if (*tokstart == '$') + { + write_dollar_variable (yylval.sval); + return VARIABLE; + } + + /* 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. */ + { + char *tmp = copy_name (yylval.sval); + struct symbol *sym; + int is_a_field_of_this = 0, *need_this; + int hextype; + + if (current_language->la_language == language_cplus || + current_language->la_language == language_objc) + need_this = &is_a_field_of_this; + else + need_this = (int *) NULL; + + sym = lookup_symbol (tmp, expression_context_block, + VAR_NAMESPACE, + need_this, + (struct symtab **) NULL); + /* Call lookup_symtab, not lookup_partial_symtab, in case there are + no psymtabs (coff, xcoff, or some future change to blow away the + psymtabs once symbols are read). */ + if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) || + lookup_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) + { +#if 1 + /* Despite the following flaw, we need to keep this code enabled. + Because we can get called from check_stub_method, if we don't + handle nested types then it screws many operations in any + program which uses nested types. */ + /* In "A::x", if x is a member function of A and there happens + to be a type (nested or not, since the stabs don't make that + distinction) named x, then this code incorrectly thinks we + are dealing with nested types rather than a member function. */ + + char *p; + char *namestart; + struct symbol *best_sym; + + /* Look ahead to detect nested types. This probably should be + done in the grammar, but trying seemed to introduce a lot + of shift/reduce and reduce/reduce conflicts. It's possible + that it could be done, though. Or perhaps a non-grammar, but + less ad hoc, approach would work well. */ + + /* Since we do not currently have any way of distinguishing + a nested type from a non-nested one (the stabs don't tell + us whether a type is nested), we just ignore the + containing type. */ + + p = lexptr; + best_sym = sym; + while (1) + { + /* Skip whitespace. */ + while (*p == ' ' || *p == '\t' || *p == '\n') + ++p; + if (*p == ':' && p[1] == ':') + { + /* Skip the `::'. */ + p += 2; + /* Skip whitespace. */ + while (*p == ' ' || *p == '\t' || *p == '\n') + ++p; + namestart = p; + while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9') + || (*p >= 'a' && *p <= 'z') + || (*p >= 'A' && *p <= 'Z')) + ++p; + if (p != namestart) + { + struct symbol *cur_sym; + /* As big as the whole rest of the expression, which is + at least big enough. */ + char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3); + char *tmp1; + + tmp1 = ncopy; + memcpy (tmp1, tmp, strlen (tmp)); + tmp1 += strlen (tmp); + memcpy (tmp1, "::", 2); + tmp1 += 2; + memcpy (tmp1, namestart, p - namestart); + tmp1[p - namestart] = '\0'; + cur_sym = lookup_symbol (ncopy, expression_context_block, + VAR_NAMESPACE, (int *) NULL, + (struct symtab **) NULL); + if (cur_sym) + { + if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF) + { + best_sym = cur_sym; + lexptr = p; + } + else + break; + } + else + break; + } + else + break; + } + else + break; + } + + yylval.tsym.type = SYMBOL_TYPE (best_sym); +#else /* not 0 */ + yylval.tsym.type = SYMBOL_TYPE (sym); +#endif /* not 0 */ + return TYPENAME; + } + if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0) + return TYPENAME; + + if (!sym) /* see if it's an ObjC classname */ + { + CORE_ADDR Class = lookup_objc_class(tmp); + if (Class) + { + extern struct symbol *lookup_struct_typedef(); + yylval.class.class = Class; + if ((sym = lookup_struct_typedef (tmp, expression_context_block, 1))) + yylval.class.type = SYMBOL_TYPE (sym); + return CLASSNAME; + } + } + + /* 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; + } + } + + /* Any other kind of symbol */ + yylval.ssym.sym = sym; + yylval.ssym.is_a_field_of_this = is_a_field_of_this; + return NAME; + } +} + +void +yyerror (msg) + char *msg; +{ + if (*lexptr == '\0') + error("A %s near end of expression.", (msg ? msg : "error")); + else + error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr); +} diff --git a/gdb/objc-lang.c b/gdb/objc-lang.c new file mode 100644 index 0000000..594a0cb --- /dev/null +++ b/gdb/objc-lang.c @@ -0,0 +1,1905 @@ +/* Objective C language support routines for GDB, the GNU debugger. + Copyright 1996 NeXT Software, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#include "defs.h" +#include "symtab.h" +#include "gdbtypes.h" +#include "expression.h" +#include "parser-defs.h" +#include "language.h" +#include "objc-lang.h" +#include "complaints.h" +#include "value.h" +#include "symfile.h" +#include "objfiles.h" +#include "string.h" /* for strchr */ +#include "target.h" /* for target_has_execution */ +#include "gdbcore.h" +#include "gdbcmd.h" +#include "frame.h" +#include "gdb_regex.h" +#include "regcache.h" + +#include <ctype.h> + +struct objc_object { + CORE_ADDR isa; +}; + +struct objc_class { + CORE_ADDR isa; + CORE_ADDR super_class; + CORE_ADDR name; + long version; + long info; + long instance_size; + CORE_ADDR ivars; + CORE_ADDR methods; + CORE_ADDR cache; + CORE_ADDR protocols; +}; + +struct objc_super { + CORE_ADDR receiver; + CORE_ADDR class; +}; + +struct objc_method { + CORE_ADDR name; + CORE_ADDR types; + CORE_ADDR imp; +}; + +/* Complaints about ObjC classes, selectors, etc. */ + +static struct complaint noclass_lookup_complaint = + {"no way to lookup Objective-C classes", 0, 0}; + +static struct complaint nosel_lookup_complaint = + {"no way to lookup Objective-C selectors", 0, 0}; + + +#if (!defined __GNUC__ || __GNUC__ < 2 || __GNUC_MINOR__ < (defined __cplusplus ? 6 : 4)) +#define __CHECK_FUNCTION ((__const char *) 0) +#else +#define __CHECK_FUNCTION __PRETTY_FUNCTION__ +#endif + +#define CHECK(expression) \ + ((void) ((expression) ? 0 : gdb_check (#expression, __FILE__, __LINE__, \ + __CHECK_FUNCTION))) + +#define CHECK_FATAL(expression) \ + ((void) ((expression) ? 0 : gdb_check_fatal (#expression, __FILE__, \ + __LINE__, __CHECK_FUNCTION))) + +void +gdb_check (const char *str, const char *file, unsigned int line, + const char *func) +{ + error ("assertion failure on line %u of \"%s\" in function \"%s\": %s\n", + line, file, func, str); +} + +void +gdb_check_fatal (const char *str, const char *file, unsigned int line, + const char *func) +{ + internal_error (file, line, + "assertion failure in function \"%s\": %s\n", func, str); +} + +/* Lookup a structure type named "struct NAME", + visible in lexical block BLOCK. + If NOERR is nonzero, return zero if NAME is not suitably defined. */ + +struct symbol * +lookup_struct_typedef (char *name, struct block *block, int noerr) +{ + register struct symbol *sym; + + sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, (struct symtab **) NULL); + + if (sym == NULL) + { + if (noerr) + return 0; + else + error ("No struct type named %s.", name); + } + if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT) + { + if (noerr) + return 0; + else + error ("This context has class, union or enum %s, not a struct.", name); + } + return sym; +} + +CORE_ADDR +lookup_objc_class (char *classname) +{ + struct value * function, *classval; + + if (! target_has_execution) + { + /* can't call into inferior to lookup class */ + return 0; + } + + if (lookup_minimal_symbol("objc_lookUpClass", 0, 0)) + function = find_function_in_inferior("objc_lookUpClass"); + else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0)) + function = find_function_in_inferior("objc_lookup_class"); + else + { + complain (&noclass_lookup_complaint, 0); + return 0; + } + + classval = value_string (classname, strlen (classname) + 1); + classval = value_coerce_array (classval); + return (CORE_ADDR) value_as_long (call_function_by_hand (function, + 1, &classval)); +} + +int +lookup_child_selector (char *selname) +{ + struct value * function, *selstring; + + if (! target_has_execution) + { + /* can't call into inferior to lookup selector */ + return 0; + } + + if (lookup_minimal_symbol("sel_getUid", 0, 0)) + function = find_function_in_inferior("sel_getUid"); + else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0)) + function = find_function_in_inferior("sel_get_any_uid"); + else + { + complain (&nosel_lookup_complaint, 0); + return 0; + } + + selstring = value_coerce_array (value_string (selname, strlen (selname) + 1)); + return value_as_long (call_function_by_hand (function, 1, &selstring)); +} + +struct value * +value_nsstring (char *ptr, int len) +{ + struct value *stringValue[3]; + struct value *function, *nsstringValue; + struct symbol *sym; + struct type *type; + + if (!target_has_execution) + return 0; /* can't call into inferior to create NSString */ + + if (!(sym = lookup_struct_typedef("NSString", 0, 1)) && + !(sym = lookup_struct_typedef("NXString", 0, 1))) + type = lookup_pointer_type(builtin_type_void); + else + type = lookup_pointer_type(SYMBOL_TYPE (sym)); + + stringValue[2] = value_string(ptr, len); + stringValue[2] = value_coerce_array(stringValue[2]); + /* _NSNewStringFromCString replaces "istr" after Lantern2A */ + if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0)) + { + function = find_function_in_inferior("_NSNewStringFromCString"); + nsstringValue = call_function_by_hand(function, 1, &stringValue[2]); + } + else if (lookup_minimal_symbol("istr", 0, 0)) + { + function = find_function_in_inferior("istr"); + nsstringValue = call_function_by_hand(function, 1, &stringValue[2]); + } + else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0)) + { + function = find_function_in_inferior("+[NSString stringWithCString:]"); + stringValue[0] = value_from_longest + (builtin_type_long, lookup_objc_class ("NSString")); + stringValue[1] = value_from_longest + (builtin_type_long, lookup_child_selector ("stringWithCString:")); + nsstringValue = call_function_by_hand(function, 3, &stringValue[0]); + } + else + error ("NSString: internal error -- no way to create new NSString"); + + VALUE_TYPE(nsstringValue) = type; + return nsstringValue; +} + +/* Objective C name demangling */ + +char * +objc_demangle (const char *mangled) +{ + char *demangled, *cp; + + if (mangled[0] == '_' && + (mangled[1] == 'i' || mangled[1] == 'c') && + mangled[2] == '_') + { + cp = demangled = xmalloc(strlen(mangled) + 2); + + if (mangled[1] == 'i') + *cp++ = '-'; /* for instance method */ + else + *cp++ = '+'; /* for class method */ + + *cp++ = '['; /* opening left brace */ + strcpy(cp, mangled+3); /* tack on the rest of the mangled name */ + + while (*cp && *cp == '_') + cp++; /* skip any initial underbars in class name */ + + if (!(cp = strchr(cp, '_'))) /* find first non-initial underbar */ + { + free(demangled); /* not mangled name */ + return NULL; + } + if (cp[1] == '_') { /* easy case: no category name */ + *cp++ = ' '; /* replace two '_' with one ' ' */ + strcpy(cp, mangled + (cp - demangled) + 2); + } + else { + *cp++ = '('; /* less easy case: category name */ + if (!(cp = strchr(cp, '_'))) + { + free(demangled); /* not mangled name */ + return NULL; + } + *cp++ = ')'; + *cp++ = ' '; /* overwriting 1st char of method name... */ + strcpy(cp, mangled + (cp - demangled)); /* get it back */ + } + + while (*cp && *cp == '_') + cp++; /* skip any initial underbars in method name */ + + for (; *cp; cp++) + if (*cp == '_') + *cp = ':'; /* replace remaining '_' with ':' */ + + *cp++ = ']'; /* closing right brace */ + *cp++ = 0; /* string terminator */ + return demangled; + } + else + return NULL; /* not an objc mangled name */ +} + +/* Print the character C on STREAM as part of the contents of a literal + string whose delimiter is QUOTER. Note that that format for printing + characters and strings is language specific. */ + +static void +objc_emit_char (register int c, struct ui_file *stream, int quoter) +{ + + c &= 0xFF; /* Avoid sign bit follies */ + + if (PRINT_LITERAL_FORM (c)) + { + if (c == '\\' || c == quoter) + { + fputs_filtered ("\\", stream); + } + fprintf_filtered (stream, "%c", c); + } + else + { + switch (c) + { + case '\n': + fputs_filtered ("\\n", stream); + break; + case '\b': + fputs_filtered ("\\b", stream); + break; + case '\t': + fputs_filtered ("\\t", stream); + break; + case '\f': + fputs_filtered ("\\f", stream); + break; + case '\r': + fputs_filtered ("\\r", stream); + break; + case '\033': + fputs_filtered ("\\e", stream); + break; + case '\007': + fputs_filtered ("\\a", stream); + break; + default: + fprintf_filtered (stream, "\\%.3o", (unsigned int) c); + break; + } + } +} + +static void +objc_printchar (int c, struct ui_file *stream) +{ + fputs_filtered ("'", stream); + objc_emit_char (c, stream, '\''); + fputs_filtered ("'", stream); +} + +/* Print the character string STRING, printing at most LENGTH characters. + Printing stops early if the number hits print_max; repeat counts + are printed as appropriate. Print ellipses at the end if we + had to stop before printing LENGTH characters, or if FORCE_ELLIPSES. */ + +static void +objc_printstr (struct ui_file *stream, char *string, unsigned int length, + int force_ellipses) +{ + register unsigned int i; + unsigned int things_printed = 0; + int in_quotes = 0; + int need_comma = 0; + extern int inspect_it; + extern int repeat_count_threshold; + extern int print_max; + + /* If the string was not truncated due to `set print elements', and + the last byte of it is a null, we don't print that, in traditional C + style. */ + if ((!force_ellipses) && length > 0 && string[length-1] == '\0') + length--; + + if (length == 0) + { + fputs_filtered ("\"\"", stream); + return; + } + + for (i = 0; i < length && things_printed < print_max; ++i) + { + /* Position of the character we are examining + to see whether it is repeated. */ + unsigned int rep1; + /* Number of repetitions we have detected so far. */ + unsigned int reps; + + QUIT; + + if (need_comma) + { + fputs_filtered (", ", stream); + need_comma = 0; + } + + rep1 = i + 1; + reps = 1; + while (rep1 < length && string[rep1] == string[i]) + { + ++rep1; + ++reps; + } + + if (reps > repeat_count_threshold) + { + if (in_quotes) + { + if (inspect_it) + fputs_filtered ("\\\", ", stream); + else + fputs_filtered ("\", ", stream); + in_quotes = 0; + } + objc_printchar (string[i], stream); + fprintf_filtered (stream, " <repeats %u times>", reps); + i = rep1 - 1; + things_printed += repeat_count_threshold; + need_comma = 1; + } + else + { + if (!in_quotes) + { + if (inspect_it) + fputs_filtered ("\\\"", stream); + else + fputs_filtered ("\"", stream); + in_quotes = 1; + } + objc_emit_char (string[i], stream, '"'); + ++things_printed; + } + } + + /* Terminate the quotes if necessary. */ + if (in_quotes) + { + if (inspect_it) + fputs_filtered ("\\\"", stream); + else + fputs_filtered ("\"", stream); + } + + if (force_ellipses || i < length) + fputs_filtered ("...", stream); +} + +/* Create a fundamental C type using default reasonable for the current + target machine. + + Some object/debugging file formats (DWARF version 1, COFF, etc) do not + define fundamental types such as "int" or "double". Others (stabs or + DWARF version 2, etc) do define fundamental types. For the formats which + don't provide fundamental types, gdb can create such types using this + function. + + FIXME: Some compilers distinguish explicitly signed integral types + (signed short, signed int, signed long) from "regular" integral types + (short, int, long) in the debugging information. There is some dis- + agreement as to how useful this feature is. In particular, gcc does + not support this. Also, only some debugging formats allow the + distinction to be passed on to a debugger. For now, we always just + use "short", "int", or "long" as the type name, for both the implicit + and explicitly signed types. This also makes life easier for the + gdb test suite since we don't have to account for the differences + in output depending upon what the compiler and debugging format + support. We will probably have to re-examine the issue when gdb + starts taking it's fundamental type information directly from the + debugging information supplied by the compiler. fnf@cygnus.com */ + +static struct type * +objc_create_fundamental_type (struct objfile *objfile, int typeid) +{ + register struct type *type = NULL; + + switch (typeid) + { + default: + /* FIXME: For now, if we are asked to produce a type not in this + language, create the equivalent of a C integer type with the + name "<?type?>". When all the dust settles from the type + reconstruction work, this should probably become an error. */ + type = init_type (TYPE_CODE_INT, + TARGET_INT_BIT / TARGET_CHAR_BIT, + 0, "<?type?>", objfile); + warning ("internal error: no C/C++ fundamental type %d", typeid); + break; + case FT_VOID: + type = init_type (TYPE_CODE_VOID, + TARGET_CHAR_BIT / TARGET_CHAR_BIT, + 0, "void", objfile); + break; + case FT_CHAR: + type = init_type (TYPE_CODE_INT, + TARGET_CHAR_BIT / TARGET_CHAR_BIT, + 0, "char", objfile); + break; + case FT_SIGNED_CHAR: + type = init_type (TYPE_CODE_INT, + TARGET_CHAR_BIT / TARGET_CHAR_BIT, + 0, "signed char", objfile); + break; + case FT_UNSIGNED_CHAR: + type = init_type (TYPE_CODE_INT, + TARGET_CHAR_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, "unsigned char", objfile); + break; + case FT_SHORT: + type = init_type (TYPE_CODE_INT, + TARGET_SHORT_BIT / TARGET_CHAR_BIT, + 0, "short", objfile); + break; + case FT_SIGNED_SHORT: + type = init_type (TYPE_CODE_INT, + TARGET_SHORT_BIT / TARGET_CHAR_BIT, + 0, "short", objfile); /* FIXME-fnf */ + break; + case FT_UNSIGNED_SHORT: + type = init_type (TYPE_CODE_INT, + TARGET_SHORT_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, "unsigned short", objfile); + break; + case FT_INTEGER: + type = init_type (TYPE_CODE_INT, + TARGET_INT_BIT / TARGET_CHAR_BIT, + 0, "int", objfile); + break; + case FT_SIGNED_INTEGER: + type = init_type (TYPE_CODE_INT, + TARGET_INT_BIT / TARGET_CHAR_BIT, + 0, "int", objfile); /* FIXME -fnf */ + break; + case FT_UNSIGNED_INTEGER: + type = init_type (TYPE_CODE_INT, + TARGET_INT_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, "unsigned int", objfile); + break; + case FT_LONG: + type = init_type (TYPE_CODE_INT, + TARGET_LONG_BIT / TARGET_CHAR_BIT, + 0, "long", objfile); + break; + case FT_SIGNED_LONG: + type = init_type (TYPE_CODE_INT, + TARGET_LONG_BIT / TARGET_CHAR_BIT, + 0, "long", objfile); /* FIXME -fnf */ + break; + case FT_UNSIGNED_LONG: + type = init_type (TYPE_CODE_INT, + TARGET_LONG_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, "unsigned long", objfile); + break; + case FT_LONG_LONG: + type = init_type (TYPE_CODE_INT, + TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, + 0, "long long", objfile); + break; + case FT_SIGNED_LONG_LONG: + type = init_type (TYPE_CODE_INT, + TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, + 0, "signed long long", objfile); + break; + case FT_UNSIGNED_LONG_LONG: + type = init_type (TYPE_CODE_INT, + TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, "unsigned long long", objfile); + break; + case FT_FLOAT: + type = init_type (TYPE_CODE_FLT, + TARGET_FLOAT_BIT / TARGET_CHAR_BIT, + 0, "float", objfile); + break; + case FT_DBL_PREC_FLOAT: + type = init_type (TYPE_CODE_FLT, + TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, + 0, "double", objfile); + break; + case FT_EXT_PREC_FLOAT: + type = init_type (TYPE_CODE_FLT, + TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, + 0, "long double", objfile); + break; + } + return (type); +} + + +/* Table mapping opcodes into strings for printing operators + and precedences of the operators. */ + +static const struct op_print objc_op_print_tab[] = + { + {",", BINOP_COMMA, PREC_COMMA, 0}, + {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, + {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, + {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, + {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0}, + {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0}, + {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 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_LOGICAL_NOT, PREC_PREFIX, 0}, + {"~", UNOP_COMPLEMENT, 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}, + {NULL, 0, 0, 0} +}; + +struct type ** const (objc_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_signed_char, + &builtin_type_unsigned_char, + &builtin_type_unsigned_short, + &builtin_type_unsigned_int, + &builtin_type_unsigned_long, + &builtin_type_unsigned_long_long, + &builtin_type_long_double, + &builtin_type_complex, + &builtin_type_double_complex, + 0 +}; + +const struct language_defn objc_language_defn = { + "objective-c", /* Language name */ + language_objc, + objc_builtin_types, + range_check_off, + type_check_off, + case_sensitive_on, + objc_parse, + objc_error, + evaluate_subexp_standard, + objc_printchar, /* Print a character constant */ + objc_printstr, /* Function to print string constant */ + objc_emit_char, + objc_create_fundamental_type, /* Create fundamental type in this language */ + c_print_type, /* Print a type using appropriate syntax */ + c_val_print, /* Print a value using appropriate syntax */ + c_value_print, /* Print a top-level value */ + {"", "", "", ""}, /* Binary format info */ + {"0%lo", "0", "o", ""}, /* Octal format info */ + {"%ld", "", "d", ""}, /* Decimal format info */ + {"0x%lx", "0x", "x", ""}, /* Hex format info */ + objc_op_print_tab, /* expression operators for printing */ + 1, /* c-style arrays */ + 0, /* String lower bound */ + &builtin_type_char, /* Type of string elements */ + LANG_MAGIC +}; + +/* + * ObjC: + * Following functions help construct Objective C message calls + */ + +struct selname /* for parsing Objective C */ + { + struct selname *next; + char *msglist_sel; + int msglist_len; + }; + +static int msglist_len; +static struct selname *selname_chain; +static char *msglist_sel; + +void +start_msglist(void) +{ + register struct selname *new = + (struct selname *) xmalloc (sizeof (struct selname)); + + new->next = selname_chain; + new->msglist_len = msglist_len; + new->msglist_sel = msglist_sel; + msglist_len = 0; + msglist_sel = (char *)xmalloc(1); + *msglist_sel = 0; + selname_chain = new; +} + +void +add_msglist(struct stoken *str, int addcolon) +{ + char *s, *p; + int len, plen; + + if (str == 0) { /* unnamed arg, or... */ + if (addcolon == 0) { /* variable number of args */ + msglist_len++; + return; + } + p = ""; + plen = 0; + } else { + p = str->ptr; + plen = str->length; + } + len = plen + strlen(msglist_sel) + 2; + s = (char *)xmalloc(len); + strcpy(s, msglist_sel); + strncat(s, p, plen); + free(msglist_sel); + msglist_sel = s; + if (addcolon) { + s[len-2] = ':'; + s[len-1] = 0; + msglist_len++; + } else + s[len-2] = '\0'; +} + +int +end_msglist(void) +{ + register int val = msglist_len; + register struct selname *sel = selname_chain; + register char *p = msglist_sel; + int selid; + + selname_chain = sel->next; + msglist_len = sel->msglist_len; + msglist_sel = sel->msglist_sel; + selid = lookup_child_selector(p); + if (!selid) + error("Can't find selector \"%s\"", p); + write_exp_elt_longcst (selid); + free(p); + write_exp_elt_longcst (val);/* Number of args */ + free(sel); + + return val; +} + +/* + * Function: specialcmp (char *a, char *b) + * + * Special strcmp: treats ']' and ' ' as end-of-string. + * Used for qsorting lists of objc methods (either by class or selector) + */ + +int specialcmp(char *a, char *b) +{ + while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']') + { + if (*a != *b) + return *a - *b; + a++, b++; + } + if (*a && *a != ' ' && *a != ']') + return 1; /* a is longer therefore greater */ + if (*b && *b != ' ' && *b != ']') + return -1; /* a is shorter therefore lesser */ + return 0; /* a and b are identical */ +} + +/* + * Function: compare_selectors (void *, void *) + * + * Comparison function for use with qsort. Arguments are symbols or msymbols + * Compares selector part of objc method name alphabetically. + */ + +static int +compare_selectors (a, b) + void *a; + void *b; +{ + char *aname, *bname; + + if ((aname = SYMBOL_SOURCE_NAME (*(struct symbol **) a)) == NULL || + (bname = SYMBOL_SOURCE_NAME (*(struct symbol **) b)) == NULL) + error ("internal: compare_selectors(1)"); + + if ((aname = strchr(aname, ' ')) == NULL || + (bname = strchr(bname, ' ')) == NULL) + error ("internal: compare_selectors(2)"); + + return specialcmp (aname+1, bname+1); +} + +/* + * Function: selectors_info (regexp, from_tty) + * + * Implements the "Info selectors" command. Takes an optional regexp arg. + * Lists all objective c selectors that match the regexp. Works by + * grepping thru all symbols for objective c methods. Output list is + * sorted and uniqued. + */ + +static void +selectors_info (char *regexp, int from_tty) +{ + struct objfile *objfile; + struct minimal_symbol *msymbol; + char *name; + char *val; + int matches = 0; + int maxlen = 0; + int ix; + char myregexp[2048]; + char asel[256]; + struct symbol **sym_arr; + int plusminus = 0; + + if (regexp == NULL) + strcpy(myregexp, ".*]"); /* null input, match all objc methods */ + else + { + if (*regexp == '+' || *regexp == '-') /* if regexp starts with +/- */ + { /* user wants only class methods or only instance methods */ + plusminus = *regexp++; + while (*regexp == ' ' || *regexp == '\t') + regexp++; + } + if (*regexp == '\0') + strcpy(myregexp, ".*]"); + else + { + strcpy(myregexp, regexp); + if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */ + myregexp[strlen(myregexp) - 1] = ']'; /* end of method name */ + else + strcat(myregexp, ".*]"); + } + } + + if (regexp != NULL) + if (0 != (val = re_comp (myregexp))) + error ("Invalid regexp (%s): %s", val, regexp); + + /* first time thru is JUST to get max length and count */ + ALL_MSYMBOLS (objfile, msymbol) + { + QUIT; + if ((name = SYMBOL_DEMANGLED_NAME (msymbol)) == NULL) + name = SYMBOL_NAME (msymbol); + if (name && + (name[0] == '-' || name[0] == '+') && + name[1] == '[') /* got a method name */ + { + if (plusminus && name[0] != plusminus) + continue; /* filter for class/instance methods */ + name = (char *) strchr(name+2, ' '); /* find selector part */ + if (regexp == NULL || re_exec(++name) != 0) + { + char *mystart = name; + char *myend = (char *) strchr(mystart, ']'); + + if (myend && (myend - mystart > maxlen)) + maxlen = myend - mystart; /* get longest selector */ + matches++; + } + } + } + if (matches) + { + printf_filtered ("Selectors matching \"%s\":\n\n", + regexp ? regexp : "*"); + + sym_arr = alloca (matches * sizeof (struct symbol *)); + matches = 0; + ALL_MSYMBOLS (objfile, msymbol) + { + QUIT; + if ((name = SYMBOL_DEMANGLED_NAME (msymbol)) == NULL) + name = SYMBOL_NAME (msymbol); + if (name && + (name[0] == '-' || name[0] == '+') && + name[1] == '[') /* got a method name */ + { + if (plusminus && name[0] != plusminus) + continue; /* filter for class/instance methods */ + name = (char *) strchr(name+2, ' '); /* find selector part */ + if (regexp == NULL || re_exec(++name) != 0) + sym_arr[matches++] = (struct symbol *) msymbol; + } + } + + qsort (sym_arr, matches, sizeof (struct minimal_symbol *), + compare_selectors); + asel[0] = 0; /* to prevent compare on first iteration */ + for (ix = 0; ix < matches; ix++) /* now do the output */ + { + char *p = asel; + + QUIT; + if ((name = SYMBOL_DEMANGLED_NAME (sym_arr[ix])) == NULL) + name = SYMBOL_NAME (sym_arr[ix]); + name = strchr (name, ' ') + 1; + if (p[0] && specialcmp(name, p) == 0) + continue; /* seen this one already (not unique) */ + + while (*name && *name != ']') /* copy selector part */ + *p++ = *name++; + *p++ = '\0'; + puts_filtered_tabular(asel, maxlen + 1, 0); /* print in columns */ + } + begin_line(); + } + else + printf_filtered ("No selectors matching \"%s\"\n", regexp ? regexp : "*"); +} + +/* + * Function: compare_classes (void *, void *) + * + * Comparison function for use with qsort. Arguments are symbols or msymbols + * Compares class part of objc method name alphabetically. + */ + +static int +compare_classes (a, b) + void *a; + void *b; +{ + char *aname, *bname; + + if ((aname = SYMBOL_SOURCE_NAME (*(struct symbol **) a)) == NULL || + (bname = SYMBOL_SOURCE_NAME (*(struct symbol **) b)) == NULL) + error ("internal: compare_classes(1)"); + + return specialcmp (aname+1, bname+1); +} + +/* + * Function: classes_info(regexp, from_tty) + * + * Implements the "info classes" command for objective c classes. + * Lists all objective c classes that match the optional regexp. + * Works by grepping thru the list of objective c methods. + * List will be sorted and uniqued (since one class may have many methods). + * BUGS: will not list a class that has no methods. + */ + +static void +classes_info (char *regexp, int from_tty) +{ + struct objfile *objfile; + struct minimal_symbol *msymbol; + char *name; + char *val; + int matches = 0; + int maxlen = 0; + int ix; + char myregexp[2048]; + char aclass[256]; + struct symbol **sym_arr; + + if (regexp == NULL) + strcpy(myregexp, ".* "); /* null input: match all objc classes */ + else + { + strcpy(myregexp, regexp); + if (myregexp[strlen(myregexp) - 1] == '$') + /* in the method name, the end of the class name is marked by ' ' */ + myregexp[strlen(myregexp) - 1] = ' '; + else + strcat(myregexp, ".* "); + } + + if (regexp != NULL) + if (0 != (val = re_comp (myregexp))) + error ("Invalid regexp (%s): %s", val, regexp); + + /* first time thru is JUST to get max length and count */ + ALL_MSYMBOLS (objfile, msymbol) + { + QUIT; + if ((name = SYMBOL_DEMANGLED_NAME (msymbol)) == NULL) + name = SYMBOL_NAME (msymbol); + if (name && + (name[0] == '-' || name[0] == '+') && + name[1] == '[') /* got a method name */ + if (regexp == NULL || re_exec(name+2) != 0) + { + char *mystart = name + 2; /* compute length of classname part */ + char *myend = (char *) strchr(mystart, ' '); + + if (myend && (myend - mystart > maxlen)) + maxlen = myend - mystart; + matches++; + } + } + if (matches) + { + printf_filtered ("Classes matching \"%s\":\n\n", + regexp ? regexp : "*"); + sym_arr = alloca (matches * sizeof (struct symbol *)); + matches = 0; + ALL_MSYMBOLS (objfile, msymbol) + { + QUIT; + if ((name = SYMBOL_DEMANGLED_NAME (msymbol)) == NULL) + name = SYMBOL_NAME (msymbol); + if (name && + (name[0] == '-' || name[0] == '+') && + name[1] == '[') /* got a method name */ + if (regexp == NULL || re_exec(name+2) != 0) + sym_arr[matches++] = (struct symbol *) msymbol; + } + + qsort (sym_arr, matches, sizeof (struct minimal_symbol *), + compare_classes); + aclass[0] = 0; /* to prevent compare on first iteration */ + for (ix = 0; ix < matches; ix++) /* now do the output */ + { + char *p = aclass; + + QUIT; + if ((name = SYMBOL_DEMANGLED_NAME (sym_arr[ix])) == NULL) + name = SYMBOL_NAME (sym_arr[ix]); + name += 2; + if (p[0] && specialcmp(name, p) == 0) + continue; /* seen this one already (not unique) */ + + while (*name && *name != ' ') /* copy class part of method name */ + *p++ = *name++; + *p++ = '\0'; + puts_filtered_tabular(aclass, maxlen + 1, 0); /* print in columns */ + } + begin_line(); + } + else + printf_filtered ("No classes matching \"%s\"\n", regexp ? regexp : "*"); +} + +/* + * Function: find_imps (char *selector, struct symbol **sym_arr) + * + * Input: a string representing a selector + * a pointer to an array of symbol pointers + * possibly a pointer to a symbol found by the caller. + * + * Output: number of methods that implement that selector. + * Side effects: The array of symbol pointers is filled with matching syms. + * + * By analogy with function "find_methods" (symtab.c), builds a list of + * symbols matching the ambiguous input, so that "decode_line_2" (symtab.c) + * can list them and ask the user to choose one or more. In this case the + * matches are objective c methods ("implementations") matching an objective + * c selector. + * + * Note that it is possible for a normal (c-style) function to have the + * same name as an objective c selector. To prevent the selector from + * eclipsing the function, we allow the caller (decode_line_1) to search + * for such a function first, and if it finds one, pass it in to us. We + * will then integrate it into the list. We also search for one here, + * among the minsyms. + * + * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be + * divided into two parts: debuggable (struct symbol) syms, + * and non_debuggable (struct minimal_symbol) syms. + * The debuggable ones will come first, before NUM_DEBUGGABLE + * (which will thus be the index of the first non-debuggable one). + */ + +/* + * Function: total_number_of_imps (char *selector); + * + * Input: a string representing a selector + * Output: number of methods that implement that selector. + * + * By analogy with function "total_number_of_methods", this allows + * decode_line_1 (symtab.c) to detect if there are objective c methods + * matching the input, and to allocate an array of pointers to them + * which can be manipulated by "decode_line_2" (also in symtab.c) + */ + +char * +parse_selector (char *method, char **selector) +{ + char *s1 = NULL; + char *s2 = NULL; + int found_quote = 0; + + char *nselector = NULL; + + CHECK (selector != NULL); + + s1 = method; + + while (isspace (*s1)) + s1++; + if (*s1 == '\'') + { + found_quote = 1; + s1++; + } + while (isspace (*s1)) + s1++; + + nselector = s1; + s2 = s1; + + for (;;) { + if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':')) + *s1++ = *s2; + else if (isspace (*s2)) + ; + else if ((*s2 == '\0') || (*s2 == '\'')) + break; + else + return NULL; + s2++; + } + *s1++ = '\0'; + + while (isspace (*s2)) + s2++; + if (found_quote) + { + if (*s2 == '\'') + s2++; + while (isspace (*s2)) + s2++; + } + + if (selector != NULL) + *selector = nselector; + + return s2; +} + +char * +parse_method (char *method, char *type, char **class, char **category, + char **selector) +{ + char *s1 = NULL; + char *s2 = NULL; + int found_quote = 0; + + char ntype = '\0'; + char *nclass = NULL; + char *ncategory = NULL; + char *nselector = NULL; + + CHECK (type != NULL); + CHECK (class != NULL); + CHECK (category != NULL); + CHECK (selector != NULL); + + s1 = method; + + while (isspace (*s1)) + s1++; + if (*s1 == '\'') + { + found_quote = 1; + s1++; + } + while (isspace (*s1)) + s1++; + + if ((s1[0] == '+') || (s1[0] == '-')) + ntype = *s1++; + + while (isspace (*s1)) + s1++; + + if (*s1 != '[') + return NULL; + s1++; + + nclass = s1; + while (isalnum (*s1) || (*s1 == '_')) + s1++; + + s2 = s1; + while (isspace (*s2)) + s2++; + + if (*s2 == '(') + { + s2++; + while (isspace (*s2)) + s2++; + ncategory = s2; + while (isalnum (*s2) || (*s2 == '_')) + s2++; + *s2++ = '\0'; + } + + /* truncate the class name now that we're not using the open paren */ + *s1++ = '\0'; + + nselector = s2; + s1 = s2; + + for (;;) { + if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':')) + *s1++ = *s2; + else if (isspace (*s2)) + ; + else if (*s2 == ']') + break; + else + return NULL; + s2++; + } + *s1++ = '\0'; + s2++; + + while (isspace (*s2)) + s2++; + if (found_quote) + { + if (*s2 != '\'') + return NULL; + s2++; + while (isspace (*s2)) + s2++; + } + + if (type != NULL) + *type = ntype; + if (class != NULL) + *class = nclass; + if (category != NULL) + *category = ncategory; + if (selector != NULL) + *selector = nselector; + + return s2; +} + +void +find_methods (struct symtab *symtab, + char type, const char *class, const char *category, + const char *selector, + struct symbol **syms, unsigned int *nsym, unsigned int *ndebug) +{ + struct objfile *objfile = NULL; + struct minimal_symbol *msymbol = NULL; + struct block *block = NULL; + struct symbol *sym = NULL; + + char *symname = NULL; + + char ntype = '\0'; + char *nclass = NULL; + char *ncategory = NULL; + char *nselector = NULL; + + unsigned int csym = 0; + unsigned int cdebug = 0; + + static char *tmp = NULL; + static unsigned int tmplen = 0; + + CHECK (nsym != NULL); + CHECK (ndebug != NULL); + + if (symtab) + block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK); + + ALL_MSYMBOLS (objfile, msymbol) + { + QUIT; + + if ((msymbol->type != mst_text) && (msymbol->type != mst_file_text)) + /* not a function or method */ + continue; + + if (symtab) + if ((SYMBOL_VALUE_ADDRESS (msymbol) < block->startaddr) || + (SYMBOL_VALUE_ADDRESS (msymbol) >= block->endaddr)) + /* not in the specified symtab */ + continue; + + symname = SYMBOL_DEMANGLED_NAME (msymbol); + if (symname == NULL) + symname = SYMBOL_NAME (msymbol); + if (symname == NULL) + continue; + + if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '[')) + /* not a method name */ + continue; + + while ((strlen (symname) + 1) >= tmplen) + { + tmplen = (tmplen == 0) ? 1024 : tmplen * 2; + tmp = xrealloc (tmp, tmplen); + } + strcpy (tmp, symname); + + if (parse_method (tmp, &ntype, &nclass, &ncategory, &nselector) == NULL) + continue; + + if ((type != '\0') && (ntype != type)) + continue; + + if ((class != NULL) && ((nclass == NULL) || (strcmp (class, nclass) != 0))) + continue; + + if ((category != NULL) && ((ncategory == NULL) || (strcmp (category, ncategory) != 0))) + continue; + + if ((selector != NULL) && ((nselector == NULL) || (strcmp (selector, nselector) != 0))) + continue; + + sym = find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol)); + if (sym != NULL) + { + const char *newsymname = SYMBOL_DEMANGLED_NAME (sym); + + if (newsymname == NULL) + newsymname = SYMBOL_NAME (sym); + if (strcmp (symname, newsymname) == 0) + { + /* found a high-level method sym: swap it into the + lower part of sym_arr (below num_debuggable) */ + if (syms != NULL) + { + syms[csym] = syms[cdebug]; + syms[cdebug] = sym; + } + csym++; + cdebug++; + } + else + { + warning ("debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring", + newsymname, symname); + if (syms != NULL) + syms[csym] = (struct symbol *) msymbol; + csym++; + } + } + else + { + /* found a non-debuggable method symbol */ + if (syms != NULL) + syms[csym] = (struct symbol *) msymbol; + csym++; + } + } + + if (nsym != NULL) + *nsym = csym; + if (ndebug != NULL) + *ndebug = cdebug; +} + +char *find_imps (struct symtab *symtab, struct block *block, + char *method, struct symbol **syms, unsigned int *nsym, + unsigned int *ndebug) +{ + char type = '\0'; + char *class = NULL; + char *category = NULL; + char *selector = NULL; + + unsigned int csym = 0; + unsigned int cdebug = 0; + + unsigned int ncsym = 0; + unsigned int ncdebug = 0; + + char *buf = NULL; + char *tmp = NULL; + + CHECK (nsym != NULL); + CHECK (ndebug != NULL); + + if (nsym != NULL) + *nsym = 0; + if (ndebug != NULL) + *ndebug = 0; + + buf = (char *) alloca (strlen (method) + 1); + strcpy (buf, method); + tmp = parse_method (buf, &type, &class, &category, &selector); + + if (tmp == NULL) { + + struct symtab *sym_symtab = NULL; + struct symbol *sym = NULL; + struct minimal_symbol *msym = NULL; + + strcpy (buf, method); + tmp = parse_selector (buf, &selector); + + if (tmp == NULL) + return NULL; + + sym = lookup_symbol (selector, block, VAR_NAMESPACE, 0, &sym_symtab); + if (sym != NULL) + { + if (syms) + syms[csym] = sym; + csym++; + cdebug++; + } + + if (sym == NULL) + msym = lookup_minimal_symbol (selector, 0, 0); + + if (msym != NULL) + { + if (syms) + syms[csym] = msym; + csym++; + } + } + + if (syms != NULL) + find_methods (symtab, type, class, category, selector, syms + csym, &ncsym, &ncdebug); + else + find_methods (symtab, type, class, category, selector, NULL, &ncsym, &ncdebug); + + /* If we didn't find any methods, just return. */ + if (ncsym == 0 && ncdebug == 0) + return method; + + /* Take debug symbols from the second batch of symbols and swap them + * with debug symbols from the first batch. Repeat until either the + * second section is out of debug symbols or the first section is + * full of debug symbols. Either way we have all debug symbols + * packed to the beginning of the buffer. */ + + if (syms != NULL) + { + while ((cdebug < csym) && (ncdebug > 0)) + { + struct symbol *s = NULL; + + unsigned int i = cdebug; /* first non-debugging symbol */ + unsigned int j = csym + ncdebug -1; /* last of second batch of debug symbols */ + + s = syms[j]; + syms[j] = syms[i]; + syms[i] = s; + + /* We've moved a symbol from the second debug section to the first one. */ + cdebug++; + ncdebug--; + } + } + + csym += ncsym; + cdebug += ncdebug; + + if (nsym != NULL) + *nsym = csym; + if (ndebug != NULL) + *ndebug = cdebug; + + if (syms == NULL) + return method + (tmp - buf); + + if (csym > 1) + { + /* sort debuggable symbols */ + if (cdebug > 1) + qsort (syms, cdebug, sizeof (struct minimal_symbol *), compare_classes); + + /* sort minimal_symbols */ + if ((csym - cdebug) > 1) + qsort (&syms[cdebug], csym - cdebug, sizeof (struct minimal_symbol *), compare_classes); + } + syms[csym] = 0; /* terminate the sym_arr list */ + + return method + (tmp - buf); +} + +void +print_object_command (char *args, int from_tty) +{ + struct value *object, *function, *description; + CORE_ADDR string_addr; + int i = 0; + char c = -1; + + if (!args || !*args) + error ("The 'print-object' command requires an argument (an Objective-C object)"); + + { + struct expression *expr = parse_expression (args); + register struct cleanup *old_chain = make_cleanup (free_current_contents, &expr); + int pc = 0; + +#if 1 + object = expr->language_defn->evaluate_exp (builtin_type_void_data_ptr, + expr, &pc, EVAL_NORMAL); +#else + object = evaluate_subexp (builtin_type_void_data_ptr, expr, &pc, EVAL_NORMAL); +#endif + do_cleanups (old_chain); + } + + if (!(function = find_function_in_inferior ("_NSPrintForDebugger"))) + error ("Unable to locate _NSPrintForDebugger in child process"); + + description = call_function_by_hand (function, 1, &object); + + if ((string_addr = value_as_long (description)) == 0) + error ("object returns null description"); + + read_memory (string_addr + i++, &c, 1); + if (c != '\0') + do + { /* read and print characters up to EOS */ + QUIT; + printf_filtered ("%c", c); + read_memory (string_addr + i++, &c, 1); + } while (c != 0); + else + printf_filtered("<object returns empty description>"); + printf_filtered ("\n"); +} + +/* The data structure 'methcalls' is used to detect method calls + * (thru ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.), + * and ultimately find the method being called. + */ + +struct objc_methcall { + char *name; + CORE_ADDR (*stop_at) (CORE_ADDR); /* should return instance method to be called */ + CORE_ADDR begin; /* start of pc range corresponding to method invocation */ + CORE_ADDR end; /* end of pc range corresponding to method invocation */ +}; + +static int resolve_msgsend PARAMS ((CORE_ADDR pc, CORE_ADDR *new_pc)); +static int resolve_msgsend_stret PARAMS ((CORE_ADDR pc, CORE_ADDR *new_pc)); +static int resolve_msgsend_super PARAMS ((CORE_ADDR pc, CORE_ADDR *new_pc)); +static int resolve_msgsend_super_stret PARAMS ((CORE_ADDR pc, CORE_ADDR *new_pc)); + +static struct objc_methcall methcalls[] = { + { "_objc_msgSend", resolve_msgsend, 0, 0}, + { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0}, + { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0}, + { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0}, + { "_objc_getClass", NULL, 0, 0}, + { "_objc_getMetaClass", NULL, 0, 0} +}; + +#define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0])) + +/* The following function, "find_objc_msgsend", fills in the data structure + * "objc_msgs" by finding the addresses of each of the (currently four) + * functions that it holds (of which objc_msgSend is the first). This + * must be called each time symbols are loaded, in case the functions + * have moved for some reason. + */ + +void +find_objc_msgsend (void) +{ + unsigned int i; + for (i = 0; i < nmethcalls; i++) { + + struct minimal_symbol *func; + + /* try both with and without underscore */ + func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL); + if ((func == NULL) && (methcalls[i].name[0] == '_')) { + func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL); + } + if (func == NULL) { + methcalls[i].begin = 0; + methcalls[i].end = 0; + continue; + } + + methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func); + do { + methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func); + } while (methcalls[i].begin == methcalls[i].end); + } +} + +/* find_objc_msgcall (replaces pc_off_limits) + * + * ALL that this function now does is to determine whether the input + * address ("pc") is the address of one of the Objective C message + * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and + * if so, it returns the address of the method that will be called. + * + * The old function "pc_off_limits" used to do a lot of other things + * in addition, such as detecting shared library jump stubs and + * returning the address of the shlib function that would be called. + * That functionality has been moved into the SKIP_TRAMPOLINE_CODE + * and IN_SOLIB_TRAMPOLINE macros, which are resolved in the target- + * dependent modules. + */ + +struct objc_submethod_helper_data { + CORE_ADDR (*f) (CORE_ADDR, CORE_ADDR *); + CORE_ADDR pc; + CORE_ADDR *new_pc; +}; + +int +find_objc_msgcall_submethod_helper (PTR arg) +{ + struct objc_submethod_helper_data *s = (struct objc_submethod_helper_data *) arg; + if (s->f (s->pc, s->new_pc) == 0) { + return 1; + } else { + return 0; + } +} + +int +find_objc_msgcall_submethod (f, pc, new_pc) + CORE_ADDR (*f) (CORE_ADDR, CORE_ADDR *); + CORE_ADDR pc; + CORE_ADDR *new_pc; +{ + struct objc_submethod_helper_data s; + + s.f = f; + s.pc = pc; + s.new_pc = new_pc; + + if (catch_errors (find_objc_msgcall_submethod_helper, + (PTR) &s, + "Unable to determine target of Objective-C method call (ignoring):\n", + RETURN_MASK_ALL) == 0) { + return 1; + } else { + return 0; + } +} + +int +find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc) +{ + unsigned int i; + + find_objc_msgsend (); + if (new_pc != NULL) { *new_pc = 0; } + + for (i = 0; i < nmethcalls; i++) { + if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end)) { + if (methcalls[i].stop_at != NULL) { + return find_objc_msgcall_submethod (methcalls[i].stop_at, pc, new_pc); + } else { + return 0; + } + } + } + return 0; +} + +void +_initialize_objc_language (void) +{ + add_language (&objc_language_defn); + add_info ("selectors", selectors_info, /* INFO SELECTORS command */ + "All Objective C selectors, or those matching REGEXP."); + add_info ("classes", classes_info, /* INFO CLASSES command */ + "All Objective C classes, or those matching REGEXP."); + add_com ("print-object", class_vars, print_object_command, + "Ask an Objective-C object to print itself.\n"); + add_com_alias ("po", "print-object", class_vars, 1); +} + +#if defined (__powerpc__) || defined (__ppc__) +static unsigned long FETCH_ARGUMENT (int i) +{ + return read_register (3 + i); +} +#elif defined (__i386__) +static unsigned long FETCH_ARGUMENT (int i) +{ + CORE_ADDR stack = read_register (SP_REGNUM); + return read_memory_unsigned_integer (stack + (4 * (i + 1)), 4); +} +#elif defined (__sparc__) +static unsigned long FETCH_ARGUMENT (int i) +{ + return read_register (O0_REGNUM + i); +} +#elif defined (__hppa__) || defined (__hppa) +static unsigned long FETCH_ARGUMENT (int i) +{ + return read_register (R0_REGNUM + 26 - i); +} +#else +#error unknown architecture +#endif + +#if defined (__hppa__) || defined (__hppa) +static CORE_ADDR CONVERT_FUNCPTR (CORE_ADDR pc) +{ + if (pc & 0x2) { + pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, 4); + } + return pc; +} +#else +static CORE_ADDR CONVERT_FUNCPTR (CORE_ADDR pc) +{ + return pc; +} +#endif + +static void +read_objc_method (CORE_ADDR addr, struct objc_method *method) +{ + method->name = read_memory_unsigned_integer (addr, 4); + method->types = read_memory_unsigned_integer (addr + 4, 4); + method->imp = read_memory_unsigned_integer (addr + 8, 4); +} + +static +unsigned long read_objc_methlist_nmethods (CORE_ADDR addr) +{ + return read_memory_unsigned_integer (addr + 4, 4); +} + +static void +read_objc_methlist_method (CORE_ADDR addr, unsigned long num, + struct objc_method *method) +{ + CHECK_FATAL (num < read_objc_methlist_nmethods (addr)); + read_objc_method (addr + 8 + (12 * num), method); +} + +static void +read_objc_object (CORE_ADDR addr, struct objc_object *object) +{ + object->isa = read_memory_unsigned_integer (addr, 4); +} + +static void +read_objc_super (CORE_ADDR addr, struct objc_super *super) +{ + super->receiver = read_memory_unsigned_integer (addr, 4); + super->class = read_memory_unsigned_integer (addr + 4, 4); +}; + +static void +read_objc_class (CORE_ADDR addr, struct objc_class *class) +{ + class->isa = read_memory_unsigned_integer (addr, 4); + class->super_class = read_memory_unsigned_integer (addr + 4, 4); + class->name = read_memory_unsigned_integer (addr + 8, 4); + class->version = read_memory_unsigned_integer (addr + 12, 4); + class->info = read_memory_unsigned_integer (addr + 16, 4); + class->instance_size = read_memory_unsigned_integer (addr + 18, 4); + class->ivars = read_memory_unsigned_integer (addr + 24, 4); + class->methods = read_memory_unsigned_integer (addr + 28, 4); + class->cache = read_memory_unsigned_integer (addr + 32, 4); + class->protocols = read_memory_unsigned_integer (addr + 36, 4); +} + +CORE_ADDR +find_implementation_from_class (CORE_ADDR class, CORE_ADDR sel) +{ + CORE_ADDR subclass = class; + + while (subclass != 0) { + + struct objc_class class_str; + unsigned mlistnum = 0; + + read_objc_class (subclass, &class_str); + + for (;;) { + CORE_ADDR mlist; + unsigned long nmethods; + unsigned long i; + + mlist = read_memory_unsigned_integer (class_str.methods + (4 * mlistnum), 4); + if (mlist == 0) { break; } + + nmethods = read_objc_methlist_nmethods (mlist); + + for (i = 0; i < nmethods; i++) { + struct objc_method meth_str; + read_objc_methlist_method (mlist, i, &meth_str); + +#if 0 + fprintf (stderr, "checking method 0x%lx against selector 0x%lx\n", meth_str.name, sel); +#endif + + if (meth_str.name == sel) { + return CONVERT_FUNCPTR (meth_str.imp); + } + } + + mlistnum++; + } + + subclass = class_str.super_class; + } + + return 0; +} + +CORE_ADDR +find_implementation (CORE_ADDR object, CORE_ADDR sel) +{ + struct objc_object ostr; + + if (object == 0) { return 0; } + read_objc_object (object, &ostr); + if (ostr.isa == 0) { return 0; } + + return find_implementation_from_class (ostr.isa, sel); +} + +static int +resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc) +{ + CORE_ADDR object; + CORE_ADDR sel; + CORE_ADDR res; + + object = FETCH_ARGUMENT (0); + sel = FETCH_ARGUMENT (1); + + res = find_implementation (object, sel); + if (new_pc != 0) { *new_pc = res; } + if (res == 0) { return 1; } + return 0; +} + +static int +resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc) +{ + CORE_ADDR object; + CORE_ADDR sel; + CORE_ADDR res; + + object = FETCH_ARGUMENT (1); + sel = FETCH_ARGUMENT (2); + + res = find_implementation (object, sel); + if (new_pc != 0) { *new_pc = res; } + if (res == 0) { return 1; } + return 0; +} + +static int +resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc) +{ + struct objc_super sstr; + + CORE_ADDR super; + CORE_ADDR sel; + CORE_ADDR res; + + super = FETCH_ARGUMENT (0); + sel = FETCH_ARGUMENT (1); + + read_objc_super (super, &sstr); + if (sstr.class == 0) { return 0; } + + res = find_implementation_from_class (sstr.class, sel); + if (new_pc != 0) { *new_pc = res; } + if (res == 0) { return 1; } + return 0; +} + +static int +resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc) +{ + struct objc_super sstr; + + CORE_ADDR super; + CORE_ADDR sel; + CORE_ADDR res; + + super = FETCH_ARGUMENT (1); + sel = FETCH_ARGUMENT (2); + + read_objc_super (super, &sstr); + if (sstr.class == 0) { return 0; } + + res = find_implementation_from_class (sstr.class, sel); + if (new_pc != 0) { *new_pc = res; } + if (res == 0) { return 1; } + return 0; +} diff --git a/gdb/objc-lang.h b/gdb/objc-lang.h new file mode 100644 index 0000000..7141e50 --- /dev/null +++ b/gdb/objc-lang.h @@ -0,0 +1,61 @@ +/* Objective C language support definitions for GDB, the GNU debugger. + Copyright 1992 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#ifdef __STDC__ /* Forward decls for prototypes */ +struct value; +#endif + +extern int +objc_parse PARAMS ((void)); /* Defined in c-exp.y */ + +extern void +objc_error PARAMS ((char *)); /* Defined in c-exp.y */ + +extern void /* Defined in c-typeprint.c */ +c_print_type PARAMS ((struct type *, char *, struct ui_file *, int, int)); + +extern int +c_val_print PARAMS ((struct type *, char *, int, CORE_ADDR, struct ui_file *, int, int, + int, enum val_prettyprint)); + +extern int +c_value_print PARAMS ((struct value *, struct ui_file *, int, + enum val_prettyprint)); + +extern CORE_ADDR lookup_objc_class PARAMS ((char *classname)); +extern int lookup_child_selector PARAMS ((char *methodname)); + +char *objc_demangle PARAMS ((const char *mangled)); + +int find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc); + +char *parse_selector +PARAMS ((char *method, char **selector)); + +char *parse_method +PARAMS ((char *method, char *type, char **class, char **category, char **selector)); + +void find_methods +PARAMS ((struct symtab *symtab, + char type, const char *class, const char *category, const char *selector, + struct symbol **syms, unsigned int *nsym, unsigned int *ndebug)); + +char *find_imps +PARAMS ((struct symtab *symtab, struct block *block, + char *method, struct symbol **syms, unsigned int *nsym, unsigned int *ndebug)); |