-/* Data structures and API for event locations in GDB.
- Copyright (C) 2013-2017 Free Software Foundation, Inc.
+/* Data structures and API for location specs in GDB.
+ Copyright (C) 2013-2023 Free Software Foundation, Inc.
This file is part of GDB.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "gdb_assert.h"
+#include "gdbsupport/gdb_assert.h"
+#include "gdbsupport/gdb-checked-static-cast.h"
#include "location.h"
#include "symtab.h"
#include "language.h"
#include <ctype.h>
#include <string.h>
-/* An event location used to set a stop event in the inferior.
- This structure is an amalgam of the various ways
- to specify where a stop event should be set. */
+static std::string
+ explicit_to_string_internal (bool as_linespec,
+ const explicit_location_spec *explicit_loc);
-struct event_location
-{
- /* The type of this breakpoint specification. */
- enum event_location_type type;
-#define EL_TYPE(P) (P)->type
-
- union
- {
- /* A generic "this is a string specification" for a location.
- This representation is used by both "normal" linespecs and
- probes. */
- char *addr_string;
-#define EL_LINESPEC(P) ((P)->u.addr_string)
-#define EL_PROBE(P) ((P)->u.addr_string)
-
- /* An address in the inferior. */
- CORE_ADDR address;
-#define EL_ADDRESS(P) (P)->u.address
-
- /* An explicit location. */
- struct explicit_location explicit_loc;
-#define EL_EXPLICIT(P) (&((P)->u.explicit_loc))
- } u;
-
- /* Cached string representation of this location. This is used, e.g., to
- save stop event locations to file. Malloc'd. */
- char *as_string;
-#define EL_STRING(P) ((P)->as_string)
-};
-
-/* See description in location.h. */
+/* Return a xstrdup of STR if not NULL, otherwise return NULL. */
-enum event_location_type
-event_location_type (const struct event_location *location)
+static char *
+maybe_xstrdup (const char *str)
{
- return EL_TYPE (location);
+ return (str != nullptr ? xstrdup (str) : nullptr);
}
-/* See description in location.h. */
+probe_location_spec::probe_location_spec (std::string &&probe)
+ : location_spec (PROBE_LOCATION_SPEC, std::move (probe))
+{
+}
-void
-initialize_explicit_location (struct explicit_location *explicit_loc)
+location_spec_up
+probe_location_spec::clone () const
{
- memset (explicit_loc, 0, sizeof (struct explicit_location));
- explicit_loc->line_offset.sign = LINE_OFFSET_UNKNOWN;
+ return location_spec_up (new probe_location_spec (*this));
}
-/* See description in location.h. */
+bool
+probe_location_spec::empty_p () const
+{
+ return false;
+}
-event_location_up
-new_linespec_location (char **linespec)
+std::string probe_location_spec::compute_string () const
{
- struct event_location *location;
+ return std::move (m_as_string);
+}
- location = XCNEW (struct event_location);
- EL_TYPE (location) = LINESPEC_LOCATION;
+/* A "normal" linespec. */
+linespec_location_spec::linespec_location_spec
+ (const char **linespec, symbol_name_match_type match_type_)
+ : location_spec (LINESPEC_LOCATION_SPEC),
+ match_type (match_type_)
+{
if (*linespec != NULL)
{
- char *p;
- char *orig = *linespec;
+ const char *p;
+ const char *orig = *linespec;
linespec_lex_to_end (linespec);
p = remove_trailing_whitespace (orig, *linespec);
+
+ /* If there is no valid linespec then this will leave the
+ spec_string as nullptr. This behaviour is relied on in the
+ breakpoint setting code, where spec_string being nullptr means
+ to use the default breakpoint location. */
if ((p - orig) > 0)
- EL_LINESPEC (location) = savestring (orig, p - orig);
+ spec_string = savestring (orig, p - orig);
}
- return event_location_up (location);
}
-/* See description in location.h. */
+linespec_location_spec::~linespec_location_spec ()
+{
+ xfree (spec_string);
+}
-const char *
-get_linespec_location (const struct event_location *location)
+location_spec_up
+linespec_location_spec::clone () const
{
- gdb_assert (EL_TYPE (location) == LINESPEC_LOCATION);
- return EL_LINESPEC (location);
+ return location_spec_up (new linespec_location_spec (*this));
}
-/* See description in location.h. */
+bool
+linespec_location_spec::empty_p () const
+{
+ return false;
+}
+
+linespec_location_spec::linespec_location_spec
+ (const linespec_location_spec &other)
+ : location_spec (other),
+ match_type (other.match_type),
+ spec_string (maybe_xstrdup (other.spec_string))
+{
+}
+
+std::string
+linespec_location_spec::compute_string () const
+{
+ if (spec_string != nullptr)
+ {
+ if (match_type == symbol_name_match_type::FULL)
+ return std::string ("-qualified ") + spec_string;
+ else
+ return spec_string;
+ }
+ return {};
+}
-event_location_up
-new_address_location (CORE_ADDR addr, const char *addr_string,
- int addr_string_len)
+address_location_spec::address_location_spec (CORE_ADDR addr,
+ const char *addr_string,
+ int addr_string_len)
+ : location_spec (ADDRESS_LOCATION_SPEC),
+ address (addr)
{
- struct event_location *location;
+ if (addr_string != nullptr)
+ m_as_string = std::string (addr_string, addr_string_len);
+}
- location = XCNEW (struct event_location);
- EL_TYPE (location) = ADDRESS_LOCATION;
- EL_ADDRESS (location) = addr;
- if (addr_string != NULL)
- EL_STRING (location) = xstrndup (addr_string, addr_string_len);
- return event_location_up (location);
+location_spec_up
+address_location_spec::clone () const
+{
+ return location_spec_up (new address_location_spec (*this));
}
-/* See description in location.h. */
+bool
+address_location_spec::empty_p () const
+{
+ return false;
+}
-CORE_ADDR
-get_address_location (const struct event_location *location)
+address_location_spec::address_location_spec
+ (const address_location_spec &other)
+ : location_spec (other),
+ address (other.address)
{
- gdb_assert (EL_TYPE (location) == ADDRESS_LOCATION);
- return EL_ADDRESS (location);
}
-/* See description in location.h. */
+std::string
+address_location_spec::compute_string () const
+{
+ const char *addr_string = core_addr_to_string (address);
+ return std::string ("*") + addr_string;
+}
-const char *
-get_address_string_location (const struct event_location *location)
+explicit_location_spec::explicit_location_spec ()
+ : location_spec (EXPLICIT_LOCATION_SPEC)
{
- gdb_assert (EL_TYPE (location) == ADDRESS_LOCATION);
- return EL_STRING (location);
}
-/* See description in location.h. */
+explicit_location_spec::~explicit_location_spec ()
+{
+ xfree (source_filename);
+ xfree (function_name);
+ xfree (label_name);
+}
+
+explicit_location_spec::explicit_location_spec
+ (const explicit_location_spec &other)
+ : location_spec (other),
+ source_filename (maybe_xstrdup (other.source_filename)),
+ function_name (maybe_xstrdup (other.function_name)),
+ func_name_match_type (other.func_name_match_type),
+ label_name (maybe_xstrdup (other.label_name)),
+ line_offset (other.line_offset)
+{
+}
+
+location_spec_up
+explicit_location_spec::clone () const
+{
+ return location_spec_up (new explicit_location_spec (*this));
+}
-event_location_up
-new_probe_location (const char *probe)
+bool
+explicit_location_spec::empty_p () const
{
- struct event_location *location;
+ return (source_filename == nullptr
+ && function_name == nullptr
+ && label_name == nullptr
+ && line_offset.sign == LINE_OFFSET_UNKNOWN);
+}
- location = XCNEW (struct event_location);
- EL_TYPE (location) = PROBE_LOCATION;
- if (probe != NULL)
- EL_PROBE (location) = xstrdup (probe);
- return event_location_up (location);
+std::string
+explicit_location_spec::compute_string () const
+{
+ return explicit_to_string_internal (false, this);
}
/* See description in location.h. */
-const char *
-get_probe_location (const struct event_location *location)
+location_spec_up
+new_linespec_location_spec (const char **linespec,
+ symbol_name_match_type match_type)
{
- gdb_assert (EL_TYPE (location) == PROBE_LOCATION);
- return EL_PROBE (location);
+ return location_spec_up (new linespec_location_spec (linespec,
+ match_type));
}
/* See description in location.h. */
-event_location_up
-new_explicit_location (const struct explicit_location *explicit_loc)
+const linespec_location_spec *
+as_linespec_location_spec (const location_spec *locspec)
{
- struct event_location tmp;
+ gdb_assert (locspec->type () == LINESPEC_LOCATION_SPEC);
+ return gdb::checked_static_cast<const linespec_location_spec *> (locspec);
+}
- memset (&tmp, 0, sizeof (struct event_location));
- EL_TYPE (&tmp) = EXPLICIT_LOCATION;
- initialize_explicit_location (EL_EXPLICIT (&tmp));
- if (explicit_loc != NULL)
- {
- if (explicit_loc->source_filename != NULL)
- {
- EL_EXPLICIT (&tmp)->source_filename
- = explicit_loc->source_filename;
- }
+/* See description in location.h. */
- if (explicit_loc->function_name != NULL)
- EL_EXPLICIT (&tmp)->function_name
- = explicit_loc->function_name;
+location_spec_up
+new_address_location_spec (CORE_ADDR addr, const char *addr_string,
+ int addr_string_len)
+{
+ return location_spec_up (new address_location_spec (addr, addr_string,
+ addr_string_len));
+}
- if (explicit_loc->label_name != NULL)
- EL_EXPLICIT (&tmp)->label_name = explicit_loc->label_name;
+/* See description in location.h. */
- if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
- EL_EXPLICIT (&tmp)->line_offset = explicit_loc->line_offset;
- }
+const address_location_spec *
+as_address_location_spec (const location_spec *locspec)
+{
+ gdb_assert (locspec->type () == ADDRESS_LOCATION_SPEC);
+ return gdb::checked_static_cast<const address_location_spec *> (locspec);
+}
+
+/* See description in location.h. */
- return copy_event_location (&tmp);
+location_spec_up
+new_probe_location_spec (std::string &&probe)
+{
+ return location_spec_up (new probe_location_spec (std::move (probe)));
}
/* See description in location.h. */
-struct explicit_location *
-get_explicit_location (struct event_location *location)
+const probe_location_spec *
+as_probe_location_spec (const location_spec *locspec)
{
- gdb_assert (EL_TYPE (location) == EXPLICIT_LOCATION);
- return EL_EXPLICIT (location);
+ gdb_assert (locspec->type () == PROBE_LOCATION_SPEC);
+ return gdb::checked_static_cast<const probe_location_spec *> (locspec);
}
/* See description in location.h. */
-const struct explicit_location *
-get_explicit_location_const (const struct event_location *location)
+const explicit_location_spec *
+as_explicit_location_spec (const location_spec *locspec)
{
- gdb_assert (EL_TYPE (location) == EXPLICIT_LOCATION);
- return EL_EXPLICIT (location);
+ gdb_assert (locspec->type () == EXPLICIT_LOCATION_SPEC);
+ return gdb::checked_static_cast<const explicit_location_spec *> (locspec);
}
-/* This convenience function returns a malloc'd string which
- represents the location in EXPLICIT_LOC.
+/* See description in location.h. */
- AS_LINESPEC is non-zero if this string should be a linespec.
- Otherwise it will be output in explicit form. */
+explicit_location_spec *
+as_explicit_location_spec (location_spec *locspec)
+{
+ gdb_assert (locspec->type () == EXPLICIT_LOCATION_SPEC);
+ return gdb::checked_static_cast<explicit_location_spec *> (locspec);
+}
-static char *
-explicit_to_string_internal (int as_linespec,
- const struct explicit_location *explicit_loc)
+/* Return a string representation of the explicit location spec in
+ EXPLICIT_LOCSPEC.
+
+ AS_LINESPEC is true if this string should be a linespec. Otherwise
+ it will be output in explicit form. */
+
+static std::string
+explicit_to_string_internal (bool as_linespec,
+ const explicit_location_spec *explicit_loc)
{
- int need_space = 0;
+ bool need_space = false;
char space = as_linespec ? ':' : ' ';
string_file buf;
if (!as_linespec)
buf.puts ("-source ");
buf.puts (explicit_loc->source_filename);
- need_space = 1;
+ need_space = true;
}
if (explicit_loc->function_name != NULL)
{
if (need_space)
buf.putc (space);
+ if (explicit_loc->func_name_match_type == symbol_name_match_type::FULL)
+ buf.puts ("-qualified ");
if (!as_linespec)
buf.puts ("-function ");
buf.puts (explicit_loc->function_name);
- need_space = 1;
+ need_space = true;
}
if (explicit_loc->label_name != NULL)
if (!as_linespec)
buf.puts ("-label ");
buf.puts (explicit_loc->label_name);
- need_space = 1;
+ need_space = true;
}
if (explicit_loc->line_offset.sign != LINE_OFFSET_UNKNOWN)
explicit_loc->line_offset.offset);
}
- return xstrdup (buf.c_str ());
+ return buf.release ();
}
/* See description in location.h. */
-char *
-explicit_location_to_string (const struct explicit_location *explicit_loc)
+std::string
+explicit_location_spec::to_linespec () const
{
- return explicit_to_string_internal (0, explicit_loc);
+ return explicit_to_string_internal (true, this);
}
-/* See description in location.h. */
+/* Find an instance of the quote character C in the string S that is
+ outside of all single- and double-quoted strings (i.e., any quoting
+ other than C). */
-char *
-explicit_location_to_linespec (const struct explicit_location *explicit_loc)
+static const char *
+find_end_quote (const char *s, char end_quote_char)
{
- return explicit_to_string_internal (1, explicit_loc);
+ /* zero if we're not in quotes;
+ '"' if we're in a double-quoted string;
+ '\'' if we're in a single-quoted string. */
+ char nested_quote_char = '\0';
+
+ for (const char *scan = s; *scan != '\0'; scan++)
+ {
+ if (nested_quote_char != '\0')
+ {
+ if (*scan == nested_quote_char)
+ nested_quote_char = '\0';
+ else if (scan[0] == '\\' && *(scan + 1) != '\0')
+ scan++;
+ }
+ else if (*scan == end_quote_char && nested_quote_char == '\0')
+ return scan;
+ else if (*scan == '"' || *scan == '\'')
+ nested_quote_char = *scan;
+ }
+
+ return 0;
}
-/* See description in location.h. */
+/* A lexer for explicit location specs. This function will advance
+ INP past any strings that it lexes. Returns a malloc'd copy of the
+ lexed string or NULL if no lexing was done. */
-event_location_up
-copy_event_location (const struct event_location *src)
+static gdb::unique_xmalloc_ptr<char>
+explicit_location_spec_lex_one (const char **inp,
+ const struct language_defn *language,
+ explicit_completion_info *completion_info)
{
- struct event_location *dst;
+ const char *start = *inp;
- dst = XCNEW (struct event_location);
- EL_TYPE (dst) = EL_TYPE (src);
- if (EL_STRING (src) != NULL)
- EL_STRING (dst) = xstrdup (EL_STRING (src));
+ if (*start == '\0')
+ return NULL;
- switch (EL_TYPE (src))
+ /* If quoted, skip to the ending quote. */
+ if (strchr (get_gdb_linespec_parser_quote_characters (), *start))
{
- case LINESPEC_LOCATION:
- if (EL_LINESPEC (src) != NULL)
- EL_LINESPEC (dst) = xstrdup (EL_LINESPEC (src));
- break;
-
- case ADDRESS_LOCATION:
- EL_ADDRESS (dst) = EL_ADDRESS (src);
- break;
-
- case EXPLICIT_LOCATION:
- if (EL_EXPLICIT (src)->source_filename != NULL)
- EL_EXPLICIT (dst)->source_filename
- = xstrdup (EL_EXPLICIT (src)->source_filename);
+ if (completion_info != NULL)
+ completion_info->quoted_arg_start = start;
- if (EL_EXPLICIT (src)->function_name != NULL)
- EL_EXPLICIT (dst)->function_name
- = xstrdup (EL_EXPLICIT (src)->function_name);
+ const char *end = find_end_quote (start + 1, *start);
- if (EL_EXPLICIT (src)->label_name != NULL)
- EL_EXPLICIT (dst)->label_name = xstrdup (EL_EXPLICIT (src)->label_name);
+ if (end == NULL)
+ {
+ if (completion_info == NULL)
+ error (_("Unmatched quote, %s."), start);
- EL_EXPLICIT (dst)->line_offset = EL_EXPLICIT (src)->line_offset;
- break;
+ end = start + strlen (start);
+ *inp = end;
+ return gdb::unique_xmalloc_ptr<char> (savestring (start + 1,
+ *inp - start - 1));
+ }
+ if (completion_info != NULL)
+ completion_info->quoted_arg_end = end;
+ *inp = end + 1;
+ return gdb::unique_xmalloc_ptr<char> (savestring (start + 1,
+ *inp - start - 2));
+ }
- case PROBE_LOCATION:
- if (EL_PROBE (src) != NULL)
- EL_PROBE (dst) = xstrdup (EL_PROBE (src));
- break;
+ /* If the input starts with '-' or '+', the string ends with the next
+ whitespace or comma. */
+ if (*start == '-' || *start == '+')
+ {
+ while (*inp[0] != '\0' && *inp[0] != ',' && !isspace (*inp[0]))
+ ++(*inp);
+ }
+ else
+ {
+ /* Handle numbers first, stopping at the next whitespace or ','. */
+ while (isdigit (*inp[0]))
+ ++(*inp);
+ if (*inp[0] == '\0' || isspace (*inp[0]) || *inp[0] == ',')
+ return gdb::unique_xmalloc_ptr<char> (savestring (start,
+ *inp - start));
- default:
- gdb_assert_not_reached ("unknown event location type");
+ /* Otherwise stop at the next occurrence of whitespace, '\0',
+ keyword, or ','. */
+ *inp = start;
+ while ((*inp)[0]
+ && (*inp)[0] != ','
+ && !(isspace ((*inp)[0])
+ || linespec_lexer_lex_keyword (&(*inp)[1])))
+ {
+ /* Special case: C++ operator,. */
+ if (language->la_language == language_cplus
+ && startswith (*inp, CP_OPERATOR_STR))
+ (*inp) += CP_OPERATOR_LEN;
+ ++(*inp);
+ }
}
- return event_location_up (dst);
+ if (*inp - start > 0)
+ return gdb::unique_xmalloc_ptr<char> (savestring (start, *inp - start));
+
+ return NULL;
}
-void
-event_location_deleter::operator() (event_location *location) const
+/* Return true if COMMA points past "operator". START is the start of
+ the line that COMMAND points to, hence when reading backwards, we
+ must not read any character before START. */
+
+static bool
+is_cp_operator (const char *start, const char *comma)
{
- if (location != NULL)
+ if (comma != NULL
+ && (comma - start) >= CP_OPERATOR_LEN)
{
- xfree (EL_STRING (location));
+ const char *p = comma;
- switch (EL_TYPE (location))
+ while (p > start && isspace (p[-1]))
+ p--;
+ if (p - start >= CP_OPERATOR_LEN)
{
- case LINESPEC_LOCATION:
- xfree (EL_LINESPEC (location));
- break;
-
- case ADDRESS_LOCATION:
- /* Nothing to do. */
- break;
-
- case EXPLICIT_LOCATION:
- xfree (EL_EXPLICIT (location)->source_filename);
- xfree (EL_EXPLICIT (location)->function_name);
- xfree (EL_EXPLICIT (location)->label_name);
- break;
-
- case PROBE_LOCATION:
- xfree (EL_PROBE (location));
- break;
-
- default:
- gdb_assert_not_reached ("unknown event location type");
+ p -= CP_OPERATOR_LEN;
+ if (strncmp (p, CP_OPERATOR_STR, CP_OPERATOR_LEN) == 0
+ && (p == start
+ || !(isalnum (p[-1]) || p[-1] == '_')))
+ {
+ return true;
+ }
}
-
- xfree (location);
}
+ return false;
}
-/* See description in location.h. */
-
-const char *
-event_location_to_string (struct event_location *location)
+/* When scanning the input string looking for the next explicit
+ location spec option/delimiter, we jump to the next option by looking
+ for ",", and "-". Such a character can also appear in C++ symbols
+ like "operator," and "operator-". So when we find such a
+ character, we call this function to check if we found such a
+ symbol, meaning we had a false positive for an option string. In
+ that case, we keep looking for the next delimiter, until we find
+ one that is not a false positive, or we reach end of string. FOUND
+ is the character that scanning found (either '-' or ','), and START
+ is the start of the line that FOUND points to, hence when reading
+ backwards, we must not read any character before START. Returns a
+ pointer to the next non-false-positive delimiter character, or NULL
+ if none was found. */
+
+static const char *
+skip_op_false_positives (const char *start, const char *found)
{
- if (EL_STRING (location) == NULL)
+ while (found != NULL && is_cp_operator (start, found))
{
- switch (EL_TYPE (location))
- {
- case LINESPEC_LOCATION:
- if (EL_LINESPEC (location) != NULL)
- EL_STRING (location) = xstrdup (EL_LINESPEC (location));
- break;
-
- case ADDRESS_LOCATION:
- EL_STRING (location)
- = xstrprintf ("*%s",
- core_addr_to_string (EL_ADDRESS (location)));
- break;
-
- case EXPLICIT_LOCATION:
- EL_STRING (location)
- = explicit_location_to_string (EL_EXPLICIT (location));
- break;
+ if (found[0] == '-' && found[1] == '-')
+ start = found + 2;
+ else
+ start = found + 1;
+ found = find_toplevel_char (start, *found);
+ }
- case PROBE_LOCATION:
- EL_STRING (location) = xstrdup (EL_PROBE (location));
- break;
+ return found;
+}
- default:
- gdb_assert_not_reached ("unknown event location type");
- }
- }
+/* Assuming both FIRST and NEW_TOK point into the same string, return
+ the pointer that is closer to the start of the string. If FIRST is
+ NULL, returns NEW_TOK. If NEW_TOK is NULL, returns FIRST. */
- return EL_STRING (location);
+static const char *
+first_of (const char *first, const char *new_tok)
+{
+ if (first == NULL)
+ return new_tok;
+ else if (new_tok != NULL && new_tok < first)
+ return new_tok;
+ else
+ return first;
}
-/* A lexer for explicit locations. This function will advance INP
- past any strings that it lexes. Returns a malloc'd copy of the
- lexed string or NULL if no lexing was done. */
+/* A lexer for functions in explicit location specs. This function will
+ advance INP past a function until the next option, or until end of
+ string. Returns a malloc'd copy of the lexed string or NULL if no
+ lexing was done. */
static gdb::unique_xmalloc_ptr<char>
-explicit_location_lex_one (const char **inp,
- const struct language_defn *language)
+explicit_location_spec_lex_one_function
+ (const char **inp,
+ const struct language_defn *language,
+ explicit_completion_info *completion_info)
{
const char *start = *inp;
if (!(language->la_language == language_ada
&& quote_char == '\"' && is_ada_operator (start)))
{
+ if (completion_info != NULL)
+ completion_info->quoted_arg_start = start;
+
const char *end = find_toplevel_char (start + 1, quote_char);
if (end == NULL)
- error (_("Unmatched quote, %s."), start);
+ {
+ if (completion_info == NULL)
+ error (_("Unmatched quote, %s."), start);
+
+ end = start + strlen (start);
+ *inp = end;
+ char *saved = savestring (start + 1, *inp - start - 1);
+ return gdb::unique_xmalloc_ptr<char> (saved);
+ }
+
+ if (completion_info != NULL)
+ completion_info->quoted_arg_end = end;
*inp = end + 1;
- return gdb::unique_xmalloc_ptr<char> (savestring (start + 1,
- *inp - start - 2));
+ char *saved = savestring (start + 1, *inp - start - 2);
+ return gdb::unique_xmalloc_ptr<char> (saved);
}
}
- /* If the input starts with '-' or '+', the string ends with the next
- whitespace or comma. */
- if (*start == '-' || *start == '+')
+ const char *comma = find_toplevel_char (start, ',');
+
+ /* If we have "-function -myfunction", or perhaps better example,
+ "-function -[BasicClass doIt]" (objc selector), treat
+ "-myfunction" as the function name. I.e., skip the first char if
+ it is an hyphen. Don't skip the first char always, because we
+ may have C++ "operator<", and find_toplevel_char needs to see the
+ 'o' in that case. */
+ const char *hyphen
+ = (*start == '-'
+ ? find_toplevel_char (start + 1, '-')
+ : find_toplevel_char (start, '-'));
+
+ /* Check for C++ "operator," and "operator-". */
+ comma = skip_op_false_positives (start, comma);
+ hyphen = skip_op_false_positives (start, hyphen);
+
+ /* Pick the one that appears first. */
+ const char *end = first_of (hyphen, comma);
+
+ /* See if a linespec keyword appears first. */
+ const char *s = start;
+ const char *ws = find_toplevel_char (start, ' ');
+ while (ws != NULL && linespec_lexer_lex_keyword (ws + 1) == NULL)
{
- while (*inp[0] != '\0' && *inp[0] != ',' && !isspace (*inp[0]))
- ++(*inp);
+ s = ws + 1;
+ ws = find_toplevel_char (s, ' ');
}
- else
- {
- /* Handle numbers first, stopping at the next whitespace or ','. */
- while (isdigit (*inp[0]))
- ++(*inp);
- if (*inp[0] == '\0' || isspace (*inp[0]) || *inp[0] == ',')
- return gdb::unique_xmalloc_ptr<char> (savestring (start,
- *inp - start));
+ if (ws != NULL)
+ end = first_of (end, ws + 1);
- /* Otherwise stop at the next occurrence of whitespace, '\0',
- keyword, or ','. */
- *inp = start;
- while ((*inp)[0]
- && (*inp)[0] != ','
- && !(isspace ((*inp)[0])
- || linespec_lexer_lex_keyword (&(*inp)[1])))
- {
- /* Special case: C++ operator,. */
- if (language->la_language == language_cplus
- && startswith (*inp, CP_OPERATOR_STR))
- (*inp) += CP_OPERATOR_LEN;
- ++(*inp);
- }
- }
+ /* If we don't have any terminator, then take the whole string. */
+ if (end == NULL)
+ end = start + strlen (start);
+
+ /* Trim whitespace at the end. */
+ while (end > start && end[-1] == ' ')
+ end--;
+
+ *inp = end;
if (*inp - start > 0)
return gdb::unique_xmalloc_ptr<char> (savestring (start, *inp - start));
/* See description in location.h. */
-event_location_up
-string_to_explicit_location (const char **argp,
- const struct language_defn *language,
- int dont_throw)
+location_spec_up
+string_to_explicit_location_spec (const char **argp,
+ const struct language_defn *language,
+ explicit_completion_info *completion_info)
{
- event_location_up location;
-
/* It is assumed that input beginning with '-' and a non-digit
character is an explicit location. "-p" is reserved, though,
for probe locations. */
|| ((*argp)[0] == '-' && (*argp)[1] == 'p'))
return NULL;
- location = new_explicit_location (NULL);
+ std::unique_ptr<explicit_location_spec> locspec
+ (new explicit_location_spec ());
/* Process option/argument pairs. dprintf_command
requires that processing stop on ','. */
int len;
const char *start;
+ /* Clear these on each iteration, since they should be filled
+ with info about the last option. */
+ if (completion_info != NULL)
+ {
+ completion_info->quoted_arg_start = NULL;
+ completion_info->quoted_arg_end = NULL;
+ }
+
/* If *ARGP starts with a keyword, stop processing
options. */
if (linespec_lexer_lex_keyword (*argp) != NULL)
/* Mark the start of the string in case we need to rewind. */
start = *argp;
+ if (completion_info != NULL)
+ completion_info->last_option = start;
+
/* Get the option string. */
gdb::unique_xmalloc_ptr<char> opt
- = explicit_location_lex_one (argp, language);
-
- *argp = skip_spaces_const (*argp);
-
- /* Get the argument string. */
- gdb::unique_xmalloc_ptr<char> oarg
- = explicit_location_lex_one (argp, language);
- bool have_oarg = oarg != NULL;
- *argp = skip_spaces_const (*argp);
+ = explicit_location_spec_lex_one (argp, language, NULL);
/* Use the length of the option to allow abbreviations. */
len = strlen (opt.get ());
- /* All options have a required argument. Checking for this required
- argument is deferred until later. */
+ /* Get the argument string. */
+ *argp = skip_spaces (*argp);
+
+ /* All options have a required argument. Checking for this
+ required argument is deferred until later. */
+ gdb::unique_xmalloc_ptr<char> oarg;
+ /* True if we have an argument. This is required because we'll
+ move from OARG before checking whether we have an
+ argument. */
+ bool have_oarg = false;
+
+ /* True if the option needs an argument. */
+ bool need_oarg = false;
+
+ /* Convenience to consistently set both OARG/HAVE_OARG from
+ ARG. */
+ auto set_oarg = [&] (gdb::unique_xmalloc_ptr<char> arg)
+ {
+ if (completion_info != NULL)
+ {
+ /* We do this here because the set of options that take
+ arguments matches the set of explicit location
+ options. */
+ completion_info->saw_explicit_location_spec_option = true;
+ }
+ oarg = std::move (arg);
+ have_oarg = oarg != NULL;
+ need_oarg = true;
+ };
+
if (strncmp (opt.get (), "-source", len) == 0)
- EL_EXPLICIT (location)->source_filename = oarg.release ();
+ {
+ set_oarg (explicit_location_spec_lex_one (argp, language,
+ completion_info));
+ locspec->source_filename = oarg.release ();
+ }
else if (strncmp (opt.get (), "-function", len) == 0)
- EL_EXPLICIT (location)->function_name = oarg.release ();
+ {
+ set_oarg (explicit_location_spec_lex_one_function (argp, language,
+ completion_info));
+ locspec->function_name = oarg.release ();
+ }
+ else if (strncmp (opt.get (), "-qualified", len) == 0)
+ {
+ locspec->func_name_match_type = symbol_name_match_type::FULL;
+ }
else if (strncmp (opt.get (), "-line", len) == 0)
{
+ set_oarg (explicit_location_spec_lex_one (argp, language, NULL));
+ *argp = skip_spaces (*argp);
if (have_oarg)
- EL_EXPLICIT (location)->line_offset
- = linespec_parse_line_offset (oarg.get ());
+ {
+ locspec->line_offset = linespec_parse_line_offset (oarg.get ());
+ continue;
+ }
}
else if (strncmp (opt.get (), "-label", len) == 0)
- EL_EXPLICIT (location)->label_name = oarg.release ();
+ {
+ set_oarg (explicit_location_spec_lex_one (argp, language,
+ completion_info));
+ locspec->label_name = oarg.release ();
+ }
/* Only emit an "invalid argument" error for options
that look like option strings. */
else if (opt.get ()[0] == '-' && !isdigit (opt.get ()[1]))
{
- if (!dont_throw)
+ if (completion_info == NULL)
error (_("invalid explicit location argument, \"%s\""), opt.get ());
}
else
Stop parsing and return whatever explicit location was
parsed. */
*argp = start;
- return location;
+ break;
}
+ *argp = skip_spaces (*argp);
+
/* It's a little lame to error after the fact, but in this
case, it provides a much better user experience to issue
the "invalid argument" error before any missing
argument error. */
- if (!have_oarg && !dont_throw)
+ if (need_oarg && !have_oarg && completion_info == NULL)
error (_("missing argument for \"%s\""), opt.get ());
}
/* One special error check: If a source filename was given
without offset, function, or label, issue an error. */
- if (EL_EXPLICIT (location)->source_filename != NULL
- && EL_EXPLICIT (location)->function_name == NULL
- && EL_EXPLICIT (location)->label_name == NULL
- && (EL_EXPLICIT (location)->line_offset.sign == LINE_OFFSET_UNKNOWN)
- && !dont_throw)
+ if (locspec->source_filename != NULL
+ && locspec->function_name == NULL
+ && locspec->label_name == NULL
+ && (locspec->line_offset.sign == LINE_OFFSET_UNKNOWN)
+ && completion_info == NULL)
{
error (_("Source filename requires function, label, or "
"line offset."));
}
- return location;
+ return location_spec_up (locspec.release ());
}
/* See description in location.h. */
-event_location_up
-string_to_event_location_basic (char **stringp,
- const struct language_defn *language)
+location_spec_up
+string_to_location_spec_basic (const char **stringp,
+ const struct language_defn *language,
+ symbol_name_match_type match_type)
{
- event_location_up location;
+ location_spec_up locspec;
const char *cs;
/* Try the input as a probe spec. */
cs = *stringp;
- if (cs != NULL && probe_linespec_to_ops (&cs) != NULL)
+ if (cs != NULL && probe_linespec_to_static_ops (&cs) != NULL)
{
- location = new_probe_location (*stringp);
+ locspec = new_probe_location_spec (*stringp);
*stringp += strlen (*stringp);
}
else
{
- /* Try an address location. */
+ /* Try an address location spec. */
if (*stringp != NULL && **stringp == '*')
{
const char *arg, *orig;
orig = arg = *stringp;
addr = linespec_expression_to_pc (&arg);
- location = new_address_location (addr, orig, arg - orig);
+ locspec = new_address_location_spec (addr, orig, arg - orig);
*stringp += arg - orig;
}
else
{
/* Everything else is a linespec. */
- location = new_linespec_location (stringp);
+ locspec = new_linespec_location_spec (stringp, match_type);
}
}
- return location;
+ return locspec;
}
/* See description in location.h. */
-event_location_up
-string_to_event_location (char **stringp,
- const struct language_defn *language)
+location_spec_up
+string_to_location_spec (const char **stringp,
+ const struct language_defn *language,
+ symbol_name_match_type match_type)
{
const char *arg, *orig;
- /* Try an explicit location. */
+ /* Try an explicit location spec. */
orig = arg = *stringp;
- event_location_up location = string_to_explicit_location (&arg, language, 0);
- if (location != NULL)
+ location_spec_up locspec
+ = string_to_explicit_location_spec (&arg, language, NULL);
+ if (locspec != nullptr)
{
/* It was a valid explicit location. Advance STRINGP to
the end of input. */
*stringp += arg - orig;
- }
- else
- {
- /* Everything else is a "basic" linespec, address, or probe
- location. */
- location = string_to_event_location_basic (stringp, language);
- }
-
- return location;
-}
-
-/* See description in location.h. */
-int
-event_location_empty_p (const struct event_location *location)
-{
- switch (EL_TYPE (location))
- {
- case LINESPEC_LOCATION:
- /* Linespecs are never "empty." (NULL is a valid linespec) */
- return 0;
-
- case ADDRESS_LOCATION:
- return 0;
-
- case EXPLICIT_LOCATION:
- return (EL_EXPLICIT (location) == NULL
- || (EL_EXPLICIT (location)->source_filename == NULL
- && EL_EXPLICIT (location)->function_name == NULL
- && EL_EXPLICIT (location)->label_name == NULL
- && (EL_EXPLICIT (location)->line_offset.sign
- == LINE_OFFSET_UNKNOWN)));
-
- case PROBE_LOCATION:
- return EL_PROBE (location) == NULL;
-
- default:
- gdb_assert_not_reached ("unknown event location type");
+ /* If the user really specified a location spec, then we're
+ done. */
+ if (!locspec->empty_p ())
+ return locspec;
+
+ /* Otherwise, the user _only_ specified optional flags like
+ "-qualified", otherwise string_to_explicit_location_spec
+ would have thrown an error. Save the flags for "basic"
+ linespec parsing below and discard the explicit location
+ spec. */
+ explicit_location_spec *xloc
+ = gdb::checked_static_cast<explicit_location_spec *> (locspec.get ());
+ match_type = xloc->func_name_match_type;
}
-}
-/* See description in location.h. */
-
-void
-set_event_location_string (struct event_location *location,
- const char *string)
-{
- xfree (EL_STRING (location));
- EL_STRING (location) = string == NULL ? NULL : xstrdup (string);
+ /* Everything else is a "basic" linespec, address, or probe location
+ spec. */
+ return string_to_location_spec_basic (stringp, language, match_type);
}
projects / thirdparty / binutils-gdb.git / blobdiff