Merge GDB 7.5.1

gdb/linespec.c

 /* Parser for linespec for the GNU debugger, GDB.
 
    Copyright (C) 1986-2005, 2007-2012 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 3 of the License, or
    (at your option) any later version.
@@ skipping 25 matching lines @@
 #include "exceptions.h"
 #include "language.h"
 #include "interps.h"
 #include "mi/mi-cmds.h"
 #include "target.h"
 #include "arch-utils.h"
 #include <ctype.h>
 #include "cli/cli-utils.h"
 #include "filenames.h"
 #include "ada-lang.h"
+#include "stack.h"
 
 typedef struct symtab *symtab_p;
 DEF_VEC_P (symtab_p);
 
 typedef struct symbol *symbolp;
 DEF_VEC_P (symbolp);
 
 typedef struct type *typep;
 DEF_VEC_P (typep);
 
 /* An address entry is used to ensure that any given location is only
    added to the result a single time.  It holds an address and the
    program space from which the address came.  */
 
 struct address_entry
 {
   struct program_space *pspace;
   CORE_ADDR addr;
 };
 
+/* A helper struct which just holds a minimal symbol and the object
+   file from which it came.  */
+
+typedef struct minsym_and_objfile
+{
+  struct minimal_symbol *minsym;
+  struct objfile *objfile;
+} minsym_and_objfile_d;
+
+DEF_VEC_O (minsym_and_objfile_d);
+
+/* An enumeration of possible signs for a line offset.  */
+enum offset_relative_sign
+{
+  /* No sign  */
+  LINE_OFFSET_NONE,
+
+  /* A plus sign ("+")  */
+  LINE_OFFSET_PLUS,
+
+  /* A minus sign ("-")  */
+  LINE_OFFSET_MINUS,
+
+  /* A special "sign" for unspecified offset.  */
+  LINE_OFFSET_UNKNOWN
+};
+
+/* A line offset in a linespec.  */
+
+struct line_offset
+{
+  /* Line offset and any specified sign.  */
+  int offset;
+  enum offset_relative_sign sign;
+};
+
+/* A linespec.  Elements of this structure are filled in by a parser
+   (either parse_linespec or some other function).  The structure is
+   then converted into SALs by convert_linespec_to_sals.  */
+
+struct linespec
+{
+  /* An expression and the resulting PC.  Specifying an expression
+     currently precludes the use of other members.  */
+
+  /* The expression entered by the user.  */
+  char *expression;
+
+  /* The resulting PC expression derived from evaluating EXPRESSION.  */
+  CORE_ADDR expr_pc;
+
+  /* Any specified file symtabs.  */
+
+  /* The user-supplied source filename or NULL if none was specified.  */
+  char *source_filename;
+
+  /* The list of symtabs to search to which to limit the search.  May not
+     be NULL.  If SOURCE_FILENAME is NULL (no user-specified filename),
+     FILE_SYMTABS should contain one single NULL member.  This will
+     cause the code to use the default symtab.  */
+  VEC (symtab_p) *file_symtabs;
+
+  /* The name of a function or method and any matching symbols.  */
+
+  /* The user-specified function name.  If no function name was
+     supplied, this may be NULL.  */
+  char *function_name;
+
+  /* A list of matching function symbols and minimal symbols.  Both lists
+     may be NULL if no matching symbols were found.  */
+  VEC (symbolp) *function_symbols;
+  VEC (minsym_and_objfile_d) *minimal_symbols;
+
+  /* The name of a label and matching symbols.  */
+
+  /* The user-specified label name.  */
+  char *label_name;
+
+  /* A structure of matching label symbols and the corresponding
+     function symbol in which the label was found.  Both may be NULL
+     or both must be non-NULL.  */
+  struct
+  {
+    VEC (symbolp) *label_symbols;
+    VEC (symbolp) *function_symbols;
+  } labels;
+
+  /* Line offset.  It may be LINE_OFFSET_UNKNOWN, meaning that no
+   offset was specified.  */
+  struct line_offset line_offset;
+};
+typedef struct linespec *linespec_p;
+
 /* An instance of this is used to keep all state while linespec
    operates.  This instance is passed around as a 'this' pointer to
    the various implementation methods.  */
 
 struct linespec_state
 {
+  /* The language in use during linespec processing.  */
+  const struct language_defn *language;
+
   /* The program space as seen when the module was entered.  */
   struct program_space *program_space;
 
   /* The default symtab to use, if no other symtab is specified.  */
   struct symtab *default_symtab;
 
   /* The default line to use.  */
   int default_line;
 
-  /* If the linespec started with "FILE:", this holds all the matching
-     symtabs.  Otherwise, it will hold a single NULL entry, meaning
-     that the default symtab should be used.  */
-  VEC (symtab_p) *file_symtabs;
-
-  /* If the linespec started with "FILE:", this holds an xmalloc'd
-     copy of "FILE".  */
-  char *user_filename;
-
-  /* If the linespec is "FUNCTION:LABEL", this holds an xmalloc'd copy
-     of "FUNCTION".  */
-  char *user_function;
-
   /* The 'funfirstline' value that was passed in to decode_line_1 or
      decode_line_full.  */
   int funfirstline;
 
   /* Nonzero if we are running in 'list' mode; see decode_line_list.  */
   int list_mode;
 
   /* The 'canonical' value passed to decode_line_full, or NULL.  */
   struct linespec_result *canonical;
 
   /* Canonical strings that mirror the symtabs_and_lines result.  */
   char **canonical_names;
 
   /* This is a set of address_entry objects which is used to prevent
      duplicate symbols from being entered into the result.  */
   htab_t addr_set;
 };
 
 /* This is a helper object that is used when collecting symbols into a
    result.  */
 
 struct collect_info
 {
   /* The linespec object in use.  */
   struct linespec_state *state;
 
+  /* A list of symtabs to which to restrict matches.  */
+  VEC (symtab_p) *file_symtabs;
+
   /* The result being accumulated.  */
-  struct symtabs_and_lines result;
+  struct
+  {
+    VEC (symbolp) *symbols;
+    VEC (minsym_and_objfile_d) *minimal_symbols;
+  } result;
 };
 
+/* Token types  */
+
+enum ls_token_type
+{
+  /* A keyword  */
+  LSTOKEN_KEYWORD = 0,
+
+  /* A colon "separator"  */
+  LSTOKEN_COLON,
+
+  /* A string  */
+  LSTOKEN_STRING,
+
+  /* A number  */
+  LSTOKEN_NUMBER,
+
+  /* A comma  */
+  LSTOKEN_COMMA,
+
+  /* EOI (end of input)  */
+  LSTOKEN_EOI,
+
+  /* Consumed token  */
+  LSTOKEN_CONSUMED
+};
+typedef enum ls_token_type linespec_token_type;
+
+/* List of keywords  */
+
+static const char * const linespec_keywords[] = { "if", "thread", "task" };
+
+/* A token of the linespec lexer  */
+
+struct ls_token
+{
+  /* The type of the token  */
+  linespec_token_type type;
+
+  /* Data for the token  */
+  union
+  {
+    /* A string, given as a stoken  */
+    struct stoken string;
+
+    /* A keyword  */
+    const char *keyword;
+  } data;
+};
+typedef struct ls_token linespec_token;
+
+#define LS_TOKEN_STOKEN(TOK) (TOK).data.string
+#define LS_TOKEN_KEYWORD(TOK) (TOK).data.keyword
+
+/* An instance of the linespec parser.  */
+
+struct ls_parser
+{
+  /* Lexer internal data  */
+  struct
+  {
+    /* Save head of input stream.  */
+    char *saved_arg;
+
+    /* Head of the input stream.  */
+    char **stream;
+#define PARSER_STREAM(P) (*(P)->lexer.stream)
+
+    /* The current token.  */
+    linespec_token current;
+  } lexer;
+
+  /* Is the entire linespec quote-enclosed?  */
+  int is_quote_enclosed;
+
+  /* Is a keyword syntactically valid at this point?
+     In, e.g., "break thread thread 1", the leading "keyword" must not
+     be interpreted as such.  */
+  int keyword_ok;
+
+  /* The state of the parse.  */
+  struct linespec_state state;
+#define PARSER_STATE(PPTR) (&(PPTR)->state)
+
+  /* The result of the parse.  */
+  struct linespec result;
+#define PARSER_RESULT(PPTR) (&(PPTR)->result)
+};
+typedef struct ls_parser linespec_parser;
+
 /* Prototypes for local functions.  */
 
 static void initialize_defaults (struct symtab **default_symtab,
                                  int *default_line);
 
-static struct symtabs_and_lines decode_indirect (struct linespec_state *self,
-                                                 char **argptr);
-
-static char *locate_first_half (char **argptr, int *is_quote_enclosed);
+static CORE_ADDR linespec_expression_to_pc (char **exp_ptr);
 
 static struct symtabs_and_lines decode_objc (struct linespec_state *self,
+                                             linespec_p ls,
                                              char **argptr);
 
-static struct symtabs_and_lines decode_compound (struct linespec_state *self,
-                                                 char **argptr,
-                                                 char *saved_arg,
-                                                 char *p);
+static VEC (symtab_p) *symtabs_from_filename (const char *);
 
-static VEC (symbolp) *lookup_prefix_sym (char **argptr, char *p,
-                                         VEC (symtab_p) *,
-                                         char **);
+static VEC (symbolp) *find_label_symbols (struct linespec_state *self,
+                                          VEC (symbolp) *function_symbols,
+                                          VEC (symbolp) **label_funcs_ret,
+                                          const char *name);
 
-static struct symtabs_and_lines find_method (struct linespec_state *self,
-                                             char *saved_arg,
-                                             char *copy,
-                                             const char *class_name,
-                                             VEC (symbolp) *sym_classes);
+void find_linespec_symbols (struct linespec_state *self,
+                            VEC (symtab_p) *file_symtabs,
+                            const char *name,
+                            VEC (symbolp) **symbols,
+                            VEC (minsym_and_objfile_d) **minsyms);
 
-static void cplusplus_error (const char *name, const char *fmt, ...)
-     ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 3);
-
-static char *find_toplevel_char (char *s, char c);
-
-static int is_objc_method_format (const char *s);
-
-static VEC (symtab_p) *symtabs_from_filename (char **argptr,
-                                              char *p, int is_quote_enclosed,
-                                              char **user_filename);
-
-static VEC (symbolp) *find_function_symbols (char **argptr, char *p,
-                                             int is_quote_enclosed,
-                                             char **user_function);
-
-static struct symtabs_and_lines decode_all_digits (struct linespec_state *self,
-                                                   char **argptr,
-                                                   char *q);
-
-static struct symtabs_and_lines decode_dollar (struct linespec_state *self,
-                                               char *copy);
-
-static int decode_label (struct linespec_state *self,
-                         VEC (symbolp) *function_symbols,
-                         char *copy,
-                         struct symtabs_and_lines *result);
-
-static struct symtabs_and_lines decode_variable (struct linespec_state *self,
-                                                 char *copy);
+static struct line_offset
+     linespec_parse_variable (struct linespec_state *self,
+                              const char *variable);
 
 static int symbol_to_sal (struct symtab_and_line *result,
                           int funfirstline, struct symbol *sym);
 
 static void add_matching_symbols_to_info (const char *name,
                                           struct collect_info *info,
                                           struct program_space *pspace);
 
 static void add_all_symbol_names_from_pspace (struct collect_info *info,
                                               struct program_space *pspace,
                                               VEC (const_char_ptr) *names);
 
+static VEC (symtab_p) *collect_symtabs_from_filename (const char *file);
+
+static void decode_digits_ordinary (struct linespec_state *self,
+                                    linespec_p ls,
+                                    int line,
+                                    struct symtabs_and_lines *sals,
+                                    struct linetable_entry **best_entry);
+
+static void decode_digits_list_mode (struct linespec_state *self,
+                                     linespec_p ls,
+                                     struct symtabs_and_lines *values,
+                                     struct symtab_and_line val);
+
+static void minsym_found (struct linespec_state *self, struct objfile *objfile,
+                          struct minimal_symbol *msymbol,
+                          struct symtabs_and_lines *result);
+
+static int compare_symbols (const void *a, const void *b);
+
+static int compare_msymbols (const void *a, const void *b);
+
+static const char *find_toplevel_char (const char *s, char c);
+
+/* Permitted quote characters for the parser.  This is different from the
+   completer's quote characters to allow backward compatibility with the
+   previous parser.  */
+static const char *const linespec_quote_characters = "\"\'";
+
+/* Lexer functions.  */
+
+/* Lex a number from the input in PARSER.  This only supports
+   decimal numbers.
+
+   Return true if input is decimal numbers.  Return false if not.  */
+
+static int
+linespec_lexer_lex_number (linespec_parser *parser, linespec_token *tokenp)
+{
+  tokenp->type = LSTOKEN_NUMBER;
+  LS_TOKEN_STOKEN (*tokenp).length = 0;
+  LS_TOKEN_STOKEN (*tokenp).ptr = PARSER_STREAM (parser);
+
+  /* Keep any sign at the start of the stream.  */
+  if (*PARSER_STREAM (parser) == '+' || *PARSER_STREAM (parser) == '-')
+    {
+      ++LS_TOKEN_STOKEN (*tokenp).length;
+      ++(PARSER_STREAM (parser));
+    }
+
+  while (isdigit (*PARSER_STREAM (parser)))
+    {
+      ++LS_TOKEN_STOKEN (*tokenp).length;
+      ++(PARSER_STREAM (parser));
+    }
+
+  /* If the next character in the input buffer is not a space, comma,
+     quote, or colon, the input does not represent a number.  */
+  if (*PARSER_STREAM (parser) != '\0'
+      && !isspace (*PARSER_STREAM (parser)) && *PARSER_STREAM (parser) != ','
+      && *PARSER_STREAM (parser) != ':'
+      && !strchr (linespec_quote_characters, *PARSER_STREAM (parser)))
+    {
+      PARSER_STREAM (parser) = LS_TOKEN_STOKEN (*tokenp).ptr;
+      return 0;
+    }
+
+  return 1;
+}
+
+/* Does P represent one of the keywords?  If so, return
+   the keyword.  If not, return NULL.  */
+
+static const char *
+linespec_lexer_lex_keyword (const char *p)
+{
+  int i;
+
+  if (p != NULL)
+    {
+      for (i = 0; i < ARRAY_SIZE (linespec_keywords); ++i)
+        {
+          int len = strlen (linespec_keywords[i]);
+
+          /* If P begins with one of the keywords and the next
+             character is not a valid identifier character,
+             we have found a keyword.  */
+          if (strncmp (p, linespec_keywords[i], len) == 0
+              && !(isalnum (p[len]) || p[len] == '_'))
+            return linespec_keywords[i];
+        }
+    }
+
+  return NULL;
+}
+
+/* Does STRING represent an Ada operator?  If so, return the length
+   of the decoded operator name.  If not, return 0.  */
+
+static int
+is_ada_operator (const char *string)
+{
+  const struct ada_opname_map *mapping;
+
+  for (mapping = ada_opname_table;
+       mapping->encoded != NULL
+         && strncmp (mapping->decoded, string,
+                     strlen (mapping->decoded)) != 0; ++mapping)
+    ;
+
+  return mapping->decoded == NULL ? 0 : strlen (mapping->decoded);
+}
+
+/* Find QUOTE_CHAR in STRING, accounting for the ':' terminal.  Return
+   the location of QUOTE_CHAR, or NULL if not found.  */
+
+static const char *
+skip_quote_char (const char *string, char quote_char)
+{
+  const char *p, *last;
+
+  p = last = find_toplevel_char (string, quote_char);
+  while (p && *p != '\0' && *p != ':')
+    {
+      p = find_toplevel_char (p, quote_char);
+      if (p != NULL)
+        last = p++;
+    }
+
+  return last;
+}
+
+/* Make a writable copy of the string given in TOKEN, trimming
+   any trailing whitespace.  */
+
+static char *
+copy_token_string (linespec_token token)
+{
+  char *str, *s;
+
+  if (token.type == LSTOKEN_KEYWORD)
+    return xstrdup (LS_TOKEN_KEYWORD (token));
+
+  str = savestring (LS_TOKEN_STOKEN (token).ptr,
+                    LS_TOKEN_STOKEN (token).length);
+  s = remove_trailing_whitespace (str, str + LS_TOKEN_STOKEN (token).length);
+  *s = '\0';
+
+  return str;
+}
+
+/* Does P represent the end of a quote-enclosed linespec?  */
+
+static int
+is_closing_quote_enclosed (const char *p)
+{
+  if (strchr (linespec_quote_characters, *p))
+    ++p;
+  p = skip_spaces ((char *) p);
+  return (*p == '\0' || linespec_lexer_lex_keyword (p));
+}
+
+/* Find the end of the parameter list that starts with *INPUT.
+   This helper function assists with lexing string segments
+   which might contain valid (non-terminating) commas.  */
+
+static char *
+find_parameter_list_end (char *input)
+{
+  char end_char, start_char;
+  int depth;
+  char *p;
+
+  start_char = *input;
+  if (start_char == '(')
+    end_char = ')';
+  else if (start_char == '<')
+    end_char = '>';
+  else
+    return NULL;
+
+  p = input;
+  depth = 0;
+  while (*p)
+    {
+      if (*p == start_char)
+        ++depth;
+      else if (*p == end_char)
+        {
+          if (--depth == 0)
+            {
+              ++p;
+              break;
+            }
+        }
+      ++p;
+    }
+
+  return p;
+}
+
+
+/* Lex a string from the input in PARSER.  */
+
+static linespec_token
+linespec_lexer_lex_string (linespec_parser *parser)
+{
+  linespec_token token;
+  char *start = PARSER_STREAM (parser);
+
+  token.type = LSTOKEN_STRING;
+
+  /* If the input stream starts with a quote character, skip to the next
+     quote character, regardless of the content.  */
+  if (strchr (linespec_quote_characters, *PARSER_STREAM (parser)))
+    {
+      const char *end;
+      char quote_char = *PARSER_STREAM (parser);
+
+      /* Special case: Ada operators.  */
+      if (PARSER_STATE (parser)->language->la_language == language_ada
+          && quote_char == '\"')
+        {
+          int len = is_ada_operator (PARSER_STREAM (parser));
+
+          if (len != 0)
+            {
+              /* The input is an Ada operator.  Return the quoted string
+                 as-is.  */
+              LS_TOKEN_STOKEN (token).ptr = PARSER_STREAM (parser);
+              LS_TOKEN_STOKEN (token).length = len;
+              PARSER_STREAM (parser) += len;
+              return token;
+            }
+
+          /* The input does not represent an Ada operator -- fall through
+             to normal quoted string handling.  */
+        }
+
+      /* Skip past the beginning quote.  */
+      ++(PARSER_STREAM (parser));
+
+      /* Mark the start of the string.  */
+      LS_TOKEN_STOKEN (token).ptr = PARSER_STREAM (parser);
+
+      /* Skip to the ending quote.  */
+      end = skip_quote_char (PARSER_STREAM (parser), quote_char);
+
+      /* Error if the input did not terminate properly.  */
+      if (end == NULL)
+        error (_("unmatched quote"));
+
+      /* Skip over the ending quote and mark the length of the string.  */
+      PARSER_STREAM (parser) = (char *) ++end;
+      LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - 2 - start;
+    }
+  else
+    {
+      char *p;
+
+      /* Otherwise, only identifier characters are permitted.
+         Spaces are the exception.  In general, we keep spaces,
+         but only if the next characters in the input do not resolve
+         to one of the keywords.
+
+         This allows users to forgo quoting CV-qualifiers, template arguments,
+         and similar common language constructs.  */
+
+      while (1)
+        {
+          if (isspace (*PARSER_STREAM (parser)))
+            {
+              p = skip_spaces (PARSER_STREAM (parser));
+              /* When we get here we know we've found something followed by
+                 a space (we skip over parens and templates below).
+                 So if we find a keyword now, we know it is a keyword and not,
+                 say, a function name.  */
+              if (linespec_lexer_lex_keyword (p) != NULL)
+                {
+                  LS_TOKEN_STOKEN (token).ptr = start;
+                  LS_TOKEN_STOKEN (token).length
+                    = PARSER_STREAM (parser) - start;
+                  return token;
+                }
+
+              /* Advance past the whitespace.  */
+              PARSER_STREAM (parser) = p;
+            }
+
+          /* If the next character is EOI or (single) ':', the
+             string is complete;  return the token.  */
+          if (*PARSER_STREAM (parser) == 0)
+            {
+              LS_TOKEN_STOKEN (token).ptr = start;
+              LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start;
+              return token;
+            }
+          else if (PARSER_STREAM (parser)[0] == ':')
+            {
+              /* Do not tokenize the C++ scope operator. */
+              if (PARSER_STREAM (parser)[1] == ':')
+                ++(PARSER_STREAM (parser));
+
+              /* Do not tokenify if the input length so far is one
+                 (i.e, a single-letter drive name) and the next character
+                 is a directory separator.  This allows Windows-style
+                 paths to be recognized as filenames without quoting it.  */
+              else if ((PARSER_STREAM (parser) - start) != 1
+                       || !IS_DIR_SEPARATOR (PARSER_STREAM (parser)[1]))
+                {
+                  LS_TOKEN_STOKEN (token).ptr = start;
+                  LS_TOKEN_STOKEN (token).length
+                    = PARSER_STREAM (parser) - start;
+                  return token;
+                }
+            }
+          /* Special case: permit quote-enclosed linespecs.  */
+          else if (parser->is_quote_enclosed
+                   && strchr (linespec_quote_characters,
+                              *PARSER_STREAM (parser))
+                   && is_closing_quote_enclosed (PARSER_STREAM (parser)))
+            {
+              LS_TOKEN_STOKEN (token).ptr = start;
+              LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start;
+              return token;
+            }
+          /* Because commas may terminate a linespec and appear in
+             the middle of valid string input, special cases for
+             '<' and '(' are necessary.  */
+          else if (*PARSER_STREAM (parser) == '<'
+                   || *PARSER_STREAM (parser) == '(')
+            {
+              char *p;
+
+              p = find_parameter_list_end (PARSER_STREAM (parser));
+              if (p != NULL)
+                {
+                  PARSER_STREAM (parser) = p;
+                  continue;
+                }
+            }
+          /* Commas are terminators, but not if they are part of an
+             operator name.  */
+          else if (*PARSER_STREAM (parser) == ',')
+            {
+              if ((PARSER_STATE (parser)->language->la_language
+                   == language_cplus)
+                  && (PARSER_STREAM (parser) - start) > 8
+                  /* strlen ("operator") */)
+                {
+                  char *p = strstr (start, "operator");
+
+                  if (p != NULL && is_operator_name (p))
+                    {
+                      /* This is an operator name.  Keep going.  */
+                      ++(PARSER_STREAM (parser));
+                      continue;
+                    }
+                }
+
+              /* Comma terminates the string.  */
+              LS_TOKEN_STOKEN (token).ptr = start;
+              LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start;
+              return token;
+            }
+
+          /* Advance the stream.  */
+          ++(PARSER_STREAM (parser));
+        }
+    }
+
+  return token;
+}
+
+/* Lex a single linespec token from PARSER.  */
+
+static linespec_token
+linespec_lexer_lex_one (linespec_parser *parser)
+{
+  const char *keyword;
+
+  if (parser->lexer.current.type == LSTOKEN_CONSUMED)
+    {
+      /* Skip any whitespace.  */
+      PARSER_STREAM (parser) = skip_spaces (PARSER_STREAM (parser));
+
+      /* Check for a keyword, they end the linespec.  */
+      keyword = NULL;
+      if (parser->keyword_ok)
+        keyword = linespec_lexer_lex_keyword (PARSER_STREAM (parser));
+      if (keyword != NULL)
+        {
+          parser->lexer.current.type = LSTOKEN_KEYWORD;
+          LS_TOKEN_KEYWORD (parser->lexer.current) = keyword;
+          return parser->lexer.current;
+        }
+
+      /* Handle other tokens.  */
+      switch (*PARSER_STREAM (parser))
+        {
+        case 0:
+          parser->lexer.current.type = LSTOKEN_EOI;
+          break;
+
+        case '+': case '-':
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9':
+           if (!linespec_lexer_lex_number (parser, &(parser->lexer.current)))
+             parser->lexer.current = linespec_lexer_lex_string (parser);
+          break;
+
+        case ':':
+          /* If we have a scope operator, lex the input as a string.
+             Otherwise, return LSTOKEN_COLON.  */
+          if (PARSER_STREAM (parser)[1] == ':')
+            parser->lexer.current = linespec_lexer_lex_string (parser);
+          else
+            {
+              parser->lexer.current.type = LSTOKEN_COLON;
+              ++(PARSER_STREAM (parser));
+            }
+          break;
+
+        case '\'': case '\"':
+          /* Special case: permit quote-enclosed linespecs.  */
+          if (parser->is_quote_enclosed
+              && is_closing_quote_enclosed (PARSER_STREAM (parser)))
+            {
+              ++(PARSER_STREAM (parser));
+              parser->lexer.current.type = LSTOKEN_EOI;
+            }
+          else
+            parser->lexer.current = linespec_lexer_lex_string (parser);
+          break;
+
+        case ',':
+          parser->lexer.current.type = LSTOKEN_COMMA;
+          LS_TOKEN_STOKEN (parser->lexer.current).ptr
+            = PARSER_STREAM (parser);
+          LS_TOKEN_STOKEN (parser->lexer.current).length = 1;
+          ++(PARSER_STREAM (parser));
+          break;
+
+        default:
+          /* If the input is not a number, it must be a string.
+             [Keywords were already considered above.]  */
+          parser->lexer.current = linespec_lexer_lex_string (parser);
+          break;
+        }
+    }
+
+  return parser->lexer.current;
+}
+
+/* Consume the current token and return the next token in PARSER's
+   input stream.  */
+
+static linespec_token
+linespec_lexer_consume_token (linespec_parser *parser)
+{
+  parser->lexer.current.type = LSTOKEN_CONSUMED;
+  return linespec_lexer_lex_one (parser);
+}
+
+/* Return the next token without consuming the current token.  */
+
+static linespec_token
+linespec_lexer_peek_token (linespec_parser *parser)
+{
+  linespec_token next;
+  char *saved_stream = PARSER_STREAM (parser);
+  linespec_token saved_token = parser->lexer.current;
+
+  next = linespec_lexer_consume_token (parser);
+  PARSER_STREAM (parser) = saved_stream;
+  parser->lexer.current = saved_token;
+  return next;
+}
+
 /* Helper functions.  */
 
 /* Add SAL to SALS.  */
 
 static void
 add_sal_to_sals_basic (struct symtabs_and_lines *sals,
                        struct symtab_and_line *sal)
 {
   ++sals->nelts;
   sals->sals = xrealloc (sals->sals, sals->nelts * sizeof (sals->sals[0]));
@@ skipping 19 matching lines @@
       self->canonical_names = xrealloc (self->canonical_names,
                                         sals->nelts * sizeof (char *));
       if (sal->symtab && sal->symtab->filename)
         {
           char *filename = sal->symtab->filename;
 
           /* Note that the filter doesn't have to be a valid linespec
              input.  We only apply the ":LINE" treatment to Ada for
              the time being.  */
           if (symname != NULL && sal->line != 0
-              && current_language->la_language == language_ada)
+              && self->language->la_language == language_ada)
             canonical_name = xstrprintf ("%s:%s:%d", filename, symname,
                                          sal->line);
           else if (symname != NULL)
             canonical_name = xstrprintf ("%s:%s", filename, symname);
           else
             canonical_name = xstrprintf ("%s:%d", filename, sal->line);
         }
 
       self->canonical_names[sals->nelts - 1] = canonical_name;
     }
@@ skipping 38 matching lines @@
   if (*slot)
     return 0;
 
   p = XNEW (struct address_entry);
   memcpy (p, &e, sizeof (struct address_entry));
   *slot = p;
 
   return 1;
 }
 
-/* Issue a helpful hint on using the command completion feature on
-   single quoted demangled C++ symbols as part of the completion
-   error.  */
-
-static void
-cplusplus_error (const char *name, const char *fmt, ...)
-{
-  struct ui_file *tmp_stream;
-  char *message;
-
-  tmp_stream = mem_fileopen ();
-  make_cleanup_ui_file_delete (tmp_stream);
-
-  {
-    va_list args;
-
-    va_start (args, fmt);
-    vfprintf_unfiltered (tmp_stream, fmt, args);
-    va_end (args);
-  }
-
-  while (*name == '\'')
-    name++;
-  fprintf_unfiltered (tmp_stream,
-                      ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
-                       "(Note leading single quote.)"),
-                      name, name);
-
-  message = ui_file_xstrdup (tmp_stream, NULL);
-  make_cleanup (xfree, message);
-  throw_error (NOT_FOUND_ERROR, "%s", message);
-}
+/* A callback function and the additional data to call it with.  */
+
+struct symbol_and_data_callback
+{
+  /* The callback to use.  */
+  symbol_found_callback_ftype *callback;
+
+  /* Data to be passed to the callback.  */
+  void *data;
+};
+
+/* A helper for iterate_over_all_matching_symtabs that is used to
+   restrict calls to another callback to symbols representing inline
+   symbols only.  */
+
+static int
+iterate_inline_only (struct symbol *sym, void *d)
+{
+  if (SYMBOL_INLINED (sym))
+    {
+      struct symbol_and_data_callback *cad = d;
+
+      return cad->callback (sym, cad->data);
+    }
+  return 1; /* Continue iterating.  */
+}
+
+/* Some data for the expand_symtabs_matching callback.  */
+
+struct symbol_matcher_data
+{
+  /* The lookup name against which symbol name should be compared.  */
+  const char *lookup_name;
+
+  /* The routine to be used for comparison.  */
+  symbol_name_cmp_ftype symbol_name_cmp;
+};
 
 /* A helper for iterate_over_all_matching_symtabs that is passed as a
    callback to the expand_symtabs_matching method.  */
 
 static int
-iterate_name_matcher (const struct language_defn *language,
-                      const char *name, void *d)
-{
-  const char **dname = d;
-
-  if (language->la_symbol_name_compare (name, *dname) == 0)
-    return 1;
-  return 0;
+iterate_name_matcher (const char *name, void *d)
+{
+  const struct symbol_matcher_data *data = d;
+
+  if (data->symbol_name_cmp (name, data->lookup_name) == 0)
+    return 1; /* Expand this symbol's symbol table.  */
+  return 0; /* Skip this symbol.  */
 }
 
 /* A helper that walks over all matching symtabs in all objfiles and
    calls CALLBACK for each symbol matching NAME.  If SEARCH_PSPACE is
    not NULL, then the search is restricted to just that program
-   space.  */
+   space.  If INCLUDE_INLINE is nonzero then symbols representing
+   inlined instances of functions will be included in the result.  */
 
 static void
-iterate_over_all_matching_symtabs (const char *name,
+iterate_over_all_matching_symtabs (struct linespec_state *state,
+                                   const char *name,
                                    const domain_enum domain,
-                                   int (*callback) (struct symbol *, void *),
+                                   symbol_found_callback_ftype *callback,
                                    void *data,
-                                   struct program_space *search_pspace)
+                                   struct program_space *search_pspace,
+                                   int include_inline)
 {
   struct objfile *objfile;
   struct program_space *pspace;
+  struct symbol_matcher_data matcher_data;
+
+  matcher_data.lookup_name = name;
+  matcher_data.symbol_name_cmp =
+    state->language->la_get_symbol_name_cmp != NULL
+    ? state->language->la_get_symbol_name_cmp (name)
+    : strcmp_iw;
 
   ALL_PSPACES (pspace)
   {
     if (search_pspace != NULL && search_pspace != pspace)
       continue;
     if (pspace->executing_startup)
       continue;
 
     set_current_program_space (pspace);
 
     ALL_OBJFILES (objfile)
     {
       struct symtab *symtab;
 
       if (objfile->sf)
         objfile->sf->qf->expand_symtabs_matching (objfile, NULL,
                                                   iterate_name_matcher,
                                                   ALL_DOMAIN,
-                                                  &name);
-
-      ALL_OBJFILE_SYMTABS (objfile, symtab)
+                                                  &matcher_data);
+
+      ALL_OBJFILE_PRIMARY_SYMTABS (objfile, symtab)
         {
-          if (symtab->primary)
-            {
-              struct block *block;
-
-              block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
-              LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data);
+          struct block *block;
+
+          block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
+          LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data);
+
+          if (include_inline)
+            {
+              struct symbol_and_data_callback cad = { callback, data };
+              int i;
+
+              for (i = FIRST_LOCAL_BLOCK;
+                   i < BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (symtab)); i++)
+                {
+                  block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), i);
+                  LA_ITERATE_OVER_SYMBOLS (block, name, domain,
+                                           iterate_inline_only, &cad);
+                }
             }
         }
     }
   }
 }
 
 /* Returns the block to be used for symbol searches for the given SYMTAB,
    which may be NULL.  */
 
 static struct block *
@@ skipping 11 matching lines @@
          no selected frame yet.  */
       save_language = current_language->la_language;
       block = get_selected_block (0);
       set_language (save_language);
     }
 
   return block;
 }
 
 /* A helper for find_method.  This finds all methods in type T which
-   match NAME.  It adds resulting symbol names to RESULT_NAMES, and
+   match NAME.  It adds matching symbol names to RESULT_NAMES, and
    adds T's direct superclasses to SUPERCLASSES.  */
 
 static void
 find_methods (struct type *t, const char *name,
               VEC (const_char_ptr) **result_names,
               VEC (typep) **superclasses)
 {
   int i1 = 0;
   int ibase;
-  char *class_name = type_name_no_tag (t);
-  char *canon;
+  const char *class_name = type_name_no_tag (t);
 
   /* Ignore this class if it doesn't have a name.  This is ugly, but
      unless we figure out how to get the physname without the name of
      the class, then the loop can't do any good.  */
   if (class_name)
     {
       int method_counter;
       int name_len = strlen (name);
 
       CHECK_TYPEDEF (t);
 
       /* Loop over each method name.  At this level, all overloads of a name
          are counted as a single name.  There is an inner loop which loops over
          each overload.  */
 
       for (method_counter = TYPE_NFN_FIELDS (t) - 1;
            method_counter >= 0;
            --method_counter)
         {
-          char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
+          const char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
           char dem_opname[64];
 
           if (strncmp (method_name, "__", 2) == 0 ||
               strncmp (method_name, "op", 2) == 0 ||
               strncmp (method_name, "type", 4) == 0)
             {
               if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI))
                 method_name = dem_opname;
               else if (cplus_demangle_opname (method_name, dem_opname, 0))
                 method_name = dem_opname;
@@ skipping 23 matching lines @@
 
   for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
     VEC_safe_push (typep, *superclasses, TYPE_BASECLASS (t, ibase));
 }
 
 /* Find an instance of the character C in the string S that is outside
    of all parenthesis pairs, single-quoted strings, and double-quoted
    strings.  Also, ignore the char within a template name, like a ','
    within foo<int, int>.  */
 
-static char *
-find_toplevel_char (char *s, char c)
+static const char *
+find_toplevel_char (const char *s, char c)
 {
   int quoted = 0;               /* zero if we're not in quotes;
                                    '"' if we're in a double-quoted string;
                                    '\'' if we're in a single-quoted string.  */
   int depth = 0;                /* Number of unclosed parens we've seen.  */
-  char *scan;
+  const char *scan;
 
   for (scan = s; *scan; scan++)
     {
       if (quoted)
         {
           if (*scan == quoted)
             quoted = 0;
           else if (*scan == '\\' && *(scan + 1))
             scan++;
         }
       else if (*scan == c && ! quoted && depth == 0)
         return scan;
       else if (*scan == '"' || *scan == '\'')
         quoted = *scan;
       else if (*scan == '(' || *scan == '<')
         depth++;
       else if ((*scan == ')' || *scan == '>') && depth > 0)
         depth--;
     }
 
   return 0;
 }
 
-/* Determines if the gives string corresponds to an Objective-C method
-   representation, such as -[Foo bar:] or +[Foo bar].  Objective-C symbols
-   are allowed to have spaces and parentheses in them.  */
+/* The string equivalent of find_toplevel_char.  Returns a pointer
+   to the location of NEEDLE in HAYSTACK, ignoring any occurrences
+   inside "()" and "<>".  Returns NULL if NEEDLE was not found.  */
 
-static int 
-is_objc_method_format (const char *s)
+static const char *
+find_toplevel_string (const char *haystack, const char *needle)
 {
-  if (s == NULL || *s == '\0')
-    return 0;
-  /* Handle arguments with the format FILENAME:SYMBOL.  */
-  if ((s[0] == ':') && (strchr ("+-", s[1]) != NULL) 
-      && (s[2] == '[') && strchr(s, ']'))
-    return 1;
-  /* Handle arguments that are just SYMBOL.  */
-  else if ((strchr ("+-", s[0]) != NULL) && (s[1] == '[') && strchr(s, ']'))
-    return 1;
-  return 0;
+  const char *s = haystack;
+
+  do
+    {
+      s = find_toplevel_char (s, *needle);
+
+      if (s != NULL)
+        {
+          /* Found first char in HAYSTACK;  check rest of string.  */
+          if (strncmp (s, needle, strlen (needle)) == 0)
+            return s;
+
+          /* Didn't find it; loop over HAYSTACK, looking for the next
+             instance of the first character of NEEDLE.  */
+          ++s;
+        }
+    }
+  while (s != NULL && *s != '\0');
+
+  /* NEEDLE was not found in HAYSTACK.  */
+  return NULL;
 }
 
 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
    and store the result in SELF->CANONICAL.  */
 
 static void
 filter_results (struct linespec_state *self,
                 struct symtabs_and_lines *result,
                 VEC (const_char_ptr) *filters)
 {
@@ skipping 80 matching lines @@
   if (select_mode == multiple_symbols_cancel
       && VEC_length (const_char_ptr, item_names) > 1)
     error (_("canceled because the command is ambiguous\n"
              "See set/show multiple-symbol."));
   
   if (select_mode == multiple_symbols_all
       || VEC_length (const_char_ptr, item_names) == 1)
     {
       do_cleanups (old_chain);
       convert_results_to_lsals (self, result);