/* Helper routines for C++ support in GDB.
- Copyright (C) 2002-2015 Free Software Foundation, Inc.
+ Copyright (C) 2002-2016 Free Software Foundation, Inc.
Contributed by MontaVista Software.
#include "expression.h"
#include "value.h"
#include "cp-abi.h"
+#include "namespace.h"
#include <signal.h>
-
+#include "gdb_setjmp.h"
#include "safe-ctype.h"
#define d_left(dc) (dc)->u.s_binary.left
long *len)
{
*len = strlen (string);
- return obstack_copy (obstack, string, *len);
+ return (char *) obstack_copy (obstack, string, *len);
}
/* A cleanup wrapper for cp_demangled_name_parse_free. */
TRY
{
- sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
+ sym = lookup_symbol (name, 0, VAR_DOMAIN, 0).symbol;
}
CATCH (except, RETURN_MASK_ALL)
{
Canonicalize the name again, and store it in the
current node (RET_COMP). */
- char *canon = cp_canonicalize_string_no_typedefs (name);
+ std::string canon = cp_canonicalize_string_no_typedefs (name);
- if (canon != NULL)
+ if (!canon.empty ())
{
- /* Copy the canonicalization into the obstack and
- free CANON. */
- name = copy_string_to_obstack (&info->obstack, canon, &len);
- xfree (canon);
+ /* Copy the canonicalization into the obstack. */
+ name = copy_string_to_obstack (&info->obstack, canon.c_str (), &len);
}
ret_comp->u.s_name.s = name;
sym = NULL;
TRY
{
- sym = lookup_symbol (local_name, 0, VAR_DOMAIN, 0);
+ sym = lookup_symbol (local_name, 0, VAR_DOMAIN, 0).symbol;
}
CATCH (except, RETURN_MASK_ALL)
{
}
}
-/* Parse STRING and convert it to canonical form, resolving any typedefs.
- If parsing fails, or if STRING is already canonical, return NULL.
- Otherwise return the canonical form. The return value is allocated via
- xmalloc. If FINDER is not NULL, then type components are passed to
- FINDER to be looked up. DATA is passed verbatim to FINDER. */
+/* Parse STRING and convert it to canonical form, resolving any
+ typedefs. If parsing fails, or if STRING is already canonical,
+ return the empty string. Otherwise return the canonical form. If
+ FINDER is not NULL, then type components are passed to FINDER to be
+ looked up. DATA is passed verbatim to FINDER. */
-char *
+std::string
cp_canonicalize_string_full (const char *string,
canonicalization_ftype *finder,
void *data)
{
- char *ret;
+ std::string ret;
unsigned int estimated_len;
struct demangle_parse_info *info;
- ret = NULL;
estimated_len = strlen (string) * 2;
info = cp_demangled_name_to_comp (string, NULL);
if (info != NULL)
/* Convert the tree back into a string. */
ret = cp_comp_to_string (info->tree, estimated_len);
- gdb_assert (ret != NULL);
+ gdb_assert (!ret.empty ());
/* Free the parse information. */
cp_demangled_name_parse_free (info);
/* Finally, compare the original string with the computed
name, returning NULL if they are the same. */
- if (strcmp (string, ret) == 0)
- {
- xfree (ret);
- return NULL;
- }
+ if (ret == string)
+ return std::string ();
}
return ret;
/* Like cp_canonicalize_string_full, but always passes NULL for
FINDER. */
-char *
+std::string
cp_canonicalize_string_no_typedefs (const char *string)
{
return cp_canonicalize_string_full (string, NULL, NULL);
}
/* Parse STRING and convert it to canonical form. If parsing fails,
- or if STRING is already canonical, return NULL. Otherwise return
- the canonical form. The return value is allocated via xmalloc. */
+ or if STRING is already canonical, return the empty string.
+ Otherwise return the canonical form. */
-char *
+std::string
cp_canonicalize_string (const char *string)
{
struct demangle_parse_info *info;
unsigned int estimated_len;
- char *ret;
if (cp_already_canonical (string))
- return NULL;
+ return std::string ();
info = cp_demangled_name_to_comp (string, NULL);
if (info == NULL)
- return NULL;
+ return std::string ();
estimated_len = strlen (string) * 2;
- ret = cp_comp_to_string (info->tree, estimated_len);
+ std::string ret = cp_comp_to_string (info->tree, estimated_len);
cp_demangled_name_parse_free (info);
- if (ret == NULL)
+ if (ret.empty ())
{
warning (_("internal error: string \"%s\" failed to be canonicalized"),
string);
- return NULL;
+ return std::string ();
}
- if (strcmp (string, ret) == 0)
- {
- xfree (ret);
- return NULL;
- }
+ if (ret == string)
+ return std::string ();
return ret;
}
return strlen (name);
}
case '\0':
- case ':':
return index;
+ case ':':
+ /* ':' marks a component iff the next character is also a ':'.
+ Otherwise it is probably malformed input. */
+ if (name[index + 1] == ':')
+ return index;
+ break;
case 'o':
/* Operator names can screw up the recursion. */
if (operator_possible
sym_return_val_size = 100;
sym_return_val_index = 0;
- sym_return_val = xmalloc ((sym_return_val_size + 1) *
- sizeof (struct symbol *));
+ sym_return_val = XNEWVEC (struct symbol *, sym_return_val_size + 1);
sym_return_val[0] = NULL;
old_cleanups = make_cleanup (xfree, sym_return_val);
else
{
char *concatenated_name
- = alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
+ = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
strcpy (concatenated_name, the_namespace);
strcat (concatenated_name, "::");
strcat (concatenated_name, func_name);
else
{
char *concatenated_name
- = alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
+ = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
strcpy (concatenated_name, the_namespace);
strcat (concatenated_name, "::");
if (prefix_len != 0)
{
- the_namespace = alloca (prefix_len + 1);
+ the_namespace = (char *) alloca (prefix_len + 1);
strncpy (the_namespace, type_name, prefix_len);
the_namespace[prefix_len] = '\0';
static void
reset_directive_searched (void *data)
{
- struct using_direct *direct = data;
+ struct using_direct *direct = (struct using_direct *) data;
direct->searched = 0;
}
/* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417.
Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */
- rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL);
+ rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol;
if (rtti_sym == NULL)
{
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
struct sigaction sa, old_sa;
#else
- void (*ofunc) ();
+ sighandler_t ofunc;
#endif
static int core_dump_allowed = -1;
#endif
sigaction (SIGSEGV, &sa, &old_sa);
#else
- ofunc = (void (*)()) signal (SIGSEGV, gdb_demangle_signal_handler);
+ ofunc = signal (SIGSEGV, gdb_demangle_signal_handler);
#endif
crash_signal = SIGSETJMP (gdb_demangle_jmp_buf);
"demangler-warning", short_msg);
make_cleanup (xfree, long_msg);
- target_terminal_ours ();
+ make_cleanup_restore_target_terminal ();
+ target_terminal_ours_for_output ();
+
begin_line ();
if (core_dump_allowed)
fprintf_unfiltered (gdb_stderr,
return result;
}
+/* See cp-support.h. */
+
+int
+gdb_sniff_from_mangled_name (const char *mangled, char **demangled)
+{
+ *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
+ return *demangled != NULL;
+}
+
/* Don't allow just "maintenance cplus". */
static void
return;
len = cp_find_first_component (arg);
- prefix = alloca (len + 1);
+ prefix = (char *) alloca (len + 1);
memcpy (prefix, arg, len);
prefix[len] = '\0';