2004-02-09 Elena Zannoni <ezannoni@redhat.com>
authorElena Zannoni <ezannoni@kwikemart.cygnus.com>
Mon, 9 Feb 2004 22:29:21 +0000 (22:29 +0000)
committerElena Zannoni <ezannoni@kwikemart.cygnus.com>
Mon, 9 Feb 2004 22:29:21 +0000 (22:29 +0000)
* linespec.c (decode_line_1, locate_first_half)
(decode_compound, lookup_prefix_sym): Update comments. Delete old
commented out code.

gdb/ChangeLog
gdb/linespec.c

index 5ef59fc682bfb6d3b89dbc0c7d912ae48f5befb3..4b193fd6140b817dd3beafb0a2402fc3fbd148e9 100644 (file)
@@ -1,3 +1,9 @@
+2004-02-09  Elena Zannoni  <ezannoni@redhat.com>
+
+       * linespec.c (decode_line_1, locate_first_half)
+       (decode_compound, lookup_prefix_sym): Update comments. Delete old
+       commented out code.
+
 2004-02-09  Daniel Jacobowitz  <drow@mvista.com>
 
        * cp-namespace.c (check_one_possible_namespace_symbol): Don't use
index e16e96ea16e9316e696e2f1ee5b20e0f918a4a36..d362f1cc5f0b3803eb912feaa84acf078e044ee4 100644 (file)
@@ -694,7 +694,11 @@ decode_line_1 (char **argptr, int funfirstline, struct symtab *default_symtab,
   /* Check to see if it's a multipart linespec (with colons or
      periods).  */
 
-  /* Locate the end of the first half of the linespec.  */
+  /* Locate the end of the first half of the linespec.
+     After the call, for instance, if the argptr string is "foo.c:123"
+     p will point at "123".  If there is only one part, like "foo", p
+     will point to "". If this is a C++ name, like "A::B::foo", p will
+     point to "::B::foo". Argptr is not changed by this call.  */
 
   p = locate_first_half (argptr, &is_quote_enclosed);
 
@@ -723,8 +727,13 @@ decode_line_1 (char **argptr, int funfirstline, struct symtab *default_symtab,
       if (is_quoted)
        *argptr = *argptr + 1;
       
-      /* Is it a C++ or Java compound data structure?  */
-
+      /* Is it a C++ or Java compound data structure?
+        The check on p[1] == ':' is capturing the case of "::",
+        since p[0]==':' was checked above.  
+        Note that the call to decode_compound does everything
+        for us, including the lookup on the symbol table, so we
+        can return now. */
+       
       if (p[0] == '.' || p[1] == ':')
        return decode_compound (argptr, funfirstline, canonical,
                                saved_arg, p);
@@ -954,7 +963,9 @@ decode_indirect (char **argptr)
 /* Locate the first half of the linespec, ending in a colon, period,
    or whitespace.  (More or less.)  Also, check to see if *ARGPTR is
    enclosed in double quotes; if so, set is_quote_enclosed, advance
-   ARGPTR past that and zero out the trailing double quote.  */
+   ARGPTR past that and zero out the trailing double quote.
+   If ARGPTR is just a simple name like "main", p will point to ""
+   at the end.  */
 
 static char *
 locate_first_half (char **argptr, int *is_quote_enclosed)
@@ -1141,7 +1152,9 @@ decode_objc (char **argptr, int funfirstline, struct symtab *file_symtab,
 }
 
 /* This handles C++ and Java compound data structures.  P should point
-   at the first component separator, i.e. double-colon or period.  */
+   at the first component separator, i.e. double-colon or period.  As
+   an example, on entrance to this function we could have ARGPTR
+   pointing to "AAA::inA::fun" and P pointing to "::inA::fun".  */
 
 static struct symtabs_and_lines
 decode_compound (char **argptr, int funfirstline, char ***canonical,
@@ -1149,9 +1162,6 @@ decode_compound (char **argptr, int funfirstline, char ***canonical,
 {
   struct symtabs_and_lines values;
   char *p2;
-#if 0
-  char *q, *q1;
-#endif
   char *saved_arg2 = *argptr;
   char *temp_end;
   struct symbol *sym;
@@ -1162,9 +1172,10 @@ decode_compound (char **argptr, int funfirstline, char ***canonical,
   struct symbol **sym_arr;
   struct type *t;
 
-  /* First check for "global" namespace specification,
-     of the form "::foo".  If found, skip over the colons
-     and jump to normal symbol processing.  */
+  /* First check for "global" namespace specification, of the form
+     "::foo".  If found, skip over the colons and jump to normal
+     symbol processing.  I.e. the whole line specification starts with
+     "::" (note the condition that *argptr == p). */
   if (p[0] == ':' 
       && ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t')))
     saved_arg2 += 2;
@@ -1190,10 +1201,35 @@ decode_compound (char **argptr, int funfirstline, char ***canonical,
      "B::C" separately as a symbol in the previous example.  */
 
   p2 = p;              /* Save for restart.  */
+
+  /* This is very messy. Following the example above we have now the
+     following pointers:
+     p -> "::inA::fun"
+     argptr -> "AAA::inA::fun
+     saved_arg -> "AAA::inA::fun
+     saved_arg2 -> "AAA::inA::fun
+     p2 -> "::inA::fun". */
+
+  /* In the loop below, with these strings, we'll make 2 passes, each
+     is marked in comments.*/
+
   while (1)
     {
+
+      /* Start of lookup in the symbol tables. */
+
+      /* Lookup in the symbol table the substring between argptr and
+        p. Note, this call changes the value of argptr.  */
+      /* PASS1: Before the call, argptr->"AAA::inA::fun",
+        p->"::inA::fun".  After the call: argptr->"inA::fun", p
+        unchanged.  */
+      /* PASS2: Before the call, argptr->"AAA::inA::fun", p->"::fun".
+        After the call: argptr->"fun", p->"::fun".  */
       sym_class = lookup_prefix_sym (argptr, p);
 
+      /* PASS1: assume sym_class == NULL. Skip the whole if-stmt. */
+      /* PASS2: assume sym_class has been found, i.e. "AAA::inA" is a
+        class. Enter the if-stmt.  */
       if (sym_class &&
          (t = check_typedef (SYMBOL_TYPE (sym_class)),
           (TYPE_CODE (t) == TYPE_CODE_STRUCT
@@ -1211,51 +1247,54 @@ decode_compound (char **argptr, int funfirstline, char ***canonical,
            }
          else
            {
+             /* PASS2: at this point argptr->"fun".  */
              p = *argptr;
              while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':')
                p++;
+             /* PASS2: at this point p->"".  String ended.  */
            }
-/*
-   q = operator_chars (*argptr, &q1);
-   if (q1 - q)
-   {
-   char *opname;
-   char *tmp = alloca (q1 - q + 1);
-   memcpy (tmp, q, q1 - q);
-   tmp[q1 - q] = '\0';
-   opname = cplus_mangle_opname (tmp, DMGL_ANSI);
-   if (opname == NULL)
-   {
-   cplusplus_error (saved_arg, "no mangling for \"%s\"\n", tmp);
-   }
-   copy = (char*) alloca (3 + strlen(opname));
-   sprintf (copy, "__%s", opname);
-   p = q1;
-   }
-   else
- */
-         {
-           copy = (char *) alloca (p - *argptr + 1);
-           memcpy (copy, *argptr, p - *argptr);
-           copy[p - *argptr] = '\0';
-           if (p != *argptr
-               && copy[p - *argptr - 1]
-               && strchr (get_gdb_completer_quote_characters (),
-                          copy[p - *argptr - 1]) != NULL)
-             copy[p - *argptr - 1] = '\0';
-         }
+
+         /* Allocate our own copy of the substring between argptr and
+            p. */
+         copy = (char *) alloca (p - *argptr + 1);
+         memcpy (copy, *argptr, p - *argptr);
+         copy[p - *argptr] = '\0';
+         if (p != *argptr
+             && copy[p - *argptr - 1]
+             && strchr (get_gdb_completer_quote_characters (),
+                        copy[p - *argptr - 1]) != NULL)
+           copy[p - *argptr - 1] = '\0';
+
+         /* PASS2: At this point copy->"fun", p->"" */
 
          /* No line number may be specified.  */
          while (*p == ' ' || *p == '\t')
            p++;
          *argptr = p;
 
+         /* Look for copy as a method of sym_class. */
+         /* PASS2: at this point copy->"fun", sym_class is "AAA:inA".
+            This concludes the scanning of the string for possible
+            components matches.  If we find it here, we return. If
+            not, and we are at the and of the string, we'll get out
+            of the loop and lookup the whole string in the symbol
+            tables.  */
+
          return find_method (funfirstline, canonical, saved_arg,
                              copy, t, sym_class);
-       }
+       } /* End if symbol found */
 
+      /* End of lookup in the symbol tables.  */
+
+      /* Prepare for next run through the loop.  */
       /* Move pointer up to next possible class/namespace token.  */
+
       p = p2 + 1;      /* Restart with old value +1.  */
+
+      /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
+        i.e. if there is a double-colon, p will now point to the
+        second colon. */
+
       /* Move pointer ahead to next double-colon.  */
       while (*p && (p[0] != ' ') && (p[0] != '\t') && (p[0] != '\''))
        {
@@ -1266,6 +1305,14 @@ decode_compound (char **argptr, int funfirstline, char ***canonical,
                error ("malformed template specification in command");
              p = temp_end;
            }
+         /* Note that, since, at the start of this loop, p would be
+            pointing to the second colon in a double-colon, we only
+            satisfy the condition below if there is another
+            double-colon to the right (after). I.e. there is another
+            component that can be a class or a namespace. I.e, if at
+            the beginning of this loop (PASS1), we had
+            p->":inA::fun", we'll trigger this when p has been
+            advanced to point to "::fun".  */
          else if ((p[0] == ':') && (p[1] == ':'))
            break;      /* Found double-colon.  */
          else
@@ -1273,10 +1320,20 @@ decode_compound (char **argptr, int funfirstline, char ***canonical,
        }
 
       if (*p != ':')
-       break;          /* Out of the while (1).  */
-
-      p2 = p;          /* Save restart for next time around.  */
-      *argptr = saved_arg2;    /* Restore argptr.  */
+       break;          /* Out of the while (1).  This would happen
+                          for instance if we have looked up
+                          unsuccessfully all the components of the
+                          string, and p->"".  */
+
+      /* We get here if p points to ' ', '\t', '\'', "::" or ""(i.e
+        string ended). */
+      /* Save restart for next time around.  */
+      p2 = p;
+      /* Restore argptr as it was on entry to this function.  */
+      *argptr = saved_arg2;
+      /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun".  */
+
+      /* All ready for next pass through the loop.  */
     }                  /* while (1) */
 
   /* Last chance attempt -- check entire name as a symbol.  Use "copy"
@@ -1289,6 +1346,7 @@ decode_compound (char **argptr, int funfirstline, char ***canonical,
   copy[p - saved_arg2] = '\000';
   /* Set argptr to skip over the name.  */
   *argptr = (*p == '\'') ? p + 1 : p;
+
   /* Look up entire name */
   sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0, &sym_symtab);
   if (sym)
@@ -1307,7 +1365,9 @@ decode_compound (char **argptr, int funfirstline, char ***canonical,
 /* Return the symbol corresponding to the substring of *ARGPTR ending
    at P, allowing whitespace.  Also, advance *ARGPTR past the symbol
    name in question, the compound object separator ("::" or "."), and
-   whitespace.  */
+   whitespace.  Note that *ARGPTR is changed whether or not the
+   lookup_symbol call finds anything (i.e we return NULL).  As an
+   example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun".  */
 
 static struct symbol *
 lookup_prefix_sym (char **argptr, char *p)
@@ -1323,12 +1383,15 @@ lookup_prefix_sym (char **argptr, char *p)
   memcpy (copy, *argptr, p - *argptr);
   copy[p - *argptr] = 0;
 
-  /* Discard the class name from the arg.  */
+  /* Discard the class name from the argptr.  */
   p = p1 + (p1[0] == ':' ? 2 : 1);
   while (*p == ' ' || *p == '\t')
     p++;
   *argptr = p;
 
+  /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
+     argptr->"inA::fun" */
+
   return lookup_symbol (copy, 0, STRUCT_DOMAIN, 0,
                        (struct symtab **) NULL);
 }