+Thu Mar 11 09:33:01 1993 Fred Fish (fnf@cygnus.com)
+
+ * utils.c (fputs_demangled): Complete rewrite to clean up and
+ add a language parameter that is used to select the demangling
+ algorithm.
+ * defs.h (enum language): Move further up in file so enum can
+ be used in prototypes.
+ * defs.h (fputs_demangled): Update prototype to add lang arg.
+ * c-typeprint.c (cp_type_print_method_args): Add language arg
+ to fputs_demangled calls, remove DMGL_PARAMS flag.
+ * stack.c (print_frame_info): Remove obsolete code so we don't
+ have to update fputs_demangled usage in it.
+ * stack.c (print_frame_info, frame_info): Add language variable
+ to pass to fputs_demangled and initialize it from the symbol's
+ language. Call fputs_demangled with language arg.
+ * symtab.c (find_methods): Add language arg to fputs_demangled
+ call.
+
Wed Mar 10 17:37:11 1993 Fred Fish (fnf@cygnus.com)
* Makefile.in (VERSION): Bump version to 4.8.2.
{
int i;
- fputs_demangled (prefix, stream, DMGL_ANSI | DMGL_PARAMS);
- fputs_demangled (varstring, stream, DMGL_ANSI | DMGL_PARAMS);
+ fputs_demangled (prefix, stream, DMGL_ANSI, language_cplus);
+ fputs_demangled (varstring, stream, DMGL_ANSI, language_cplus);
fputs_filtered (" (", stream);
if (args && args[!staticp] && args[!staticp]->code != TYPE_CODE_VOID)
{
/* Gdb does *lots* of string compares. Use macros to speed them up by
avoiding function calls if the first characters are not the same. */
-#define STRCMP(a,b) (*(a) == *(b) ? strcmp ((a), (b)) : *(a) - *(b))
+#define STRCMP(a,b) (*(a) == *(b) ? strcmp ((a), (b)) : (int)*(a) - (int)*(b))
#define STREQ(a,b) (*(a) == *(b) ? !strcmp ((a), (b)) : 0)
#define STREQN(a,b,c) (*(a) == *(b) ? !strncmp ((a), (b), (c)) : 0)
class_pseudo
};
+/* Languages represented in the symbol table and elsewhere.
+ This should probably be in language.h, but since enum's can't
+ be forward declared to satisfy opaque references before their
+ actual definition, needs to be here. */
+
+enum language
+{
+ language_unknown, /* Language not known */
+ language_auto, /* Placeholder for automatic setting */
+ language_c, /* C */
+ language_cplus, /* C++ */
+ /* start-sanitize-chill */
+ language_chill, /* Chill */
+ /* end-sanitize-chill */
+ language_m2 /* Modula-2 */
+};
+
/* the cleanup list records things that have to be undone
if an error happens (descriptors to be closed, memory to be freed, etc.)
Each link in the chain records a function to call and an
fprint_symbol PARAMS ((FILE *, char *));
extern void
-fputs_demangled PARAMS ((char *, FILE *, int));
+fputs_demangled PARAMS ((char *, FILE *, int, enum language));
extern void
perror_with_name PARAMS ((char *));
/* Baud rate specified for communication with serial target systems. */
extern char *baud_rate;
-/* Languages represented in the symbol table and elsewhere.
- This should probably be in language.h, but since enum's can't
- be forward declared to satisfy opaque references before their
- actual definition, needs to be here. */
-
-enum language
-{
- language_unknown, /* Language not known */
- language_auto, /* Placeholder for automatic setting */
- language_c, /* C */
- language_cplus, /* C++ */
- /* start-sanitize-chill */
- language_chill, /* Chill */
- /* end-sanitize-chill */
- language_m2 /* Modula-2 */
-};
-
/* Possibilities for prettyprint parameters to routines which print
things. Like enum language, this should be in value.h, but needs
to be here for the same reason. FIXME: If we can eliminate this
# endif
#endif
+/* If we picked up a copy of CHAR_BIT from a configuration file
+ (which may get it by including <limits.h>) then use it to set
+ the number of bits in a host char. If not, use the same size
+ as the target. */
+
+#if defined (CHAR_BIT)
+#define HOST_CHAR_BIT CHAR_BIT
+#else
+#define HOST_CHAR_BIT TARGET_CHAR_BIT
+#endif
+
/* Assorted functions we can declare, now that const and volatile are
defined. */
/* Print and select stack frames for GDB, the GNU debugger.
- Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
This file is part of GDB.
struct symtab_and_line sal;
struct symbol *func;
register char *funname = 0;
+ enum language funlang = language_unknown;
int numargs;
-#if 0 /* Symbol reading is fast enough now */
- struct partial_symtab *pst;
-
- /* Don't give very much information if we haven't readin the
- symbol table yet. */
- pst = find_pc_psymtab (fi->pc);
- if (pst && !pst->readin)
- {
- /* Abbreviated information. */
- char *fname;
-
- if (!find_pc_partial_function (fi->pc, &fname, 0))
- fname = "??";
-
- printf_filtered ("#%-2d ", level);
- if (addressprint)
- printf_filtered ("%s in ", local_hex_string(fi->pc));
-
- fputs_demangled (fname, stdout, 0);
- fputs_filtered (" (...)\n", stdout);
-
- return;
- }
-#endif
-
#ifdef CORE_NEEDS_RELOCATION
CORE_NEEDS_RELOCATION(fi->pc);
#endif
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
if (msymbol != NULL
- && (msymbol -> address
+ && (SYMBOL_VALUE_ADDRESS (msymbol)
> BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
{
/* In this case we have no way of knowing the source file
/* We also don't know anything about the function besides
its address and name. */
func = 0;
- funname = msymbol -> name;
+ funname = SYMBOL_NAME (msymbol);
+ funlang = SYMBOL_LANGUAGE (msymbol);
}
else
- funname = SYMBOL_NAME (func);
+ {
+ funname = SYMBOL_NAME (func);
+ funlang = SYMBOL_LANGUAGE (func);
+ }
}
else
{
register struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
if (msymbol != NULL)
- funname = msymbol -> name;
+ {
+ funname = SYMBOL_NAME (msymbol);
+ funlang = SYMBOL_LANGUAGE (msymbol);
+ }
}
if (source >= 0 || !sal.symtab)
if (addressprint)
if (fi->pc != sal.pc || !sal.symtab)
printf_filtered ("%s in ", local_hex_string(fi->pc));
- fputs_demangled (funname ? funname : "??", stdout, 0);
+ fputs_demangled (funname ? funname : "??", stdout, 0, funlang);
wrap_here (" ");
fputs_filtered (" (", stdout);
if (args)
fflush (stdout);
}
-#ifdef FRAME_SPECIFICATION_DYADIC
-extern FRAME setup_arbitrary_frame ();
-#endif
-
/*
* Read a frame specification in whatever the appropriate format is.
* Call error() if the specification is in any way invalid (i.e.
char *frame_exp;
{
int numargs = 0;
- int arg1, arg2;
+ int arg1, arg2, arg3;
+#define MAXARGS 4
+ int args[MAXARGS];
if (frame_exp)
{
struct cleanup *tmp_cleanup;
while (*frame_exp == ' ') frame_exp++;
- for (p = frame_exp; *p && *p != ' '; p++)
- ;
- if (*frame_exp)
+ while (*frame_exp)
{
- numargs = 1;
+ if (numargs > MAXARGS)
+ error ("Too many args in frame specification");
+ /* Parse an argument. */
+ for (p = frame_exp; *p && *p != ' '; p++)
+ ;
addr_string = savestring(frame_exp, p - frame_exp);
{
tmp_cleanup = make_cleanup (free, addr_string);
- arg1 = parse_and_eval_address (addr_string);
+ args[numargs++] = parse_and_eval_address (addr_string);
do_cleanups (tmp_cleanup);
}
+ /* Skip spaces, move to possible next arg. */
while (*p == ' ') p++;
-
- if (*p)
- {
- numargs = 2;
- arg2 = parse_and_eval_address (p);
- }
+ frame_exp = p;
}
}
/* NOTREACHED */
case 1:
{
- int level = arg1;
+ int level = args[0];
FRAME fid = find_relative_frame (get_current_frame (), &level);
FRAME tfid;
(s)he gets. Still, give the highest one that matches. */
for (fid = get_current_frame ();
- fid && FRAME_FP (fid) != arg1;
+ fid && FRAME_FP (fid) != args[0];
fid = get_prev_frame (fid))
;
if (fid)
while ((tfid = get_prev_frame (fid)) &&
- (FRAME_FP (tfid) == arg1))
+ (FRAME_FP (tfid) == args[0]))
fid = tfid;
-#ifdef FRAME_SPECIFICATION_DYADIC
- if (!fid)
- error ("Incorrect number of args in frame specification");
-
- return fid;
-#else
- return create_new_frame (arg1, 0);
-#endif
+ /* We couldn't identify the frame as an existing frame, but
+ perhaps we can create one with a single argument.
+ Fall through to default case; it's up to SETUP_ARBITRARY_FRAME
+ to complain if it doesn't like a single arg. */
}
- /* NOTREACHED */
- case 2:
- /* Must be addresses */
-#ifndef FRAME_SPECIFICATION_DYADIC
- error ("Incorrect number of args in frame specification");
+
+ default:
+#ifdef SETUP_ARBITRARY_FRAME
+ return SETUP_ARBITRARY_FRAME (numargs, args);
#else
- return setup_arbitrary_frame (arg1, arg2);
+ /* Usual case. Do it here rather than have everyone supply
+ a SETUP_ARBITRARY_FRAME that does this. */
+ if (numargs == 1)
+ return create_new_frame (args[0], 0);
+ error ("Too many args in frame specification");
#endif
/* NOTREACHED */
}
- fatal ("Internal: Error in parsing in parse_frame_specification");
/* NOTREACHED */
}
FRAME calling_frame;
int i, count;
char *funname = 0;
+ enum language funlang = language_unknown;
if (!target_has_stack)
error ("No inferior or core file.");
func = get_frame_function (frame);
s = find_pc_symtab(fi->pc);
if (func)
- funname = SYMBOL_NAME (func);
+ {
+ funname = SYMBOL_NAME (func);
+ funlang = SYMBOL_LANGUAGE (func);
+ }
else
{
register struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
if (msymbol != NULL)
- funname = msymbol -> name;
+ {
+ funname = SYMBOL_NAME (msymbol);
+ funlang = SYMBOL_LANGUAGE (msymbol);
+ }
}
calling_frame = get_prev_frame (frame);
if (funname)
{
printf_filtered (" in ");
- fputs_demangled (funname, stdout, DMGL_ANSI | DMGL_PARAMS);
+ fputs_demangled (funname, stdout, DMGL_ANSI | DMGL_PARAMS, funlang);
}
wrap_here (" ");
if (sal.symtab)
if (s)
printf_filtered(" source language %s.\n", language_str(s->language));
+#ifdef PRINT_EXTRA_FRAME_INFO
+ PRINT_EXTRA_FRAME_INFO (fi);
+#endif
+
{
/* Address of the argument list for this frame, or 0. */
CORE_ADDR arg_list = FRAME_ARGS_ADDRESS_CORRECT (fi);
|| SYMBOL_CLASS (sym) == LOC_STATIC)
{
values_printed = 1;
- fprint_symbol (stream, SYMBOL_NAME (sym));
+ fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
fputs_filtered (" = ", stream);
print_variable_value (sym, frame, stream);
fprintf_filtered (stream, "\n");
for (i = 0; i < nsyms; i++)
{
sym = BLOCK_SYM (b, i);
- if (! strcmp (SYMBOL_NAME (sym), "default"))
+ if (STREQ (SYMBOL_NAME (sym), "default"))
{
if (*have_default)
continue;
struct symtab_and_line sal;
sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
values_printed = 1;
- fputs_demangled (SYMBOL_NAME (sym), stream, DMGL_ANSI | DMGL_PARAMS);
+ fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
if (addressprint)
fprintf_filtered (stream, " %s",
local_hex_string(SYMBOL_VALUE_ADDRESS (sym)));
|| SYMBOL_CLASS (sym) == LOC_REGPARM)
{
values_printed = 1;
- fprint_symbol (stream, SYMBOL_NAME (sym));
+ fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
fputs_filtered (" = ", stream);
/* We have to look up the symbol because arguments often have
two entries (one a parameter, one a register) and the one
FRAME_ADDR selected_frame_addr;
CORE_ADDR selected_frame_pc;
FRAME frame;
- char *funcname;
- struct cleanup *back_to;
value return_value;
if (selected_frame == NULL)
{
if (thisfun != 0)
{
- funcname = strdup_demangled (SYMBOL_NAME (thisfun));
- back_to = make_cleanup (free, funcname);
- if (!query ("Make %s return now? ", funcname))
+ if (!query ("Make %s return now? ", SYMBOL_SOURCE_NAME (thisfun)))
{
error ("Not confirmed.");
/* NOTREACHED */
}
- do_cleanups (back_to);
}
else
if (!query ("Make selected stack frame return now? "))
else
{
fputs_filtered("(Cannot find method ", stdout);
- fputs_demangled(phys_name, stdout, DMGL_PARAMS);
+ fputs_demangled(phys_name, stdout, DMGL_PARAMS,
+ language_cplus);
fputs_filtered(" - possibly inlined.)\n", stdout);
}
}
#include "bfd.h"
#include "target.h"
#include "demangle.h"
+#include "expression.h"
+#include "language.h"
/* Prototypes for local functions */
#else
error ("Quit (expect signal %d when inferior is resumed)", SIGINT);
#endif /* TIOCGPGRP */
+#else
+ error ("Quit");
#endif
}
+
+#ifdef __GO32__
+
+/* In the absence of signals, poll keyboard for a quit.
+ Called from #define QUIT pollquit() in xm-go32.h. */
+
+void
+pollquit()
+{
+ if (kbhit ())
+ {
+ int k = getkey ();
+ if (k == 1)
+ quit_flag = 1;
+ else if (k == 2)
+ immediate_quit = 1;
+ quit ();
+ }
+}
+
+#endif
+
/* Control C comes here */
void
}
-/* fputs_demangled is a variant of fputs_filtered that
- demangles g++ names.*/
+/* fputs_demangled attempts to demangle NAME, a symbol in language LANG, using
+ demangling args ARG_MODE, and print it filtered to STREAM. If the name is
+ not mangled, or the language for the name is unknown, or demangling is off,
+ the name is printed in its "raw" form. */
void
-fputs_demangled (linebuffer, stream, arg_mode)
- char *linebuffer;
+fputs_demangled (name, stream, arg_mode, lang)
+ char *name;
FILE *stream;
int arg_mode;
+ enum language lang;
{
-#define SYMBOL_MAX 1024
-
-#define SYMBOL_CHAR(c) (isascii(c) \
- && (isalnum(c) || (c) == '_' || (c) == CPLUS_MARKER))
-
- char buf[SYMBOL_MAX+1];
-# define DMSLOP 5 /* How much room to leave in buf */
- char *p;
-
- if (linebuffer == NULL)
- return;
-
- /* If user wants to see raw output, no problem. */
- if (!demangle) {
- fputs_filtered (linebuffer, stream);
- return;
- }
-
- p = linebuffer;
-
- while ( *p != (char) 0 ) {
- int i = 0;
-
- /* collect non-interesting characters into buf */
- while (*p != (char) 0 && !SYMBOL_CHAR(*p) && i < (int)sizeof(buf)-DMSLOP ) {
- buf[i++] = *p;
- p++;
- }
- if (i > 0) {
- /* output the non-interesting characters without demangling */
- buf[i] = (char) 0;
- fputs_filtered(buf, stream);
- i = 0; /* reset buf */
- }
+ char *demangled;
- /* and now the interesting characters */
- while (i < SYMBOL_MAX
- && *p != (char) 0
- && SYMBOL_CHAR(*p)
- && i < (int)sizeof(buf) - DMSLOP) {
- buf[i++] = *p;
- p++;
- }
- buf[i] = (char) 0;
- if (i > 0) {
- char * result;
-
- if ( (result = cplus_demangle(buf, arg_mode)) != NULL ) {
- fputs_filtered(result, stream);
- free(result);
- }
- else {
- fputs_filtered(buf, stream);
- }
+ if (name != NULL)
+ {
+ /* If user wants to see raw output, no problem. */
+ if (!demangle)
+ {
+ fputs_filtered (name, stream);
+ }
+ else
+ {
+ switch (lang)
+ {
+ case language_cplus:
+ demangled = cplus_demangle (name, arg_mode);
+ break;
+ /* start-sanitize-chill */
+ case language_chill:
+ demangled = chill_demangle (name);
+ break;
+ /* end-sanitize-chill */
+ default:
+ demangled = NULL;
+ break;
+ }
+ fputs_filtered (demangled ? demangled : name, stream);
+ if (demangled != NULL)
+ {
+ free (demangled);
+ }
+ }
}
- }
}
/* Print a variable number of ARGS using format FORMAT. If this
\f
/* C++ demangler stuff. */
-/* Make a copy of a symbol, applying C++ demangling if demangling is enabled
- and a demangled version exists. Note that the value returned from
- cplus_demangle is already allocated in malloc'd memory. */
-
-char *
-strdup_demangled (name)
- const char *name;
-{
- char *demangled = NULL;
-
- if (demangle)
- {
- demangled = cplus_demangle (name, DMGL_PARAMS | DMGL_ANSI);
- }
- return ((demangled != NULL) ? demangled : strdup (name));
-}
-
-
/* Print NAME on STREAM, demangling if necessary. */
void
fprint_symbol (stream, name)
FILE *stream;
char *name;
{
- char *demangled;
- if ((!demangle)
- || NULL == (demangled = cplus_demangle (name, DMGL_PARAMS | DMGL_ANSI)))
- fputs_filtered (name, stream);
+ char *demangled = NULL;
+
+ if (demangle)
+ {
+ /* Lacking a better method of knowing what demangler to use, pick
+ one appropriate for whatever the current language is. (FIXME) */
+ switch (current_language -> la_language)
+ {
+ case language_cplus:
+ demangled = cplus_demangle (name, DMGL_PARAMS | DMGL_ANSI);
+ break;
+ /* start-sanitize-chill */
+ case language_chill:
+ demangled = chill_demangle (name);
+ break;
+ /* end-sanitize-chill */
+ }
+ }
+ if (demangled == NULL)
+ {
+ fputs_filtered (name, stream);
+ }
else
{
fputs_filtered (demangled, stream);
#ifdef SIGWINCH_HANDLER_BODY
SIGWINCH_HANDLER_BODY
#endif
+
projects / binutils-gdb.git / commitdiff