[RFA] Add ObjC recognition to linespec.c [5/5]

Adam Fedor
2003-01-03T23:31:04Z

[-- Attachment #1: Type: text/plain, Size: 265 bytes --]

I know that linespec has been changing a lot lately, and I'm not sure if
it's finished changing yet. So this is my attempt to insert ObjC
handling into linespec. Actually Klee Dienes really did most of these
changes, and I probably bastardized those as well...

[-- Attachment #2: objc23.patch --]
[-- Type: text/plain, Size: 6732 bytes --]

2003-01-03 Adam Fedor <fedor@gnu.org>

* linespec.c (decode_objc): New function to decode ObjC calls
(decode_line_1): Check for ObjC calls (using decode_objc)

Index: linespec.c
===================================================================
RCS file: /cvs/src/src/gdb/linespec.c,v
retrieving revision 1.32
diff -u -p -r1.32 linespec.c
--- linespec.c 19 Dec 2002 18:56:14 -0000 1.32
+++ linespec.c 3 Jan 2003 22:56:54 -0000
@@ -37,6 +37,11 @@

extern char *operator_chars (char *, char **);

+/* From objc-lang.h. Included here to avoid conflict with other prototypes */
+extern char *find_imps (struct symtab *symtab, struct block *block,
+ char *method, struct symbol **syms, unsigned int *nsym,
+ unsigned int *ndebug);
+
/* Prototypes for local functions */

static void initialize_defaults (struct symtab **default_symtab,
@@ -48,6 +53,12 @@ static struct symtabs_and_lines decode_i

static char *locate_first_half (char **argptr, int *is_quote_enclosed);

+static struct symtabs_and_lines decode_objc (char **argptr,
+ int funfirstline,
+ struct symtab *file_symtab,
+ char ***canonical,
+ char *saved_arg);
+
static struct symtabs_and_lines decode_compound (char **argptr,
int funfirstline,
char ***canonical,
@@ -568,6 +579,7 @@ decode_line_1 (char **argptr, int funfir
int is_quoted;
/* Is part of *ARGPTR is enclosed in double quotes? */
int is_quote_enclosed;
+ int is_objc_method = 0;
char *saved_arg = *argptr;

init_sal (&val); /* initialize to zeroes */
@@ -596,6 +608,24 @@ decode_line_1 (char **argptr, int funfir

p = locate_first_half (argptr, &is_quote_enclosed);

+ /* Check if this is an Objective-C method. */
+ if (*p && (p[0] == ':') && (strchr ("+-", p[1]) != NULL)
+ && (p[2] == '['))
+ {
+ is_objc_method = 1;
+ paren_pointer = NULL; /* Probably just a category name. Ignore it */
+ }
+
+ /* Is it an Objective-C selector? */
+
+ {
+ struct symtabs_and_lines values;
+ values = decode_objc (argptr, funfirstline, NULL,
+ canonical, saved_arg);
+ if (values.sals != NULL)
+ return values;
+ }
+
/* Does it look like there actually were two parts? */

if ((p[0] == ':' || p[0] == '.') && paren_pointer == NULL)
@@ -669,13 +699,21 @@ decode_line_1 (char **argptr, int funfir
Find the next token (everything up to end or next whitespace). */

if (**argptr == '$') /* May be a convenience variable */
- p = skip_quoted (*argptr + (((*argptr)[1] == '$') ? 2 : 1)); /* One or two $ chars possible */
+ {
+ /* One or two $ chars possible */
+ p = skip_quoted (*argptr + (((*argptr)[1] == '$') ? 2 : 1));
+ }
else if (is_quoted)
{
p = skip_quoted (*argptr);
if (p[-1] != '\'')
error ("Unmatched single quote.");
}
+ else if (is_objc_method)
+ {
+ /* allow word separators in method names for Obj-C */
+ p = skip_quoted_chars (*argptr, NULL, "");
+ }
else if (paren_pointer != NULL)
{
p = paren_pointer + 1;
@@ -952,6 +990,13 @@ locate_first_half (char **argptr, int *i
error ("malformed template specification in command");
p = temp_end;
}
+ /* Check for a colon and a plus or minus and a [ (which
+ indicates an Objective-C method) */
+ if (*p && (p[0] == ':') && (strchr ("+-", p[1]) != NULL)
+ && (p[2] == '['))
+ {
+ break;
+ }
/* Check for the end of the first half of the linespec. End of line,
a tab, a double colon or the last single colon, or a space. But
if enclosed in double quotes we do not break on enclosed spaces */
@@ -993,6 +1038,98 @@ locate_first_half (char **argptr, int *i
}

\f
+
+struct symtabs_and_lines
+decode_objc (char **argptr, int funfirstline, struct symtab *file_symtab,
+ char ***canonical, char *saved_arg)
+{
+ /* here's where we recognise an Objective-C Selector. An
+ * Objective C selector may be implemented by more than one
+ * class, therefore it may represent more than one
+ * method/function. This gives us a situation somewhat
+ * analogous to C++ overloading. If there's more than one
+ * method that could represent the selector, then use some of
+ * the existing C++ code to let the user choose one.
+ */
+
+ struct symtabs_and_lines values;
+ struct symbol **sym_arr = NULL;
+ struct symbol *sym = NULL;
+ char *copy = NULL;
+ struct block *block = NULL;
+ int i1 = 0;
+ int i2 = 0;
+
+ values.sals = NULL;
+ values.nelts = 0;
+
+ if (file_symtab != NULL)
+ block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab), STATIC_BLOCK);
+ else
+ block = get_selected_block (0);
+
+ copy = find_imps (file_symtab, block, *argptr, NULL, &i1, &i2);
+
+ if (i1 > 0)
+ {
+ sym_arr = (struct symbol **) alloca ((i1 + 1) * sizeof (struct symbol *));
+ sym_arr[i1] = 0;
+
+ copy = find_imps (file_symtab, block, *argptr, sym_arr, &i1, &i2);
+ *argptr = copy;
+ }
+
+ /* i1 now represents the TOTAL number of matches found...
+ i2 represents how many HIGH-LEVEL (struct symbol) matches,
+ which will come first in the sym_arr array. Any low-level
+ (minimal_symbol) matches will follow those. */
+
+ if (i1 == 1)
+ {
+ if (i2 > 0)
+ {
+ /* already a struct symbol */
+ sym = sym_arr[0];
+ }
+ else
+ {
+ sym = find_pc_function (SYMBOL_VALUE_ADDRESS (sym_arr[0]));
+ if ((sym != NULL) && strcmp (SYMBOL_NAME (sym_arr[0]), SYMBOL_NAME (sym)) != 0)
+ {
+ warning ("debugging symbol \"%s\" does not match selector; ignoring", SYMBOL_NAME (sym));
+ sym = NULL;
+ }
+ }
+
+ values.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
+ values.nelts = 1;
+
+ if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ {
+ /* canonicalize this, so it remains resolved for dylib loads */
+ values.sals[0] = find_function_start_sal (sym, funfirstline);
+ build_canonical_line_spec (values.sals, SYMBOL_SOURCE_NAME (sym), canonical);
+ }
+ else
+ {
+ /* the only match was a non-debuggable symbol */
+ values.sals[0].symtab = 0;
+ values.sals[0].line = 0;
+ values.sals[0].end = 0;
+ values.sals[0].pc = SYMBOL_VALUE_ADDRESS (sym_arr[0]);
+ }
+ return values;
+ }
+
+ if (i1 > 1)
+ {
+ /* more than one match -- user must choose one or more */
+ return decode_line_2 (sym_arr, i2, funfirstline, canonical);
+ //return select_symbols (sym_arr, i1, i2, funfirstline, canonical);
+ }
+
+ return values;
+}

/* This handles C++ and Java compound data structures. P should point
at the first component separator, i.e. double-colon or period. */