-/* TK interface routines.
- Copyright 1994 Free Software Foundation, Inc.
+/* Tcl/Tk interface routines.
+ Copyright 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
+
+ Written by Stu Grossman <grossman@cygnus.com> of Cygnus Support.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "defs.h"
#include "symtab.h"
#include "target.h"
#include <tcl.h>
#include <tk.h>
+#include <itcl.h>
+#include <tix.h>
+
+#ifdef IDE
+#include "event.h"
+#include "idetcl.h"
+#endif
+
+#ifdef ANSI_PROTOTYPES
+#include <stdarg.h>
+#else
#include <varargs.h>
+#endif
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
#include <setjmp.h>
#include "top.h"
#include <sys/ioctl.h>
-#include <string.h>
+#include "gdb_string.h"
#include "dis-asm.h"
+#include <stdio.h>
+#include "gdbcmd.h"
+#ifndef WINNT
#ifndef FIOASYNC
#include <sys/stropts.h>
#endif
+#endif
-/* Non-zero means that we're doing the gdbtk interface. */
-int gdbtk = 0;
+#ifdef WINNT
+#define GDBTK_PATH_SEP ";"
+#else
+#define GDBTK_PATH_SEP ":"
+#endif
+
+/* Some versions (1.3.79, 1.3.81) of Linux don't support SIOCSPGRP the way
+ gdbtk wants to use it... */
+#ifdef __linux__
+#undef SIOCSPGRP
+#endif
-/* Non-zero means we are reloading breakpoints, etc from the
- Gdbtk kernel, and we should suppress various messages */
-static int gdbtk_reloading = 0;
+static void null_routine PARAMS ((int));
+static void gdbtk_flush PARAMS ((FILE *));
+static void gdbtk_fputs PARAMS ((const char *, FILE *));
+static int gdbtk_query PARAMS ((const char *, va_list));
+static char *gdbtk_readline PARAMS ((char *));
+static void gdbtk_init PARAMS ((char *));
+static void tk_command_loop PARAMS ((void));
+static void gdbtk_call_command PARAMS ((struct cmd_list_element *, char *, int));
+static int gdbtk_wait PARAMS ((int, struct target_waitstatus *));
+static void x_event PARAMS ((int));
+static void gdbtk_interactive PARAMS ((void));
+static void cleanup_init PARAMS ((int));
+static void tk_command PARAMS ((char *, int));
+static int gdb_disassemble PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static int compare_lines PARAMS ((const PTR, const PTR));
+static int gdbtk_dis_asm_read_memory PARAMS ((bfd_vma, bfd_byte *, int, disassemble_info *));
+static int gdb_path_conv PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static int gdb_stop PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static int gdb_listfiles PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static int gdb_listfuncs PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static int call_wrapper PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static int gdb_cmd PARAMS ((ClientData, Tcl_Interp *, int, char *argv[]));
+static int gdb_fetch_registers PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static void gdbtk_readline_end PARAMS ((void));
+static int gdb_changed_register_list PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static void register_changed_p PARAMS ((int, void *));
+static int gdb_get_breakpoint_list PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static int gdb_get_breakpoint_info PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static void breakpoint_notify PARAMS ((struct breakpoint *, const char *));
+static void gdbtk_create_breakpoint PARAMS ((struct breakpoint *));
+static void gdbtk_delete_breakpoint PARAMS ((struct breakpoint *));
+static void gdbtk_modify_breakpoint PARAMS ((struct breakpoint *));
+static int gdb_loc PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static int gdb_eval PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static int gdb_sourcelines PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static int map_arg_registers PARAMS ((int, char *[], void (*) (int, void *), void *));
+static void get_register_name PARAMS ((int, void *));
+static int gdb_regnames PARAMS ((ClientData, Tcl_Interp *, int, char *[]));
+static void get_register PARAMS ((int, void *));
/* Handle for TCL interpreter */
-static Tcl_Interp *interp = NULL;
-/* Handle for TK main window */
-static Tk_Window mainWindow = NULL;
+static Tcl_Interp *interp = NULL;
static int x_fd; /* X network socket */
-/* This variable determines where memory used for disassembly is read from.
+/* This variable is true when the inferior is running. Although it's
+ possible to disable most input from widgets and thus prevent
+ attempts to do anything while the inferior is running, any commands
+ that get through - even a simple memory read - are Very Bad, and
+ may cause GDB to crash or behave strangely. So, this variable
+ provides an extra layer of defense. */
- If > 0, then disassembly comes from the exec file rather than the target
- (which might be at the other end of a slow serial link). If == 0 then
- disassembly comes from target. If < 0 disassembly is automatically switched
- to the target if it's an inferior process, otherwise the exec file is
- used.
- */
+static int running_now;
+
+/* This variable determines where memory used for disassembly is read from.
+ If > 0, then disassembly comes from the exec file rather than the
+ target (which might be at the other end of a slow serial link). If
+ == 0 then disassembly comes from target. If < 0 disassembly is
+ automatically switched to the target if it's an inferior process,
+ otherwise the exec file is used. */
static int disassemble_from_exec = -1;
+#ifndef _WIN32
+
+/* Supply malloc calls for tcl/tk. We do not want to do this on
+ Windows, because Tcl_Alloc is probably in a DLL which will not call
+ the mmalloc routines. */
+
+char *
+Tcl_Alloc (size)
+ unsigned int size;
+{
+ return xmalloc (size);
+}
+
+char *
+Tcl_Realloc (ptr, size)
+ char *ptr;
+ unsigned int size;
+{
+ return xrealloc (ptr, size);
+}
+
+void
+Tcl_Free(ptr)
+ char *ptr;
+{
+ free (ptr);
+}
+
+#endif /* _WIN32 */
+
static void
null_routine(arg)
int arg;
/* Dynamic string header for stdout. */
-static Tcl_DString stdout_buffer;
-
-/* Use this to collect stdout output that will be returned as the result of a
- tcl command. */
+static Tcl_DString *result_ptr;
+\f
+static void
+gdbtk_flush (stream)
+ FILE *stream;
+{
+#if 0
+ /* Force immediate screen update */
-static int saving_output = 0;
+ Tcl_VarEval (interp, "gdbtk_tcl_flush", NULL);
+#endif
+}
static void
-start_saving_output ()
+gdbtk_fputs (ptr, stream)
+ const char *ptr;
+ FILE *stream;
{
- saving_output = 1;
-}
+ if (result_ptr)
+ Tcl_DStringAppend (result_ptr, (char *)ptr, -1);
+ else
+ {
+ Tcl_DString str;
-#define get_saved_output() (Tcl_DStringValue (&stdout_buffer))
+ Tcl_DStringInit (&str);
-static void
-finish_saving_output ()
+ Tcl_DStringAppend (&str, "gdbtk_tcl_fputs", -1);
+ Tcl_DStringAppendElement (&str, (char *)ptr);
+
+ Tcl_Eval (interp, Tcl_DStringValue (&str));
+ Tcl_DStringFree (&str);
+ }
+}
+
+static int
+gdbtk_query (query, args)
+ const char *query;
+ va_list args;
{
- if (!saving_output)
- return;
+ char buf[200], *merge[2];
+ char *command;
+ long val;
- saving_output = 0;
+ vsprintf (buf, query, args);
+ merge[0] = "gdbtk_tcl_query";
+ merge[1] = buf;
+ command = Tcl_Merge (2, merge);
+ Tcl_Eval (interp, command);
+ free (command);
- Tcl_DStringFree (&stdout_buffer);
+ val = atol (interp->result);
+ return val;
}
-\f
-/* This routine redirects the output of fputs_unfiltered so that
- the user can see what's going on in his debugger window. */
+/* VARARGS */
static void
-flush_holdbuf ()
+#ifdef ANSI_PROTOTYPES
+gdbtk_readline_begin (char *format, ...)
+#else
+gdbtk_readline_begin (va_alist)
+ va_dcl
+#endif
{
- char *s, *argv[1];
-
- /* We use Tcl_Merge to quote braces and funny characters as necessary. */
+ va_list args;
+ char buf[200], *merge[2];
+ char *command;
- argv[0] = Tcl_DStringValue (&stdout_buffer);
- s = Tcl_Merge (1, argv);
+#ifdef ANSI_PROTOTYPES
+ va_start (args, format);
+#else
+ char *format;
+ va_start (args);
+ format = va_arg (args, char *);
+#endif
- Tcl_DStringFree (&stdout_buffer);
+ vsprintf (buf, format, args);
+ merge[0] = "gdbtk_tcl_readline_begin";
+ merge[1] = buf;
+ command = Tcl_Merge (2, merge);
+ Tcl_Eval (interp, command);
+ free (command);
+}
- Tcl_VarEval (interp, "gdbtk_tcl_fputs ", s, NULL);
+static char *
+gdbtk_readline (prompt)
+ char *prompt;
+{
+ char *merge[2];
+ char *command;
+ int result;
+
+ merge[0] = "gdbtk_tcl_readline";
+ merge[1] = prompt;
+ command = Tcl_Merge (2, merge);
+ result = Tcl_Eval (interp, command);
+ free (command);
+ if (result == TCL_OK)
+ {
+ return (strdup (interp -> result));
+ }
+ else
+ {
+ gdbtk_fputs (interp -> result, gdb_stdout);
+ gdbtk_fputs ("\n", gdb_stdout);
+ return (NULL);
+ }
+}
- free (s);
+static void
+gdbtk_readline_end ()
+{
+ Tcl_Eval (interp, "gdbtk_tcl_readline_end");
}
+\f
static void
-gdbtk_flush (stream)
- FILE *stream;
+#ifdef ANSI_PROTOTYPES
+dsprintf_append_element (Tcl_DString *dsp, char *format, ...)
+#else
+dsprintf_append_element (va_alist)
+ va_dcl
+#endif
{
- if (stream != gdb_stdout || saving_output)
- return;
+ va_list args;
+ char buf[1024];
- /* Flush output from C to tcl land. */
+#ifdef ANSI_PROTOTYPES
+ va_start (args, format);
+#else
+ Tcl_DString *dsp;
+ char *format;
- flush_holdbuf ();
+ va_start (args);
+ dsp = va_arg (args, Tcl_DString *);
+ format = va_arg (args, char *);
+#endif
- /* Force immediate screen update */
+ vsprintf (buf, format, args);
- Tcl_VarEval (interp, "gdbtk_tcl_flush", NULL);
+ Tcl_DStringAppendElement (dsp, buf);
}
-static void
-gdbtk_fputs (ptr, stream)
- const char *ptr;
- FILE *stream;
+static int
+gdb_path_conv (clientData, interp, argc, argv)
+ ClientData clientData;
+ Tcl_Interp *interp;
+ int argc;
+ char *argv[];
{
- int len;
-
- if (stream != gdb_stdout)
+#ifdef WINNT
+ char pathname[256], *ptr;
+ if (argc != 2)
+ error ("wrong # args");
+ cygwin32_conv_to_full_win32_path (argv[1], pathname);
+ for (ptr = pathname; *ptr; ptr++)
{
- Tcl_VarEval (interp, "gdbtk_tcl_fputs_error ", "{", ptr, "}", NULL);
- return;
+ if (*ptr == '\\')
+ *ptr = '/';
}
+#else
+ char *pathname = argv[1];
+#endif
+ Tcl_DStringAppend (result_ptr, pathname, strlen(pathname));
+ return TCL_OK;
+}
- Tcl_DStringAppend (&stdout_buffer, ptr, -1);
+static int
+gdb_get_breakpoint_list (clientData, interp, argc, argv)
+ ClientData clientData;
+ Tcl_Interp *interp;
+ int argc;
+ char *argv[];
+{
+ struct breakpoint *b;
+ extern struct breakpoint *breakpoint_chain;
- if (saving_output)
- return;
+ if (argc != 1)
+ error ("wrong # args");
- if (Tcl_DStringLength (&stdout_buffer) > 1000)
- flush_holdbuf ();
+ for (b = breakpoint_chain; b; b = b->next)
+ if (b->type == bp_breakpoint)
+ dsprintf_append_element (result_ptr, "%d", b->number);
+
+ return TCL_OK;
}
static int
-gdbtk_query (args)
- va_list args;
+gdb_get_breakpoint_info (clientData, interp, argc, argv)
+ ClientData clientData;
+ Tcl_Interp *interp;
+ int argc;
+ char *argv[];
{
- char *query;
- char buf[200];
- long val;
+ struct symtab_and_line sal;
+ static char *bptypes[] = {"breakpoint", "hardware breakpoint", "until",
+ "finish", "watchpoint", "hardware watchpoint",
+ "read watchpoint", "access watchpoint",
+ "longjmp", "longjmp resume", "step resume",
+ "through sigtramp", "watchpoint scope",
+ "call dummy" };
+ static char *bpdisp[] = {"delete", "delstop", "disable", "donttouch"};
+ struct command_line *cmd;
+ int bpnum;
+ struct breakpoint *b;
+ extern struct breakpoint *breakpoint_chain;
- query = va_arg (args, char *);
+ if (argc != 2)
+ error ("wrong # args");
- vsprintf(buf, query, args);
- Tcl_VarEval (interp, "gdbtk_tcl_query ", "{", buf, "}", NULL);
+ bpnum = atoi (argv[1]);
- val = atol (interp->result);
- return val;
+ for (b = breakpoint_chain; b; b = b->next)
+ if (b->number == bpnum)
+ break;
+
+ if (!b || b->type != bp_breakpoint)
+ error ("Breakpoint #%d does not exist", bpnum);
+
+ sal = find_pc_line (b->address, 0);
+
+ Tcl_DStringAppendElement (result_ptr, symtab_to_filename (sal.symtab));
+ dsprintf_append_element (result_ptr, "%d", sal.line);
+ dsprintf_append_element (result_ptr, "0x%lx", b->address);
+ Tcl_DStringAppendElement (result_ptr, bptypes[b->type]);
+ Tcl_DStringAppendElement (result_ptr, b->enable == enabled ? "1" : "0");
+ Tcl_DStringAppendElement (result_ptr, bpdisp[b->disposition]);
+ dsprintf_append_element (result_ptr, "%d", b->silent);
+ dsprintf_append_element (result_ptr, "%d", b->ignore_count);
+
+ Tcl_DStringStartSublist (result_ptr);
+ for (cmd = b->commands; cmd; cmd = cmd->next)
+ Tcl_DStringAppendElement (result_ptr, cmd->line);
+ Tcl_DStringEndSublist (result_ptr);
+
+ Tcl_DStringAppendElement (result_ptr, b->cond_string);
+
+ dsprintf_append_element (result_ptr, "%d", b->thread);
+ dsprintf_append_element (result_ptr, "%d", b->hit_count);
+
+ return TCL_OK;
}
-\f
+
static void
breakpoint_notify(b, action)
struct breakpoint *b;
const char *action;
{
- struct symbol *sym;
- char bpnum[50], line[50], pc[50];
- struct symtab_and_line sal;
- char *filename;
+ char buf[256];
int v;
+ struct symtab_and_line sal;
if (b->type != bp_breakpoint)
return;
+ /* We ensure that ACTION contains no special Tcl characters, so we
+ can do this. */
sal = find_pc_line (b->address, 0);
+ sprintf (buf, "gdbtk_tcl_breakpoint %s %d 0x%lx %d {%s}", action, b->number,
+ (long)b->address, sal.line, symtab_to_filename (sal.symtab));
- filename = symtab_to_filename (sal.symtab);
-
- sprintf (bpnum, "%d", b->number);
- sprintf (line, "%d", sal.line);
- sprintf (pc, "0x%lx", b->address);
-
- v = Tcl_VarEval (interp,
- "gdbtk_tcl_breakpoint ",
- action,
- " ", bpnum,
- " ", filename ? filename : "{}",
- " ", line,
- " ", pc,
- NULL);
+ v = Tcl_Eval (interp, buf);
if (v != TCL_OK)
{
gdbtk_create_breakpoint(b)
struct breakpoint *b;
{
- breakpoint_notify(b, "create");
+ breakpoint_notify (b, "create");
}
static void
gdbtk_delete_breakpoint(b)
struct breakpoint *b;
{
- breakpoint_notify(b, "delete");
-}
-
-static void
-gdbtk_enable_breakpoint(b)
- struct breakpoint *b;
-{
- breakpoint_notify(b, "enable");
+ breakpoint_notify (b, "delete");
}
static void
-gdbtk_disable_breakpoint(b)
+gdbtk_modify_breakpoint(b)
struct breakpoint *b;
{
- breakpoint_notify(b, "disable");
+ breakpoint_notify (b, "modify");
}
\f
/* This implements the TCL command `gdb_loc', which returns a list consisting
char *argv[];
{
char *filename;
- char buf[100];
struct symtab_and_line sal;
char *funcname;
CORE_ADDR pc;
free (sals.sals);
if (sals.nelts != 1)
- {
- Tcl_SetResult (interp, "Ambiguous line spec", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("Ambiguous line spec");
pc = sal.pc;
}
else
- {
- Tcl_SetResult (interp, "wrong # args", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("wrong # args");
if (sal.symtab)
- Tcl_AppendElement (interp, sal.symtab->filename);
+ Tcl_DStringAppendElement (result_ptr, sal.symtab->filename);
else
- Tcl_AppendElement (interp, "");
+ Tcl_DStringAppendElement (result_ptr, "");
find_pc_partial_function (pc, &funcname, NULL, NULL);
- Tcl_AppendElement (interp, funcname);
+ Tcl_DStringAppendElement (result_ptr, funcname);
filename = symtab_to_filename (sal.symtab);
- Tcl_AppendElement (interp, filename);
+ Tcl_DStringAppendElement (result_ptr, filename);
- sprintf (buf, "%d", sal.line);
- Tcl_AppendElement (interp, buf); /* line number */
+ dsprintf_append_element (result_ptr, "%d", sal.line); /* line number */
- sprintf (buf, "0x%lx", pc);
- Tcl_AppendElement (interp, buf); /* PC */
+ dsprintf_append_element (result_ptr, "0x%s", paddr_nz(pc)); /* PC in current frame */
+
+ dsprintf_append_element (result_ptr, "0x%s", paddr_nz(stop_pc)); /* Real PC */
return TCL_OK;
}
value_ptr val;
if (argc != 2)
- {
- Tcl_SetResult (interp, "wrong # args", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("wrong # args");
expr = parse_expression (argv[1]);
val = evaluate_expression (expr);
- start_saving_output (); /* Start collecting stdout */
-
val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), VALUE_ADDRESS (val),
gdb_stdout, 0, 0, 0, 0);
-#if 0
- value_print (val, gdb_stdout, 0, 0);
-#endif
-
- Tcl_AppendElement (interp, get_saved_output ());
-
- finish_saving_output (); /* Set stdout back to normal */
do_cleanups (old_chain);
struct symtab *symtab;
struct linetable_entry *le;
int nlines;
- char buf[100];
if (argc != 2)
- {
- Tcl_SetResult (interp, "wrong # args", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("wrong # args");
symtab = lookup_symtab (argv[1]);
if (!symtab)
- {
- Tcl_SetResult (interp, "No such file", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("No such file");
/* If there's no linetable, or no entries, then we are done. */
if (!symtab->linetable
|| symtab->linetable->nitems == 0)
{
- Tcl_AppendElement (interp, "");
+ Tcl_DStringAppendElement (result_ptr, "");
return TCL_OK;
}
&& le->pc == (le + 1)->pc)
continue;
- sprintf (buf, "%d", le->line);
- Tcl_AppendElement (interp, buf);
+ dsprintf_append_element (result_ptr, "%d", le->line);
}
return TCL_OK;
map_arg_registers (argc, argv, func, argp)
int argc;
char *argv[];
- int (*func) PARAMS ((int regnum, void *argp));
+ void (*func) PARAMS ((int regnum, void *argp));
void *argp;
{
int regnum;
&& *reg_names[regnum] != '\000')
func (regnum, argp);
else
- {
- Tcl_SetResult (interp, "bad register number", TCL_STATIC);
-
- return TCL_ERROR;
- }
+ error ("bad register number");
}
return TCL_OK;
}
-static int
+static void
get_register_name (regnum, argp)
int regnum;
void *argp; /* Ignored */
{
- Tcl_AppendElement (interp, reg_names[regnum]);
+ Tcl_DStringAppendElement (result_ptr, reg_names[regnum]);
}
/* This implements the TCL command `gdb_regnames', which returns a list of
argc--;
argv++;
- return map_arg_registers (argc, argv, get_register_name, 0);
+ return map_arg_registers (argc, argv, get_register_name, NULL);
}
#ifndef REGISTER_CONVERTIBLE
#define INVALID_FLOAT(x, y) (0 != 0)
#endif
-static int
+static void
get_register (regnum, fp)
+ int regnum;
void *fp;
{
char raw_buffer[MAX_REGISTER_RAW_SIZE];
if (read_relative_register_raw_bytes (regnum, raw_buffer))
{
- Tcl_AppendElement (interp, "Optimized out");
+ Tcl_DStringAppendElement (result_ptr, "Optimized out");
return;
}
- start_saving_output (); /* Start collecting stdout */
-
/* Convert raw data to virtual format if necessary. */
if (REGISTER_CONVERTIBLE (regnum))
else
memcpy (virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE (regnum));
- val_print (REGISTER_VIRTUAL_TYPE (regnum), virtual_buffer, 0,
- gdb_stdout, format, 1, 0, Val_pretty_default);
-
- Tcl_AppendElement (interp, get_saved_output ());
+ if (format == 'r')
+ {
+ int j;
+ printf_filtered ("0x");
+ for (j = 0; j < REGISTER_RAW_SIZE (regnum); j++)
+ {
+ register int idx = TARGET_BYTE_ORDER == BIG_ENDIAN ? j
+ : REGISTER_RAW_SIZE (regnum) - 1 - j;
+ printf_filtered ("%02x", (unsigned char)raw_buffer[idx]);
+ }
+ }
+ else
+ val_print (REGISTER_VIRTUAL_TYPE (regnum), virtual_buffer, 0,
+ gdb_stdout, format, 1, 0, Val_pretty_default);
- finish_saving_output (); /* Set stdout back to normal */
+ Tcl_DStringAppend (result_ptr, " ", -1);
}
static int
int format;
if (argc < 2)
- {
- Tcl_SetResult (interp, "wrong # args", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("wrong # args");
argc--;
argv++;
argc--;
format = **argv++;
- return map_arg_registers (argc, argv, get_register, format);
+ return map_arg_registers (argc, argv, get_register, (void *) format);
}
/* This contains the previous values of the registers, since the last call to
static char old_regs[REGISTER_BYTES];
-static int
+static void
register_changed_p (regnum, argp)
+ int regnum;
void *argp; /* Ignored */
{
char raw_buffer[MAX_REGISTER_RAW_SIZE];
- char buf[100];
if (read_relative_register_raw_bytes (regnum, raw_buffer))
return;
REGISTER_RAW_SIZE (regnum)) == 0)
return;
- /* Found a changed register. Save new value and return it's number. */
+ /* Found a changed register. Save new value and return its number. */
memcpy (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
REGISTER_RAW_SIZE (regnum));
- sprintf (buf, "%d", regnum);
- Tcl_AppendElement (interp, buf);
+ dsprintf_append_element (result_ptr, "%d", regnum);
}
static int
int argc;
char *argv[];
{
- int format;
-
argc--;
argv++;
return map_arg_registers (argc, argv, register_changed_p, NULL);
}
\f
-/* This implements the TCL command `gdb_cmd', which sends it's argument into
+/* This implements the TCL command `gdb_cmd', which sends its argument into
the GDB command scanner. */
static int
char *argv[];
{
if (argc != 2)
- {
- Tcl_SetResult (interp, "wrong # args", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("wrong # args");
+
+ if (running_now)
+ return TCL_OK;
execute_command (argv[1], 1);
bpstat_do_actions (&stop_bpstat);
- /* Drain all buffered command output */
+ return TCL_OK;
+}
- gdb_flush (gdb_stdout);
+/* Client of call_wrapper - this routine performs the actual call to
+ the client function. */
- return TCL_OK;
+struct wrapped_call_args
+{
+ Tcl_Interp *interp;
+ Tcl_CmdProc *func;
+ int argc;
+ char **argv;
+ int val;
+};
+
+static int
+wrapped_call (args)
+ struct wrapped_call_args *args;
+{
+ args->val = (*args->func) (args->func, args->interp, args->argc, args->argv);
+ return 1;
}
/* This routine acts as a top-level for all GDB code called by tcl/Tk. It
int argc;
char *argv[];
{
- int val;
- struct cleanup *saved_cleanup_chain;
- Tcl_CmdProc *func;
- jmp_buf saved_error_return;
+ struct wrapped_call_args wrapped_args;
+ Tcl_DString result, *old_result_ptr;
- func = (Tcl_CmdProc *)clientData;
- memcpy (saved_error_return, error_return, sizeof (jmp_buf));
+ Tcl_DStringInit (&result);
+ old_result_ptr = result_ptr;
+ result_ptr = &result;
- saved_cleanup_chain = save_cleanups ();
+ wrapped_args.func = (Tcl_CmdProc *)clientData;
+ wrapped_args.interp = interp;
+ wrapped_args.argc = argc;
+ wrapped_args.argv = argv;
+ wrapped_args.val = 0;
- if (!setjmp (error_return))
- val = func (clientData, interp, argc, argv);
- else
+ if (!catch_errors (wrapped_call, &wrapped_args, "", RETURN_MASK_ALL))
{
- val = TCL_ERROR; /* Flag an error for TCL */
-
- finish_saving_output (); /* Restore stdout to normal */
-
- dis_asm_read_memory_hook = 0; /* Restore disassembly hook */
+ wrapped_args.val = TCL_ERROR; /* Flag an error for TCL */
gdb_flush (gdb_stderr); /* Flush error output */
gdb_flush (gdb_stdout); /* Sometimes error output comes here as well */
-/* In case of an error, we may need to force the GUI into idle mode because
- gdbtk_call_command may have bombed out while in the command routine. */
+ /* In case of an error, we may need to force the GUI into idle
+ mode because gdbtk_call_command may have bombed out while in
+ the command routine. */
- Tcl_VarEval (interp, "gdbtk_tcl_idle", NULL);
+ running_now = 0;
+ Tcl_Eval (interp, "gdbtk_tcl_idle");
}
- do_cleanups (ALL_CLEANUPS);
-
- restore_cleanups (saved_cleanup_chain);
-
- memcpy (error_return, saved_error_return, sizeof (jmp_buf));
+ Tcl_DStringResult (interp, &result);
+ result_ptr = old_result_ptr;
- return val;
+ return wrapped_args.val;
}
static int
int argc;
char *argv[];
{
- int val;
struct objfile *objfile;
struct partial_symtab *psymtab;
struct symtab *symtab;
ALL_PSYMTABS (objfile, psymtab)
- Tcl_AppendElement (interp, psymtab->filename);
+ Tcl_DStringAppendElement (result_ptr, psymtab->filename);
ALL_SYMTABS (objfile, symtab)
- Tcl_AppendElement (interp, symtab->filename);
+ Tcl_DStringAppendElement (result_ptr, symtab->filename);
return TCL_OK;
}
+static int
+gdb_listfuncs (clientData, interp, argc, argv)
+ ClientData clientData;
+ Tcl_Interp *interp;
+ int argc;
+ char *argv[];
+{
+ struct symtab *symtab;
+ struct blockvector *bv;
+ struct block *b;
+ struct symbol *sym;
+ int i,j;
+
+ if (argc != 2)
+ error ("wrong # args");
+
+ symtab = lookup_symtab (argv[1]);
+
+ if (!symtab)
+ error ("No such file");
+
+ bv = BLOCKVECTOR (symtab);
+ for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
+ {
+ b = BLOCKVECTOR_BLOCK (bv, i);
+ /* Skip the sort if this block is always sorted. */
+ if (!BLOCK_SHOULD_SORT (b))
+ sort_block_syms (b);
+ for (j = 0; j < BLOCK_NSYMS (b); j++)
+ {
+ sym = BLOCK_SYM (b, j);
+ if (SYMBOL_CLASS (sym) == LOC_BLOCK)
+ {
+ Tcl_DStringAppendElement (result_ptr, SYMBOL_NAME(sym));
+ }
+ }
+ }
+ return TCL_OK;
+}
+
static int
gdb_stop (clientData, interp, argc, argv)
ClientData clientData;
int argc;
char *argv[];
{
- target_stop ();
+ if (target_stop)
+ target_stop ();
+ else
+ quit_flag = 1; /* hope something sees this */
return TCL_OK;
}
{
CORE_ADDR pc, low, high;
int mixed_source_and_assembly;
+ static disassemble_info di;
+ static int di_initialized;
- if (argc != 3 && argc != 4)
+ if (! di_initialized)
{
- Tcl_SetResult (interp, "wrong # args", TCL_STATIC);
- return TCL_ERROR;
+ INIT_DISASSEMBLE_INFO_NO_ARCH (di, gdb_stdout,
+ (fprintf_ftype) fprintf_unfiltered);
+ di.flavour = bfd_target_unknown_flavour;
+ di.memory_error_func = dis_asm_memory_error;
+ di.print_address_func = dis_asm_print_address;
+ di_initialized = 1;
}
+ di.mach = tm_print_insn_info.mach;
+ if (TARGET_BYTE_ORDER == BIG_ENDIAN)
+ di.endian = BFD_ENDIAN_BIG;
+ else
+ di.endian = BFD_ENDIAN_LITTLE;
+
+ if (argc != 3 && argc != 4)
+ error ("wrong # args");
+
if (strcmp (argv[1], "source") == 0)
mixed_source_and_assembly = 1;
else if (strcmp (argv[1], "nosource") == 0)
mixed_source_and_assembly = 0;
else
- {
- Tcl_SetResult (interp, "First arg must be 'source' or 'nosource'",
- TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("First arg must be 'source' or 'nosource'");
low = parse_and_eval_address (argv[2]);
if (argc == 3)
{
if (find_pc_partial_function (low, NULL, &low, &high) == 0)
- {
- Tcl_SetResult (interp, "No function contains specified address",
- TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("No function contains specified address");
}
else
high = parse_and_eval_address (argv[3]);
correctly.
Else, we're debugging a remote process, and should disassemble from the
- exec file for speed. However, this is no good if the target modifies it's
+ exec file for speed. However, this is no good if the target modifies its
code (for relocation, or whatever).
*/
if (disassemble_from_exec == -1)
if (strcmp (target_shortname, "child") == 0
- || strcmp (target_shortname, "procfs") == 0)
+ || strcmp (target_shortname, "procfs") == 0
+ || strcmp (target_shortname, "vxprocess") == 0)
disassemble_from_exec = 0; /* It's a child process, read inferior mem */
else
disassemble_from_exec = 1; /* It's remote, read the exec file */
if (disassemble_from_exec)
- dis_asm_read_memory_hook = gdbtk_dis_asm_read_memory;
+ di.read_memory_func = gdbtk_dis_asm_read_memory;
+ else
+ di.read_memory_func = dis_asm_read_memory;
/* If just doing straight assembly, all we need to do is disassemble
everything between low and high. If doing mixed source/assembly, we've
struct symtab *symtab;
struct linetable_entry *le;
int nlines;
+ int newlines;
struct my_line_entry *mle;
struct symtab_and_line sal;
int i;
int out_of_order;
- int current_line;
+ int next_line;
symtab = find_pc_symtab (low); /* Assume symtab is valid for whole PC range */
out_of_order = 0;
- for (i = 0; i < nlines - 1; i++)
+/* Copy linetable entries for this function into our data structure, creating
+ end_pc's and setting out_of_order as appropriate. */
+
+/* First, skip all the preceding functions. */
+
+ for (i = 0; i < nlines - 1 && le[i].pc < low; i++) ;
+
+/* Now, copy all entries before the end of this function. */
+
+ newlines = 0;
+ for (; i < nlines - 1 && le[i].pc < high; i++)
{
- mle[i].line = le[i].line;
+ if (le[i].line == le[i + 1].line
+ && le[i].pc == le[i + 1].pc)
+ continue; /* Ignore duplicates */
+
+ mle[newlines].line = le[i].line;
if (le[i].line > le[i + 1].line)
out_of_order = 1;
- mle[i].start_pc = le[i].pc;
- mle[i].end_pc = le[i + 1].pc;
+ mle[newlines].start_pc = le[i].pc;
+ mle[newlines].end_pc = le[i + 1].pc;
+ newlines++;
}
- mle[i].line = le[i].line;
- mle[i].start_pc = le[i].pc;
- sal = find_pc_line (le[i].pc, 0);
- mle[i].end_pc = sal.end;
+/* If we're on the last line, and it's part of the function, then we need to
+ get the end pc in a special way. */
+
+ if (i == nlines - 1
+ && le[i].pc < high)
+ {
+ mle[newlines].line = le[i].line;
+ mle[newlines].start_pc = le[i].pc;
+ sal = find_pc_line (le[i].pc, 0);
+ mle[newlines].end_pc = sal.end;
+ newlines++;
+ }
/* Now, sort mle by line #s (and, then by addresses within lines). */
if (out_of_order)
- qsort (mle, nlines, sizeof (struct my_line_entry), compare_lines);
-
-/* Scan forward until we find the start of the function. */
-
- for (i = 0; i < nlines; i++)
- if (mle[i].start_pc >= low)
- break;
+ qsort (mle, newlines, sizeof (struct my_line_entry), compare_lines);
/* Now, for each line entry, emit the specified lines (unless they have been
emitted before), followed by the assembly code for that line. */
- current_line = 0; /* Force out first line */
- for (;i < nlines && mle[i].start_pc < high; i++)
+ next_line = 0; /* Force out first line */
+ for (i = 0; i < newlines; i++)
{
- if (mle[i].line > current_line)
+/* Print out everything from next_line to the current line. */
+
+ if (mle[i].line >= next_line)
{
- if (i == nlines - 1)
- print_source_lines (symtab, mle[i].line, INT_MAX, 0);
+ if (next_line != 0)
+ print_source_lines (symtab, next_line, mle[i].line + 1, 0);
else
- print_source_lines (symtab, mle[i].line, mle[i + 1].line, 0);
- current_line = mle[i].line;
+ print_source_lines (symtab, mle[i].line, mle[i].line + 1, 0);
+
+ next_line = mle[i].line + 1;
}
+
for (pc = mle[i].start_pc; pc < mle[i].end_pc; )
{
QUIT;
fputs_unfiltered (" ", gdb_stdout);
print_address (pc, gdb_stdout);
fputs_unfiltered (":\t ", gdb_stdout);
- pc += print_insn (pc, gdb_stdout);
+ pc += (*tm_print_insn) (pc, &di);
fputs_unfiltered ("\n", gdb_stdout);
}
}
fputs_unfiltered (" ", gdb_stdout);
print_address (pc, gdb_stdout);
fputs_unfiltered (":\t ", gdb_stdout);
- pc += print_insn (pc, gdb_stdout);
+ pc += (*tm_print_insn) (pc, &di);
fputs_unfiltered ("\n", gdb_stdout);
}
}
- dis_asm_read_memory_hook = 0;
-
gdb_flush (gdb_stdout);
return TCL_OK;
char *result;
struct cleanup *old_chain;
+ /* Catch case of no argument, since this will make the tcl interpreter dump core. */
+ if (cmd == NULL)
+ error_no_arg ("tcl command to interpret");
+
retval = Tcl_Eval (interp, cmd);
result = strdup (interp->result);
cleanup_init (ignored)
int ignored;
{
- if (mainWindow != NULL)
- Tk_DestroyWindow (mainWindow);
- mainWindow = NULL;
-
if (interp != NULL)
Tcl_DeleteInterp (interp);
interp = NULL;
{
/* Process pending events */
- while (Tk_DoOneEvent (TK_DONT_WAIT|TK_ALL_EVENTS) != 0);
+ while (Tcl_DoOneEvent (TCL_DONT_WAIT|TCL_ALL_EVENTS) != 0);
}
static int
action.sa_handler = x_event;
action.sa_mask = nullsigmask;
action.sa_flags = SA_RESTART;
+#ifndef WINNT
sigaction(SIGIO, &action, NULL);
+#endif
pid = target_wait (pid, ourstatus);
action.sa_handler = SIG_IGN;
- sigaction(SIGIO, &action, NULL);
+#ifndef WINNT
+ sigaction(SIGIO, &action, NULL);
+#endif
return pid;
}
char *arg;
int from_tty;
{
+ running_now = 0;
if (cmdblk->class == class_run)
{
- Tcl_VarEval (interp, "gdbtk_tcl_busy", NULL);
+ running_now = 1;
+ Tcl_Eval (interp, "gdbtk_tcl_busy");
(*cmdblk->function.cfunc)(arg, from_tty);
- Tcl_VarEval (interp, "gdbtk_tcl_idle", NULL);
+ running_now = 0;
+ Tcl_Eval (interp, "gdbtk_tcl_idle");
}
else
(*cmdblk->function.cfunc)(arg, from_tty);
}
+/* This function is called instead of gdb's internal command loop. This is the
+ last chance to do anything before entering the main Tk event loop. */
+
static void
-gdbtk_init ()
+tk_command_loop ()
+{
+ extern GDB_FILE *instream;
+
+ /* We no longer want to use stdin as the command input stream */
+ instream = NULL;
+ Tcl_Eval (interp, "gdbtk_tcl_preloop");
+ Tk_MainLoop ();
+}
+
+/* gdbtk_init installs this function as a final cleanup. */
+
+static void
+gdbtk_cleanup (dummy)
+ PTR dummy;
+{
+ Tcl_Finalize ();
+}
+
+/* Initialize gdbtk. */
+
+static void
+gdbtk_init ( argv0 )
+ char *argv0;
{
struct cleanup *old_chain;
- char *gdbtk_filename;
- int i;
+ char *lib, *gdbtk_lib, *gdbtk_lib_tmp, *gdbtk_file;
+ int i, found_main;
struct sigaction action;
static sigset_t nullsigmask = {0};
- extern struct cmd_list_element *setlist;
- extern struct cmd_list_element *showlist;
+#ifdef IDE
+ struct ide_event_handle *h;
+ const char *errmsg;
+ char *libexecdir;
+#endif
+
+ /* If there is no DISPLAY environment variable, Tk_Init below will fail,
+ causing gdb to abort. If instead we simply return here, gdb will
+ gracefully degrade to using the command line interface. */
+
+#ifndef WINNT
+ if (getenv ("DISPLAY") == NULL)
+ return;
+#endif
old_chain = make_cleanup (cleanup_init, 0);
/* First init tcl and tk. */
-
+ Tcl_FindExecutable (argv0);
interp = Tcl_CreateInterp ();
if (!interp)
error ("Tcl_CreateInterp failed");
- Tcl_DStringInit (&stdout_buffer); /* Setup stdout buffer */
+ if (Tcl_Init(interp) != TCL_OK)
+ error ("Tcl_Init failed: %s", interp->result);
- mainWindow = Tk_CreateMainWindow (interp, NULL, "gdb", "Gdb");
+ make_final_cleanup (gdbtk_cleanup, NULL);
- if (!mainWindow)
- return; /* DISPLAY probably not set */
+#ifdef IDE
+ /* Initialize the Paths variable. */
+ if (ide_initialize_paths (interp, "gdbtcl") != TCL_OK)
+ error ("ide_initialize_paths failed: %s", interp->result);
- if (Tcl_Init(interp) != TCL_OK)
- error ("Tcl_Init failed: %s", interp->result);
+ /* Find the directory where we expect to find idemanager. We ignore
+ errors since it doesn't really matter if this fails. */
+ libexecdir = Tcl_GetVar2 (interp, "Paths", "libexecdir", TCL_GLOBAL_ONLY);
+
+ IluTk_Init ();
+
+ h = ide_event_init_from_environment (&errmsg, libexecdir);
+ if (h == NULL)
+ {
+ Tcl_AppendResult (interp, "can't initialize event system: ", errmsg,
+ (char *) NULL);
+ fprintf(stderr, "WARNING: ide_event_init_client failed: %s\n", interp->result);
+
+ Tcl_SetVar (interp, "GDBTK_IDE", "0", 0);
+ }
+ else
+ {
+ if (ide_create_tclevent_command (interp, h) != TCL_OK)
+ error ("ide_create_tclevent_command failed: %s", interp->result);
+ if (ide_create_edit_command (interp, h) != TCL_OK)
+ error ("ide_create_edit_command failed: %s", interp->result);
+
+ if (ide_create_property_command (interp, h) != TCL_OK)
+ error ("ide_create_property_command failed: %s", interp->result);
+
+ if (ide_create_window_register_command (interp, h) != TCL_OK)
+ error ("ide_create_window_register_command failed: %s",
+ interp->result);
+
+ if (ide_create_window_command (interp, h) != TCL_OK)
+ error ("ide_create_window_command failed: %s", interp->result);
+
+ /*
+ if (ide_initialize (interp, "gdb") != TCL_OK)
+ error ("ide_initialize failed: %s", interp->result);
+ */
+
+ Tcl_SetVar (interp, "GDBTK_IDE", "1", 0);
+ }
+#else
+ Tcl_SetVar (interp, "GDBTK_IDE", "0", 0);
+#endif /* IDE */
+
+ /* We don't want to open the X connection until we've done all the
+ IDE initialization. Otherwise, goofy looking unfinished windows
+ pop up when ILU drops into the TCL event loop. */
if (Tk_Init(interp) != TCL_OK)
error ("Tk_Init failed: %s", interp->result);
+ if (Itcl_Init(interp) == TCL_ERROR)
+ error ("Itcl_Init failed: %s", interp->result);
+
+ if (Tix_Init(interp) != TCL_OK)
+ error ("Tix_Init failed: %s", interp->result);
+
Tcl_CreateCommand (interp, "gdb_cmd", call_wrapper, gdb_cmd, NULL);
Tcl_CreateCommand (interp, "gdb_loc", call_wrapper, gdb_loc, NULL);
+ Tcl_CreateCommand (interp, "gdb_path_conv", call_wrapper, gdb_path_conv, NULL);
Tcl_CreateCommand (interp, "gdb_sourcelines", call_wrapper, gdb_sourcelines,
NULL);
Tcl_CreateCommand (interp, "gdb_listfiles", call_wrapper, gdb_listfiles,
NULL);
+ Tcl_CreateCommand (interp, "gdb_listfuncs", call_wrapper, gdb_listfuncs,
+ NULL);
Tcl_CreateCommand (interp, "gdb_stop", call_wrapper, gdb_stop, NULL);
Tcl_CreateCommand (interp, "gdb_regnames", call_wrapper, gdb_regnames, NULL);
Tcl_CreateCommand (interp, "gdb_fetch_registers", call_wrapper,
Tcl_CreateCommand (interp, "gdb_disassemble", call_wrapper,
gdb_disassemble, NULL);
Tcl_CreateCommand (interp, "gdb_eval", call_wrapper, gdb_eval, NULL);
-
- command_loop_hook = Tk_MainLoop;
- fputs_unfiltered_hook = gdbtk_fputs;
- print_frame_info_listing_hook = null_routine;
+ Tcl_CreateCommand (interp, "gdb_get_breakpoint_list", call_wrapper,
+ gdb_get_breakpoint_list, NULL);
+ Tcl_CreateCommand (interp, "gdb_get_breakpoint_info", call_wrapper,
+ gdb_get_breakpoint_info, NULL);
+
+ command_loop_hook = tk_command_loop;
+ print_frame_info_listing_hook =
+ (void (*) PARAMS ((struct symtab *, int, int, int))) null_routine;
query_hook = gdbtk_query;
flush_hook = gdbtk_flush;
create_breakpoint_hook = gdbtk_create_breakpoint;
delete_breakpoint_hook = gdbtk_delete_breakpoint;
- enable_breakpoint_hook = gdbtk_enable_breakpoint;
- disable_breakpoint_hook = gdbtk_disable_breakpoint;
+ modify_breakpoint_hook = gdbtk_modify_breakpoint;
interactive_hook = gdbtk_interactive;
target_wait_hook = gdbtk_wait;
call_command_hook = gdbtk_call_command;
+ readline_begin_hook = gdbtk_readline_begin;
+ readline_hook = gdbtk_readline;
+ readline_end_hook = gdbtk_readline_end;
/* Get the file descriptor for the X server */
- x_fd = ConnectionNumber (Tk_Display (mainWindow));
+ x_fd = ConnectionNumber (Tk_Display (Tk_MainWindow (interp)));
/* Setup for I/O interrupts */
action.sa_mask = nullsigmask;
action.sa_flags = 0;
action.sa_handler = SIG_IGN;
+#ifndef WINNT
sigaction(SIGIO, &action, NULL);
+#endif
#ifdef FIOASYNC
i = 1;
if (ioctl (x_fd, FIOASYNC, &i))
perror_with_name ("gdbtk_init: ioctl FIOASYNC failed");
+#ifdef SIOCSPGRP
i = getpid();
if (ioctl (x_fd, SIOCSPGRP, &i))
perror_with_name ("gdbtk_init: ioctl SIOCSPGRP failed");
+
+#else
+#ifdef F_SETOWN
+ i = getpid();
+ if (fcntl (x_fd, F_SETOWN, i))
+ perror_with_name ("gdbtk_init: fcntl F_SETOWN failed");
+#endif /* F_SETOWN */
+#endif /* !SIOCSPGRP */
#else
+#ifndef WINNT
if (ioctl (x_fd, I_SETSIG, S_INPUT|S_RDNORM) < 0)
perror_with_name ("gdbtk_init: ioctl I_SETSIG failed");
+#endif
+
#endif /* ifndef FIOASYNC */
add_com ("tk", class_obscure, tk_command,
"Send a command directly into tk.");
-#if 0
- add_show_from_set (add_set_cmd ("disassemble-from-exec", class_support,
- var_boolean, (char *)&disassemble_from_exec,
- "Set ", &setlist),
- &showlist);
-#endif
-
Tcl_LinkVar (interp, "disassemble-from-exec", (char *)&disassemble_from_exec,
TCL_LINK_INT);
- /* Load up gdbtk.tcl after all the environment stuff has been setup. */
+ /* find the gdb tcl library and source main.tcl */
- gdbtk_filename = getenv ("GDBTK_FILENAME");
- if (!gdbtk_filename)
- if (access ("gdbtk.tcl", R_OK) == 0)
- gdbtk_filename = "gdbtk.tcl";
+ gdbtk_lib = getenv ("GDBTK_LIBRARY");
+ if (!gdbtk_lib)
+ if (access ("gdbtcl/main.tcl", R_OK) == 0)
+ gdbtk_lib = "gdbtcl";
else
- gdbtk_filename = GDBTK_FILENAME;
+ gdbtk_lib = GDBTK_LIBRARY;
+
+ gdbtk_lib_tmp = xstrdup (gdbtk_lib);
+
+ found_main = 0;
+ /* see if GDBTK_LIBRARY is a path list */
+ lib = strtok (gdbtk_lib_tmp, GDBTK_PATH_SEP);
+ do
+ {
+ if (Tcl_VarEval (interp, "lappend auto_path ", lib, NULL) != TCL_OK)
+ {
+ fputs_unfiltered (Tcl_GetVar (interp, "errorInfo", 0), gdb_stderr);
+ error ("");
+ }
+ if (!found_main)
+ {
+ gdbtk_file = concat (lib, "/main.tcl", (char *) NULL);
+ if (access (gdbtk_file, R_OK) == 0)
+ {
+ found_main++;
+ Tcl_SetVar (interp, "GDBTK_LIBRARY", lib, 0);
+ }
+ }
+ }
+ while ((lib = strtok (NULL, ":")) != NULL);
+
+ free (gdbtk_lib_tmp);
+
+#ifdef IDE
+ if (!found_main)
+ {
+ /* Try finding it with the auto path. */
+
+ static const char script[] ="\
+proc gdbtk_find_main {} {\n\
+ global auto_path GDBTK_LIBRARY\n\
+ foreach dir $auto_path {\n\
+ set f [file join $dir main.tcl]\n\
+ if {[file exists $f]} then {\n\
+ set GDBTK_LIBRARY $dir\n\
+ return $f\n\
+ }\n\
+ }\n\
+ return ""\n\
+}\n\
+gdbtk_find_main";
+
+ if (Tcl_GlobalEval (interp, (char *) script) != TCL_OK)
+ {
+ fputs_unfiltered (Tcl_GetVar (interp, "errorInfo", 0), gdb_stderr);
+ error ("");
+ }
+
+ if (interp->result[0] != '\0')
+ {
+ gdbtk_file = xstrdup (interp->result);
+ found_main++;
+ }
+ }
+#endif
+
+ if (!found_main)
+ {
+ fputs_unfiltered_hook = NULL; /* Force errors to stdout/stderr */
+ if (getenv("GDBTK_LIBRARY"))
+ {
+ fprintf_unfiltered (stderr, "Unable to find main.tcl in %s\n",getenv("GDBTK_LIBRARY"));
+ fprintf_unfiltered (stderr,
+ "Please set GDBTK_LIBRARY to a path that includes the GDB tcl files.\n");
+ }
+ else
+ {
+ fprintf_unfiltered (stderr, "Unable to find main.tcl in %s\n", GDBTK_LIBRARY);
+ fprintf_unfiltered (stderr, "You might want to set GDBTK_LIBRARY\n");
+ }
+ error("");
+ }
+
+/* Defer setup of fputs_unfiltered_hook to near the end so that error messages
+ prior to this point go to stdout/stderr. */
+
+ fputs_unfiltered_hook = gdbtk_fputs;
+
+ if (Tcl_EvalFile (interp, gdbtk_file) != TCL_OK)
+ {
+ fputs_unfiltered_hook = NULL; /* Force errors to stdout/stderr */
+
+ fprintf_unfiltered (stderr, "%s:%d: %s\n", gdbtk_file,
+ interp->errorLine, interp->result);
+
+ fputs_unfiltered ("Stack trace:\n", gdb_stderr);
+ fputs_unfiltered (Tcl_GetVar (interp, "errorInfo", 0), gdb_stderr);
+ error ("");
+ }
- if (Tcl_EvalFile (interp, gdbtk_filename) != TCL_OK)
- error ("Failure reading %s: %s", gdbtk_filename, interp->result);
+ free (gdbtk_file);
discard_cleanups (old_chain);
}
-/* Come here during initialze_all_files () */
+/* Come here during initialize_all_files () */
void
_initialize_gdbtk ()
projects / deliverable / binutils-gdb.git / blobdiff