-/* Tcl/Tk interface routines.
- Copyright 1994, 1995 Free Software Foundation, Inc.
+/* Startup code for gdbtk.
+ Copyright 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
Written by Stu Grossman <grossman@cygnus.com> of Cygnus Support.
#include "symfile.h"
#include "objfiles.h"
#include "target.h"
+#include "gdbcore.h"
+#include "tracepoint.h"
+#include "demangle.h"
+
+#ifdef _WIN32
+#include <winuser.h>
+#endif
+
+#include <sys/stat.h>
+
#include <tcl.h>
#include <tk.h>
+#include <itcl.h>
+#include <tix.h>
+#include "guitcl.h"
+#include "gdbtk.h"
+
+#ifdef IDE
+/* start-sanitize-ide */
+#include "event.h"
+#include "idetcl.h"
+#include "ilutk.h"
+/* end-sanitize-ide */
+#endif
+
#ifdef ANSI_PROTOTYPES
#include <stdarg.h>
#else
#include <stdio.h>
#include "gdbcmd.h"
-#ifndef FIOASYNC
-#include <sys/stropts.h>
+#include "annotate.h"
+#include <sys/time.h>
+
+#ifdef __CYGWIN__
+#include <sys/cygwin.h> /* for cygwin32_attach_handle_to_fd */
#endif
-/* Handle for TCL interpreter */
-static Tcl_Interp *interp = NULL;
+/* For Cygwin, we use a timer to periodically check for Windows
+ messages. FIXME: It would be better to not poll, but to instead
+ rewrite the target_wait routines to serve as input sources.
+ Unfortunately, that will be a lot of work. */
+static sigset_t nullsigmask;
+static struct sigaction act1, act2;
+static struct itimerval it_on, it_off;
+
+extern int Tktable_Init PARAMS ((Tcl_Interp *interp));
+
+static void gdbtk_init PARAMS ((char *));
+void gdbtk_interactive PARAMS ((void));
+static void cleanup_init PARAMS ((int));
+static void tk_command PARAMS ((char *, int));
+
+void gdbtk_add_hooks PARAMS ((void));
+int gdbtk_test PARAMS ((char *));
+
+/*
+ * gdbtk_fputs is defined in the gdbtk_hooks.c, but we need it here
+ * because we delay adding this hook till all the setup is done. That
+ * way errors will go to stdout.
+ */
+
+extern void gdbtk_fputs PARAMS ((const char *, GDB_FILE *));
-/* Handle for TK main window */
-static Tk_Window mainWindow = NULL;
+/* Handle for TCL interpreter */
+Tcl_Interp *gdbtk_interp = NULL;
-static int x_fd; /* X network socket */
+static int gdbtk_timer_going = 0;
-/* This variable determines where memory used for disassembly is read from.
+/* linked variable used to tell tcl what the current thread is */
+int gdb_context = 0;
- 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.
+/* This variable is true when the inferior is running. See note in
+ * gdbtk.h for details.
*/
+int running_now;
-static int disassemble_from_exec = -1;
+/* This variable holds the name of a Tcl file which should be sourced by the
+ interpreter when it goes idle at startup. Used with the testsuite. */
+static char *gdbtk_source_filename = NULL;
+\f
+#ifndef _WIN32
-/* Supply malloc calls for tcl/tk. */
+/* 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_Malloc (size)
+Tcl_Alloc (size)
unsigned int size;
{
return xmalloc (size);
free (ptr);
}
-static void
-null_routine(arg)
- int arg;
-{
-}
-
-/* The following routines deal with stdout/stderr data, which is created by
- {f}printf_{un}filtered and friends. gdbtk_fputs and gdbtk_flush are the
- lowest level of these routines and capture all output from the rest of GDB.
- Normally they present their data to tcl via callbacks to the following tcl
- routines: gdbtk_tcl_fputs, gdbtk_tcl_fputs_error, and gdbtk_flush. These
- in turn call tk routines to update the display.
+#endif /* ! _WIN32 */
- Under some circumstances, you may want to collect the output so that it can
- be returned as the value of a tcl procedure. This can be done by
- surrounding the output routines with calls to start_saving_output and
- finish_saving_output. The saved data can then be retrieved with
- get_saved_output (but this must be done before the call to
- finish_saving_output). */
+#ifdef _WIN32
-/* Dynamic string header for stdout. */
+/* On Windows, if we hold a file open, other programs can't write to
+ * it. In particular, we don't want to hold the executable open,
+ * because it will mean that people have to get out of the debugging
+ * session in order to remake their program. So we close it, although
+ * this will cost us if and when we need to reopen it.
+ */
-static Tcl_DString *result_ptr;
-\f
-static void
-gdbtk_flush (stream)
- FILE *stream;
+void
+close_bfds ()
{
-#if 0
- /* Force immediate screen update */
+ struct objfile *o;
- Tcl_VarEval (interp, "gdbtk_tcl_flush", NULL);
-#endif
-}
-
-static void
-gdbtk_fputs (ptr, stream)
- const char *ptr;
- FILE *stream;
-{
- if (result_ptr)
- Tcl_DStringAppend (result_ptr, (char *)ptr, -1);
- else
+ ALL_OBJFILES (o)
{
- Tcl_DString str;
-
- Tcl_DStringInit (&str);
-
- Tcl_DStringAppend (&str, "gdbtk_tcl_fputs", -1);
- Tcl_DStringAppendElement (&str, (char *)ptr);
-
- Tcl_Eval (interp, Tcl_DStringValue (&str));
- Tcl_DStringFree (&str);
+ if (o->obfd != NULL)
+ bfd_cache_close (o->obfd);
}
-}
-static int
-gdbtk_query (query, args)
- char *query;
- va_list args;
-{
- char buf[200];
- long val;
+ if (exec_bfd != NULL)
+ bfd_cache_close (exec_bfd);
+}
- vsprintf (buf, query, args);
- Tcl_VarEval (interp, "gdbtk_tcl_query ", "{", buf, "}", NULL);
+#endif /* _WIN32 */
- val = atol (interp->result);
- return val;
-}
\f
-static void
+/* TclDebug (const char *fmt, ...) works just like printf() but
+ * sends the output to the GDB TK debug window.
+ * Not for normal use; just a convenient tool for debugging
+ */
+
+void
#ifdef ANSI_PROTOTYPES
-dsprintf_append_element (Tcl_DString *dsp, char *format, ...)
+TclDebug (const char *fmt, ...)
#else
-dsprintf_append_element (va_alist)
+TclDebug (va_alist)
va_dcl
#endif
{
va_list args;
- char buf[1024];
+ char buf[512], *v[2], *merge;
#ifdef ANSI_PROTOTYPES
- va_start (args, format);
+ va_start (args, fmt);
#else
- Tcl_DString *dsp;
- char *format;
-
+ char *fmt;
va_start (args);
- dsp = va_arg (args, Tcl_DString *);
- format = va_arg (args, char *);
+ fmt = va_arg (args, char *);
#endif
- vsprintf (buf, format, args);
-
- Tcl_DStringAppendElement (dsp, buf);
-}
-
-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 (argc != 1)
- error ("wrong # args");
+ v[0] = "debug";
+ v[1] = buf;
- for (b = breakpoint_chain; b; b = b->next)
- if (b->type == bp_breakpoint)
- dsprintf_append_element (result_ptr, "%d", b->number);
+ vsprintf (buf, fmt, args);
+ va_end (args);
- return TCL_OK;
-}
-
-static int
-gdb_get_breakpoint_info (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
-{
- 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", "disable", "donttouch"};
- struct command_line *cmd;
- int bpnum;
- struct breakpoint *b;
- extern struct breakpoint *breakpoint_chain;
-
- if (argc != 2)
- error ("wrong # args");
-
- bpnum = atoi (argv[1]);
-
- 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;
+ merge = Tcl_Merge (2, v);
+ Tcl_Eval (gdbtk_interp, merge);
+ Tcl_Free (merge);
}
+\f
+/*
+ * The rest of this file contains the start-up, and event handling code for gdbtk.
+ */
+
+/*
+ * This cleanup function is added to the cleanup list that surrounds the Tk
+ * main in gdbtk_init. It deletes the Tcl interpreter.
+ */
+
static void
-breakpoint_notify(b, action)
- struct breakpoint *b;
- const char *action;
+cleanup_init (ignored)
+ int ignored;
{
- char buf[100];
- int v;
-
- if (b->type != bp_breakpoint)
- return;
-
- sprintf (buf, "gdbtk_tcl_breakpoint %s %d", action, b->number);
-
- v = Tcl_Eval (interp, buf);
-
- if (v != TCL_OK)
- {
- gdbtk_fputs (interp->result, gdb_stdout);
- gdbtk_fputs ("\n", gdb_stdout);
- }
+ if (gdbtk_interp != NULL)
+ Tcl_DeleteInterp (gdbtk_interp);
+ gdbtk_interp = NULL;
}
-static void
-gdbtk_create_breakpoint(b)
- struct breakpoint *b;
-{
- breakpoint_notify (b, "create");
-}
+/* Come here during long calculations to check for GUI events. Usually invoked
+ via the QUIT macro. */
-static void
-gdbtk_delete_breakpoint(b)
- struct breakpoint *b;
+void
+gdbtk_interactive ()
{
- breakpoint_notify (b, "delete");
+ /* Tk_DoOneEvent (TK_DONT_WAIT|TK_IDLE_EVENTS); */
}
-static void
-gdbtk_modify_breakpoint(b)
- struct breakpoint *b;
-{
- breakpoint_notify (b, "modify");
-}
-\f
-/* This implements the TCL command `gdb_loc', which returns a list consisting
- of the source and line number associated with the current pc. */
-
-static int
-gdb_loc (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
-{
- char *filename;
- struct symtab_and_line sal;
- char *funcname;
- CORE_ADDR pc;
- if (argc == 1)
+void
+gdbtk_start_timer ()
+{
+ static int first = 1;
+ /*TclDebug ("Starting timer....");*/
+ if (first)
{
- pc = selected_frame ? selected_frame->pc : stop_pc;
- sal = find_pc_line (pc, 0);
+ /* first time called, set up all the structs */
+ first = 0;
+ sigemptyset (&nullsigmask);
+
+ act1.sa_handler = x_event;
+ act1.sa_mask = nullsigmask;
+ act1.sa_flags = 0;
+
+ act2.sa_handler = SIG_IGN;
+ act2.sa_mask = nullsigmask;
+ act2.sa_flags = 0;
+
+ it_on.it_interval.tv_sec = 0;
+ it_on.it_interval.tv_usec = 250000; /* .25 sec */
+ it_on.it_value.tv_sec = 0;
+ it_on.it_value.tv_usec = 250000;
+
+ it_off.it_interval.tv_sec = 0;
+ it_off.it_interval.tv_usec = 0;
+ it_off.it_value.tv_sec = 0;
+ it_off.it_value.tv_usec = 0;
}
- else if (argc == 2)
+
+ if (!gdbtk_timer_going)
{
- struct symtabs_and_lines sals;
- int nelts;
-
- sals = decode_line_spec (argv[1], 1);
-
- nelts = sals.nelts;
- sal = sals.sals[0];
- free (sals.sals);
-
- if (sals.nelts != 1)
- error ("Ambiguous line spec");
-
- pc = sal.pc;
+ sigaction (SIGALRM, &act1, NULL);
+ setitimer (ITIMER_REAL, &it_on, NULL);
+ gdbtk_timer_going = 1;
}
- else
- error ("wrong # args");
-
- if (sal.symtab)
- Tcl_DStringAppendElement (result_ptr, sal.symtab->filename);
- else
- Tcl_DStringAppendElement (result_ptr, "");
-
- find_pc_partial_function (pc, &funcname, NULL, NULL);
- Tcl_DStringAppendElement (result_ptr, funcname);
-
- filename = symtab_to_filename (sal.symtab);
- Tcl_DStringAppendElement (result_ptr, filename);
-
- dsprintf_append_element (result_ptr, "%d", sal.line); /* line number */
-
- dsprintf_append_element (result_ptr, "0x%lx", pc); /* PC */
-
- return TCL_OK;
}
-\f
-/* This implements the TCL command `gdb_eval'. */
-
-static int
-gdb_eval (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
-{
- struct expression *expr;
- struct cleanup *old_chain;
- value_ptr val;
-
- if (argc != 2)
- error ("wrong # args");
-
- expr = parse_expression (argv[1]);
- old_chain = make_cleanup (free_current_contents, &expr);
-
- val = evaluate_expression (expr);
-
- val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), VALUE_ADDRESS (val),
- gdb_stdout, 0, 0, 0, 0);
-
- do_cleanups (old_chain);
-
- return TCL_OK;
-}
-\f
-/* This implements the TCL command `gdb_sourcelines', which returns a list of
- all of the lines containing executable code for the specified source file
- (ie: lines where you can put breakpoints). */
-
-static int
-gdb_sourcelines (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
+void
+gdbtk_stop_timer ()
{
- struct symtab *symtab;
- struct linetable_entry *le;
- int nlines;
-
- if (argc != 2)
- error ("wrong # args");
-
- symtab = lookup_symtab (argv[1]);
-
- if (!symtab)
- error ("No such file");
-
- /* If there's no linetable, or no entries, then we are done. */
-
- if (!symtab->linetable
- || symtab->linetable->nitems == 0)
- {
- Tcl_DStringAppendElement (result_ptr, "");
- return TCL_OK;
- }
-
- le = symtab->linetable->item;
- nlines = symtab->linetable->nitems;
-
- for (;nlines > 0; nlines--, le++)
+ if (gdbtk_timer_going)
{
- /* If the pc of this line is the same as the pc of the next line, then
- just skip it. */
- if (nlines > 1
- && le->pc == (le + 1)->pc)
- continue;
-
- dsprintf_append_element (result_ptr, "%d", le->line);
+ gdbtk_timer_going = 0;
+ /*TclDebug ("Stopping timer.");*/
+ setitimer (ITIMER_REAL, &it_off, NULL);
+ sigaction (SIGALRM, &act2, NULL);
}
-
- return TCL_OK;
}
-\f
-static int
-map_arg_registers (argc, argv, func, argp)
- int argc;
- char *argv[];
- void (*func) PARAMS ((int regnum, void *argp));
- void *argp;
-{
- int regnum;
- /* Note that the test for a valid register must include checking the
- reg_names array because NUM_REGS may be allocated for the union of the
- register sets within a family of related processors. In this case, the
- trailing entries of reg_names will change depending upon the particular
- processor being debugged. */
-
- if (argc == 0) /* No args, just do all the regs */
- {
- for (regnum = 0;
- regnum < NUM_REGS
- && reg_names[regnum] != NULL
- && *reg_names[regnum] != '\000';
- regnum++)
- func (regnum, argp);
-
- return TCL_OK;
- }
-
- /* Else, list of register #s, just do listed regs */
- for (; argc > 0; argc--, argv++)
- {
- regnum = atoi (*argv);
-
- if (regnum >= 0
- && regnum < NUM_REGS
- && reg_names[regnum] != NULL
- && *reg_names[regnum] != '\000')
- func (regnum, argp);
- else
- error ("bad register number");
- }
-
- return TCL_OK;
-}
+/* gdbtk_init installs this function as a final cleanup. */
static void
-get_register_name (regnum, argp)
- int regnum;
- void *argp; /* Ignored */
-{
- Tcl_DStringAppendElement (result_ptr, reg_names[regnum]);
-}
-
-/* This implements the TCL command `gdb_regnames', which returns a list of
- all of the register names. */
-
-static int
-gdb_regnames (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
-{
- argc--;
- argv++;
-
- return map_arg_registers (argc, argv, get_register_name, 0);
-}
-
-#ifndef REGISTER_CONVERTIBLE
-#define REGISTER_CONVERTIBLE(x) (0 != 0)
+gdbtk_cleanup (dummy)
+ PTR dummy;
+{
+ Tcl_Eval (gdbtk_interp, "gdbtk_cleanup");
+#ifdef IDE
+ {
+ struct ide_event_handle *h = (struct ide_event_handle *) dummy;
+ ide_interface_deregister_all (h);
+ }
#endif
-
-#ifndef REGISTER_CONVERT_TO_VIRTUAL
-#define REGISTER_CONVERT_TO_VIRTUAL(x, y, z, a)
-#endif
-
-#ifndef INVALID_FLOAT
-#define INVALID_FLOAT(x, y) (0 != 0)
-#endif
-
-static void
-get_register (regnum, fp)
- int regnum;
- void *fp;
-{
- char raw_buffer[MAX_REGISTER_RAW_SIZE];
- char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
- int format = (int)fp;
-
- if (read_relative_register_raw_bytes (regnum, raw_buffer))
- {
- Tcl_DStringAppendElement (result_ptr, "Optimized out");
- return;
- }
-
- /* Convert raw data to virtual format if necessary. */
-
- if (REGISTER_CONVERTIBLE (regnum))
- {
- REGISTER_CONVERT_TO_VIRTUAL (regnum, REGISTER_VIRTUAL_TYPE (regnum),
- raw_buffer, virtual_buffer);
- }
- 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_DStringAppend (result_ptr, " ", -1);
+ Tcl_Finalize ();
}
-static int
-gdb_fetch_registers (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
-{
- int format;
-
- if (argc < 2)
- error ("wrong # args");
-
- argc--;
- argv++;
-
- argc--;
- format = **argv++;
-
- return map_arg_registers (argc, argv, get_register, format);
-}
-
-/* This contains the previous values of the registers, since the last call to
- gdb_changed_register_list. */
-
-static char old_regs[REGISTER_BYTES];
+/* Initialize gdbtk. This involves creating a Tcl interpreter,
+ * defining all the Tcl commands that the GUI will use, pointing
+ * all the gdb "hooks" to the correct functions,
+ * and setting the Tcl auto loading environment so that we can find all
+ * the Tcl based library files.
+ */
static void
-register_changed_p (regnum, argp)
- int regnum;
- void *argp; /* Ignored */
+gdbtk_init ( argv0 )
+ char *argv0;
{
- char raw_buffer[MAX_REGISTER_RAW_SIZE];
- char buf[100];
-
- if (read_relative_register_raw_bytes (regnum, raw_buffer))
- return;
-
- if (memcmp (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
- REGISTER_RAW_SIZE (regnum)) == 0)
+ struct cleanup *old_chain;
+ char *lib, *gdbtk_lib, *gdbtk_lib_tmp, *gdbtk_file;
+ int found_main;
+ Tcl_Obj *auto_path_elem, *auto_path_name;
+
+#ifdef IDE
+ /* start-sanitize-ide */
+ struct ide_event_handle *h;
+ const char *errmsg;
+ char *libexecdir;
+ /* end-sanitize-ide */
+#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 _WIN32
+ if (getenv ("DISPLAY") == NULL)
return;
+#endif
- /* Found a changed register. Save new value and return it's number. */
-
- memcpy (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
- REGISTER_RAW_SIZE (regnum));
-
- dsprintf_append_element (result_ptr, "%d", regnum);
-}
-
-static int
-gdb_changed_register_list (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
-{
- argc--;
- argv++;
+ old_chain = make_cleanup ((make_cleanup_func) cleanup_init, 0);
- return map_arg_registers (argc, argv, register_changed_p, NULL);
-}
-\f
-/* This implements the TCL command `gdb_cmd', which sends it's argument into
- the GDB command scanner. */
-
-static int
-gdb_cmd (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
-{
- if (argc != 2)
- error ("wrong # args");
+ /* First init tcl and tk. */
+ Tcl_FindExecutable (argv0);
+ gdbtk_interp = Tcl_CreateInterp ();
- execute_command (argv[1], 1);
+#ifdef TCL_MEM_DEBUG
+ Tcl_InitMemory (gdbtk_interp);
+#endif
- bpstat_do_actions (&stop_bpstat);
+ if (!gdbtk_interp)
+ error ("Tcl_CreateInterp failed");
- return TCL_OK;
-}
+ if (Tcl_Init(gdbtk_interp) != TCL_OK)
+ error ("Tcl_Init failed: %s", gdbtk_interp->result);
-/* This routine acts as a top-level for all GDB code called by tcl/Tk. It
- handles cleanups, and calls to return_to_top_level (usually via error).
- This is necessary in order to prevent a longjmp out of the bowels of Tk,
- possibly leaving things in a bad state. Since this routine can be called
- recursively, it needs to save and restore the contents of the jmp_buf as
- necessary. */
-
-static int
-call_wrapper (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
-{
- int val;
- struct cleanup *saved_cleanup_chain;
- Tcl_CmdProc *func;
- jmp_buf saved_error_return;
- Tcl_DString result, *old_result_ptr;
+#ifndef IDE
+ /* For the IDE we register the cleanup later, after we've
+ initialized events. */
+ make_final_cleanup (gdbtk_cleanup, NULL);
+#endif
- Tcl_DStringInit (&result);
- old_result_ptr = result_ptr;
- result_ptr = &result;
+ /* Initialize the Paths variable. */
+ if (ide_initialize_paths (gdbtk_interp, "gdbtcl") != TCL_OK)
+ error ("ide_initialize_paths failed: %s", gdbtk_interp->result);
- func = (Tcl_CmdProc *)clientData;
- memcpy (saved_error_return, error_return, sizeof (jmp_buf));
+#ifdef IDE
+ /* start-sanitize-ide */
+ /* Find the directory where we expect to find idemanager. We ignore
+ errors since it doesn't really matter if this fails. */
+ libexecdir = Tcl_GetVar2 (gdbtk_interp, "Paths", "libexecdir", TCL_GLOBAL_ONLY);
- saved_cleanup_chain = save_cleanups ();
+ IluTk_Init ();
- if (!setjmp (error_return))
- val = func (clientData, interp, argc, argv);
- else
+ h = ide_event_init_from_environment (&errmsg, libexecdir);
+ make_final_cleanup (gdbtk_cleanup, h);
+ if (h == NULL)
{
- 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. */
+ Tcl_AppendResult (gdbtk_interp, "can't initialize event system: ", errmsg,
+ (char *) NULL);
+ fprintf(stderr, "WARNING: ide_event_init_client failed: %s\n", gdbtk_interp->result);
- Tcl_VarEval (interp, "gdbtk_tcl_idle", NULL);
+ Tcl_SetVar (gdbtk_interp, "IDE_ENABLED", "0", 0);
}
+ else
+ {
+ if (ide_create_tclevent_command (gdbtk_interp, h) != TCL_OK)
+ error ("ide_create_tclevent_command failed: %s", gdbtk_interp->result);
- 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;
-}
-
-static int
-gdb_listfiles (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
-{
- struct objfile *objfile;
- struct partial_symtab *psymtab;
- struct symtab *symtab;
-
- ALL_PSYMTABS (objfile, psymtab)
- Tcl_DStringAppendElement (result_ptr, psymtab->filename);
-
- ALL_SYMTABS (objfile, symtab)
- Tcl_DStringAppendElement (result_ptr, symtab->filename);
-
- return TCL_OK;
-}
-
-static int
-gdb_stop (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
-{
- target_stop ();
-
- return TCL_OK;
-}
-\f
-/* This implements the TCL command `gdb_disassemble'. */
-
-static int
-gdbtk_dis_asm_read_memory (memaddr, myaddr, len, info)
- bfd_vma memaddr;
- bfd_byte *myaddr;
- int len;
- disassemble_info *info;
-{
- extern struct target_ops exec_ops;
- int res;
-
- errno = 0;
- res = xfer_memory (memaddr, myaddr, len, 0, &exec_ops);
-
- if (res == len)
- return 0;
- else
- if (errno == 0)
- return EIO;
- else
- return errno;
-}
-
-/* We need a different sort of line table from the normal one cuz we can't
- depend upon implicit line-end pc's for lines. This is because of the
- reordering we are about to do. */
-
-struct my_line_entry {
- int line;
- CORE_ADDR start_pc;
- CORE_ADDR end_pc;
-};
+ if (ide_create_edit_command (gdbtk_interp, h) != TCL_OK)
+ error ("ide_create_edit_command failed: %s", gdbtk_interp->result);
+
+ if (ide_create_property_command (gdbtk_interp, h) != TCL_OK)
+ error ("ide_create_property_command failed: %s", gdbtk_interp->result);
-static int
-compare_lines (mle1p, mle2p)
- const PTR mle1p;
- const PTR mle2p;
-{
- struct my_line_entry *mle1, *mle2;
- int val;
+ if (ide_create_build_command (gdbtk_interp, h) != TCL_OK)
+ error ("ide_create_build_command failed: %s", gdbtk_interp->result);
- mle1 = (struct my_line_entry *) mle1p;
- mle2 = (struct my_line_entry *) mle2p;
+ if (ide_create_window_register_command (gdbtk_interp, h, "gdb-restore")
+ != TCL_OK)
+ error ("ide_create_window_register_command failed: %s",
+ gdbtk_interp->result);
- val = mle1->line - mle2->line;
+ if (ide_create_window_command (gdbtk_interp, h) != TCL_OK)
+ error ("ide_create_window_command failed: %s", gdbtk_interp->result);
- if (val != 0)
- return val;
+ if (ide_create_exit_command (gdbtk_interp, h) != TCL_OK)
+ error ("ide_create_exit_command failed: %s", gdbtk_interp->result);
- return mle1->start_pc - mle2->start_pc;
-}
+ if (ide_create_help_command (gdbtk_interp) != TCL_OK)
+ error ("ide_create_help_command failed: %s", gdbtk_interp->result);
-static int
-gdb_disassemble (clientData, interp, argc, argv)
- ClientData clientData;
- Tcl_Interp *interp;
- int argc;
- char *argv[];
-{
- CORE_ADDR pc, low, high;
- int mixed_source_and_assembly;
- static disassemble_info di = {
- (fprintf_ftype) fprintf_unfiltered, /* fprintf_func */
- gdb_stdout, /* stream */
- NULL, /* application_data */
- 0, /* flags */
- NULL, /* private_data */
- NULL, /* read_memory_func */
- dis_asm_memory_error, /* memory_error_func */
- dis_asm_print_address /* print_address_func */
- };
-
- 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
- error ("First arg must be 'source' or 'nosource'");
+ /*
+ if (ide_initialize (gdbtk_interp, "gdb") != TCL_OK)
+ error ("ide_initialize failed: %s", gdbtk_interp->result);
+ */
- low = parse_and_eval_address (argv[2]);
+ Tcl_SetVar (gdbtk_interp, "IDE_ENABLED", "1", 0);
+ }
+ /* end-sanitize-ide */
+#else
+ Tcl_SetVar (gdbtk_interp, "IDE_ENABLED", "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(gdbtk_interp) != TCL_OK)
+ error ("Tk_Init failed: %s", gdbtk_interp->result);
+
+ if (Itcl_Init(gdbtk_interp) == TCL_ERROR)
+ error ("Itcl_Init failed: %s", gdbtk_interp->result);
+ Tcl_StaticPackage(gdbtk_interp, "Tktable", Tktable_Init,
+ (Tcl_PackageInitProc *) NULL);
+
+ if (Tix_Init(gdbtk_interp) != TCL_OK)
+ error ("Tix_Init failed: %s", gdbtk_interp->result);
+ Tcl_StaticPackage(gdbtk_interp, "Tktable", Tktable_Init,
+ (Tcl_PackageInitProc *) NULL);
+
+ if (Tktable_Init(gdbtk_interp) != TCL_OK)
+ error ("Tktable_Init failed: %s", gdbtk_interp->result);
+
+ Tcl_StaticPackage(gdbtk_interp, "Tktable", Tktable_Init,
+ (Tcl_PackageInitProc *) NULL);
+ /*
+ * These are the commands to do some Windows Specific stuff...
+ */
+
+#ifdef __CYGWIN__
+ if (ide_create_messagebox_command (gdbtk_interp) != TCL_OK)
+ error ("messagebox command initialization failed");
+ /* On Windows, create a sizebox widget command */
+ if (ide_create_sizebox_command (gdbtk_interp) != TCL_OK)
+ error ("sizebox creation failed");
+ if (ide_create_winprint_command (gdbtk_interp) != TCL_OK)
+ error ("windows print code initialization failed");
+ /* start-sanitize-ide */
+ /* An interface to ShellExecute. */
+ if (ide_create_shell_execute_command (gdbtk_interp) != TCL_OK)
+ error ("shell execute command initialization failed");
+ /* end-sanitize-ide */
+ if (ide_create_win_grab_command (gdbtk_interp) != TCL_OK)
+ error ("grab support command initialization failed");
+ /* Path conversion functions. */
+ if (ide_create_cygwin_path_command (gdbtk_interp) != TCL_OK)
+ error ("cygwin path command initialization failed");
+#endif
- if (argc == 3)
+ /*
+ * This adds all the Gdbtk commands.
+ */
+
+ if (Gdbtk_Init(gdbtk_interp) != TCL_OK)
{
- if (find_pc_partial_function (low, NULL, &low, &high) == 0)
- error ("No function contains specified address");
+ error("Gdbtk_Init failed: %s", gdbtk_interp->result);
}
- else
- high = parse_and_eval_address (argv[3]);
- /* If disassemble_from_exec == -1, then we use the following heuristic to
- determine whether or not to do disassembly from target memory or from the
- exec file:
-
- If we're debugging a local process, read target memory, instead of the
- exec file. This makes disassembly of functions in shared libs work
- 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
- code (for relocation, or whatever).
+ Tcl_StaticPackage(gdbtk_interp, "Gdbtk", Gdbtk_Init, NULL);
+
+ /* This adds all the hooks that call up from the bowels of gdb
+ * back into Tcl-land...
*/
- if (disassemble_from_exec == -1)
- if (strcmp (target_shortname, "child") == 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)
- 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
- got a totally different path to follow. */
-
- if (mixed_source_and_assembly)
- { /* Come here for mixed source/assembly */
- /* The idea here is to present a source-O-centric view of a function to
- the user. This means that things are presented in source order, with
- (possibly) out of order assembly immediately following. */
- 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 next_line;
+ gdbtk_add_hooks();
+
+ /* Add a back door to Tk from the gdb console... */
- symtab = find_pc_symtab (low); /* Assume symtab is valid for whole PC range */
-
- if (!symtab)
- goto assembly_only;
-
-/* First, convert the linetable to a bunch of my_line_entry's. */
-
- le = symtab->linetable->item;
- nlines = symtab->linetable->nitems;
-
- if (nlines <= 0)
- goto assembly_only;
-
- mle = (struct my_line_entry *) alloca (nlines * sizeof (struct my_line_entry));
-
- out_of_order = 0;
+ add_com ("tk", class_obscure, tk_command,
+ "Send a command directly into tk.");
-/* Copy linetable entries for this function into our data structure, creating
- end_pc's and setting out_of_order as appropriate. */
+ /* find the gdb tcl library and source main.tcl */
-/* First, skip all the preceding functions. */
+ gdbtk_lib = getenv ("GDBTK_LIBRARY");
+ if (!gdbtk_lib)
+ {
+ if (access ("gdbtcl/main.tcl", R_OK) == 0)
+ gdbtk_lib = "gdbtcl";
+ else
+ gdbtk_lib = GDBTK_LIBRARY;
+ }
+
+ gdbtk_lib_tmp = xstrdup (gdbtk_lib);
- for (i = 0; i < nlines - 1 && le[i].pc < low; i++) ;
+ found_main = 0;
+ /* see if GDBTK_LIBRARY is a path list */
+ lib = strtok (gdbtk_lib_tmp, GDBTK_PATH_SEP);
-/* Now, copy all entries before the end of this function. */
+ auto_path_name = Tcl_NewStringObj ("auto_path", -1);
- newlines = 0;
- for (; i < nlines - 1 && le[i].pc < high; i++)
+ do
+ {
+ auto_path_elem = Tcl_NewStringObj (lib, -1);
+ if (Tcl_ObjSetVar2 (gdbtk_interp, auto_path_name, NULL, auto_path_elem,
+ TCL_GLOBAL_ONLY | TCL_APPEND_VALUE | TCL_LIST_ELEMENT ) == NULL)
{
- 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[newlines].start_pc = le[i].pc;
- mle[newlines].end_pc = le[i + 1].pc;
- newlines++;
+ fputs_unfiltered (Tcl_GetVar (gdbtk_interp, "errorInfo", 0), gdb_stderr);
+ error ("");
}
-
-/* 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)
+ if (!found_main)
{
- 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++;
+ gdbtk_file = concat (lib, "/main.tcl", (char *) NULL);
+ if (access (gdbtk_file, R_OK) == 0)
+ {
+ found_main++;
+ Tcl_SetVar (gdbtk_interp, "GDBTK_LIBRARY", lib, 0);
+ }
}
+ }
+ while ((lib = strtok (NULL, ":")) != NULL);
-/* Now, sort mle by line #s (and, then by addresses within lines). */
-
- if (out_of_order)
- qsort (mle, newlines, sizeof (struct my_line_entry), compare_lines);
+ free (gdbtk_lib_tmp);
+ Tcl_DecrRefCount(auto_path_name);
-/* Now, for each line entry, emit the specified lines (unless they have been
- emitted before), followed by the assembly code for that line. */
-
- next_line = 0; /* Force out first line */
- for (i = 0; i < newlines; i++)
+ 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 (gdbtk_interp, (char *) script) != TCL_OK)
{
-/* Print out everything from next_line to the current line. */
-
- if (mle[i].line >= next_line)
- {
- 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].line + 1, 0);
-
- next_line = mle[i].line + 1;
- }
+ fputs_unfiltered (Tcl_GetVar (gdbtk_interp, "errorInfo", 0), gdb_stderr);
+ error ("");
+ }
- 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 += (*tm_print_insn) (pc, &di);
- fputs_unfiltered ("\n", gdb_stdout);
- }
+ if (gdbtk_interp->result[0] != '\0')
+ {
+ gdbtk_file = xstrdup (gdbtk_interp->result);
+ found_main++;
}
}
- else
+
+ if (!found_main)
{
-assembly_only:
- for (pc = low; pc < high; )
+ fputs_unfiltered_hook = NULL; /* Force errors to stdout/stderr */
+ if (getenv("GDBTK_LIBRARY"))
{
- QUIT;
- fputs_unfiltered (" ", gdb_stdout);
- print_address (pc, gdb_stdout);
- fputs_unfiltered (":\t ", gdb_stdout);
- pc += (*tm_print_insn) (pc, &di);
- fputs_unfiltered ("\n", gdb_stdout);
+ fprintf_unfiltered (gdb_stderr, "Unable to find main.tcl in %s\n",
+ getenv("GDBTK_LIBRARY"));
+ fprintf_unfiltered (gdb_stderr,
+ "Please set GDBTK_LIBRARY to a path that includes the GDB tcl files.\n");
}
+ else
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "Unable to find main.tcl in %s\n", GDBTK_LIBRARY);
+ fprintf_unfiltered (gdb_stderr,
+ "You might want to set GDBTK_LIBRARY\n");
+ }
+ error("");
}
- gdb_flush (gdb_stdout);
-
- return TCL_OK;
-}
-\f
-static void
-tk_command (cmd, from_tty)
- char *cmd;
- int from_tty;
-{
- int retval;
- char *result;
- struct cleanup *old_chain;
+/* Defer setup of fputs_unfiltered_hook to near the end so that error messages
+ prior to this point go to stdout/stderr. */
- retval = Tcl_Eval (interp, cmd);
+ fputs_unfiltered_hook = gdbtk_fputs;
- result = strdup (interp->result);
+/* start-sanitize-tclpro */
+#ifdef TCLPRO_DEBUGGER
+ {
+ Tcl_DString source_cmd;
+
+ Tcl_DStringInit (&source_cmd);
+ Tcl_DStringAppend (&source_cmd,
+ "if {[info exists env(DEBUG_STUB)]} {source $env(DEBUG_STUB); " -1);
+ Tcl_DStringAppend (&source_cmd, "debugger_init; debugger_eval {source {", -1);
+ Tcl_DStringAppend (&source_cmd, gdbtk_file, -1);
+ Tcl_DStringAppend (&source_cmd, "}}} else {source {", -1);
+ Tcl_DStringAppend (&source_cmd, gdbtk_file, -1);
+ Tcl_DStringAppend (&source_cmd, "}}", -1);
+ if (Tcl_GlobalEval (gdbtk_interp, Tcl_DStringValue (&source_cmd)) != TCL_OK)
+#else
+/* end-sanitize-tclpro */
+ if (Tcl_EvalFile (gdbtk_interp, gdbtk_file) != TCL_OK)
+/* start-sanitize-tclpro */
+#endif
+/* end-sanitize-tclpro */
+ {
+ char *msg;
- old_chain = make_cleanup (free, result);
+ /* Force errorInfo to be set up propertly. */
+ Tcl_AddErrorInfo (gdbtk_interp, "");
- if (retval != TCL_OK)
- error (result);
+ msg = Tcl_GetVar (gdbtk_interp, "errorInfo", TCL_GLOBAL_ONLY);
- printf_unfiltered ("%s\n", result);
+ fputs_unfiltered_hook = NULL; /* Force errors to stdout/stderr */
- do_cleanups (old_chain);
-}
+#ifdef _WIN32
+ MessageBox (NULL, msg, NULL, MB_OK | MB_ICONERROR | MB_TASKMODAL);
+#else
+ fputs_unfiltered (msg, gdb_stderr);
+#endif
-static void
-cleanup_init (ignored)
- int ignored;
-{
- if (mainWindow != NULL)
- Tk_DestroyWindow (mainWindow);
- mainWindow = NULL;
+ error ("");
+ }
+/* start-sanitize-tclpro */
+#ifdef TCLPRO_DEBUGGER
+ Tcl_DStringFree(&source_cmd);
+ }
+#endif
+/* end-sanitize-tclpro */
+
+#ifdef IDE
+ /* start-sanitize-ide */
+ /* Don't do this until we have initialized. Otherwise, we may get a
+ run command before we are ready for one. */
+ if (ide_run_server_init (gdbtk_interp, h) != TCL_OK)
+ error ("ide_run_server_init failed: %s", gdbtk_interp->result);
+ /* end-sanitize-ide */
+#endif
- if (interp != NULL)
- Tcl_DeleteInterp (interp);
- interp = NULL;
-}
+ free (gdbtk_file);
-/* Come here during long calculations to check for GUI events. Usually invoked
- via the QUIT macro. */
+ /* Now source in the filename provided by the --tclcommand option.
+ This is mostly used for the gdbtk testsuite... */
+
+ if (gdbtk_source_filename != NULL)
+ {
+ char *s = "after idle source ";
+ char *script = concat (s, gdbtk_source_filename, (char *) NULL);
+ Tcl_Eval (gdbtk_interp, script);
+ free (gdbtk_source_filename);
+ free (script);
+ }
+
-static void
-gdbtk_interactive ()
-{
- /* Tk_DoOneEvent (TK_DONT_WAIT|TK_IDLE_EVENTS); */
+ discard_cleanups (old_chain);
}
-/* Come here when there is activity on the X file descriptor. */
-
-static void
-x_event (signo)
- int signo;
+/* gdbtk_test is used in main.c to validate the -tclcommand option to
+ gdb, which sources in a file of tcl code after idle during the
+ startup procedure. */
+
+int
+gdbtk_test (filename)
+ char *filename;
{
- /* Process pending events */
-
- while (Tk_DoOneEvent (TK_DONT_WAIT|TK_ALL_EVENTS) != 0);
+ if (access (filename, R_OK) != 0)
+ return 0;
+ else
+ gdbtk_source_filename = xstrdup (filename);
+ return 1;
}
+
+/* Come here during initialize_all_files () */
-static int
-gdbtk_wait (pid, ourstatus)
- int pid;
- struct target_waitstatus *ourstatus;
+void
+_initialize_gdbtk ()
{
- struct sigaction action;
- static sigset_t nullsigmask = {0};
+ if (use_windows)
+ {
+ /* Tell the rest of the world that Gdbtk is now set up. */
-#ifndef SA_RESTART
- /* Needed for SunOS 4.1.x */
-#define SA_RESTART 0
+ init_ui_hook = gdbtk_init;
+#ifdef __CYGWIN__
+ (void) FreeConsole ();
#endif
-
- action.sa_handler = x_event;
- action.sa_mask = nullsigmask;
- action.sa_flags = SA_RESTART;
- sigaction(SIGIO, &action, NULL);
-
- pid = target_wait (pid, ourstatus);
-
- action.sa_handler = SIG_IGN;
- sigaction(SIGIO, &action, NULL);
-
- return pid;
-}
-
-/* This is called from execute_command, and provides a wrapper around
- various command routines in a place where both protocol messages and
- user input both flow through. Mostly this is used for indicating whether
- the target process is running or not.
-*/
-
-static void
-gdbtk_call_command (cmdblk, arg, from_tty)
- struct cmd_list_element *cmdblk;
- char *arg;
- int from_tty;
-{
- if (cmdblk->class == class_run)
- {
- Tcl_VarEval (interp, "gdbtk_tcl_busy", NULL);
- (*cmdblk->function.cfunc)(arg, from_tty);
- Tcl_VarEval (interp, "gdbtk_tcl_idle", NULL);
}
+#ifdef __CYGWIN__
else
- (*cmdblk->function.cfunc)(arg, from_tty);
+ {
+ DWORD ft = GetFileType (GetStdHandle (STD_INPUT_HANDLE));
+
+ switch (ft)
+ {
+ case FILE_TYPE_DISK:
+ case FILE_TYPE_CHAR:
+ case FILE_TYPE_PIPE:
+ break;
+ default:
+ AllocConsole();
+ cygwin32_attach_handle_to_fd ("/dev/conin", 0,
+ GetStdHandle (STD_INPUT_HANDLE),
+ 1, GENERIC_READ);
+ cygwin32_attach_handle_to_fd ("/dev/conout", 1,
+ GetStdHandle (STD_OUTPUT_HANDLE),
+ 0, GENERIC_WRITE);
+ cygwin32_attach_handle_to_fd ("/dev/conout", 2,
+ GetStdHandle (STD_ERROR_HANDLE),
+ 0, GENERIC_WRITE);
+ break;
+ }
+ }
+#endif
}
static void
-gdbtk_init ()
+tk_command (cmd, from_tty)
+ char *cmd;
+ int from_tty;
{
+ int retval;
+ char *result;
struct cleanup *old_chain;
- char *gdbtk_filename;
- int i;
- struct sigaction action;
- static sigset_t nullsigmask = {0};
-
- old_chain = make_cleanup (cleanup_init, 0);
-
- /* First init tcl and tk. */
-
- interp = Tcl_CreateInterp ();
- if (!interp)
- error ("Tcl_CreateInterp failed");
+ /* Catch case of no argument, since this will make the tcl interpreter dump core. */
+ if (cmd == NULL)
+ error_no_arg ("tcl command to interpret");
- mainWindow = Tk_CreateMainWindow (interp, NULL, "gdb", "Gdb");
-
- if (!mainWindow)
- return; /* DISPLAY probably not set */
-
- if (Tcl_Init(interp) != TCL_OK)
- error ("Tcl_Init failed: %s", interp->result);
-
- if (Tk_Init(interp) != TCL_OK)
- error ("Tk_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_sourcelines", call_wrapper, gdb_sourcelines,
- NULL);
- Tcl_CreateCommand (interp, "gdb_listfiles", call_wrapper, gdb_listfiles,
- 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,
- gdb_fetch_registers, NULL);
- Tcl_CreateCommand (interp, "gdb_changed_register_list", call_wrapper,
- gdb_changed_register_list, NULL);
- Tcl_CreateCommand (interp, "gdb_disassemble", call_wrapper,
- gdb_disassemble, NULL);
- Tcl_CreateCommand (interp, "gdb_eval", call_wrapper, gdb_eval, NULL);
- 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_MainLoop;
- print_frame_info_listing_hook = null_routine;
- query_hook = gdbtk_query;
- flush_hook = gdbtk_flush;
- create_breakpoint_hook = gdbtk_create_breakpoint;
- delete_breakpoint_hook = gdbtk_delete_breakpoint;
- modify_breakpoint_hook = gdbtk_modify_breakpoint;
- interactive_hook = gdbtk_interactive;
- target_wait_hook = gdbtk_wait;
- call_command_hook = gdbtk_call_command;
-
- /* Get the file descriptor for the X server */
-
- x_fd = ConnectionNumber (Tk_Display (mainWindow));
-
- /* Setup for I/O interrupts */
-
- action.sa_mask = nullsigmask;
- action.sa_flags = 0;
- action.sa_handler = SIG_IGN;
- sigaction(SIGIO, &action, NULL);
-
-#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
- if (ioctl (x_fd, I_SETSIG, S_INPUT|S_RDNORM) < 0)
- perror_with_name ("gdbtk_init: ioctl I_SETSIG failed");
-#endif /* ifndef FIOASYNC */
-
- add_com ("tk", class_obscure, tk_command,
- "Send a command directly into tk.");
-
- 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. */
-
- gdbtk_filename = getenv ("GDBTK_FILENAME");
- if (!gdbtk_filename)
- if (access ("gdbtk.tcl", R_OK) == 0)
- gdbtk_filename = "gdbtk.tcl";
- else
- gdbtk_filename = GDBTK_FILENAME;
-
-/* Defer setup of fputs_unfiltered_hook to near the end so that error messages
- prior to this point go to stdout/stderr. */
+ retval = Tcl_Eval (gdbtk_interp, cmd);
- fputs_unfiltered_hook = gdbtk_fputs;
+ result = strdup (gdbtk_interp->result);
- if (Tcl_EvalFile (interp, gdbtk_filename) != TCL_OK)
- {
- fputs_unfiltered_hook = NULL; /* Force errors to stdout/stderr */
+ old_chain = make_cleanup (free, result);
- fprintf_unfiltered (stderr, "%s:%d: %s\n", gdbtk_filename,
- interp->errorLine, interp->result);
+ if (retval != TCL_OK)
+ error (result);
- fputs_unfiltered ("Stack trace:\n", gdb_stderr);
- fputs_unfiltered (Tcl_GetVar (interp, "errorInfo", 0), gdb_stderr);
- error ("");
- }
+ printf_unfiltered ("%s\n", result);
- discard_cleanups (old_chain);
+ do_cleanups (old_chain);
}
-/* Come here during initialze_all_files () */
-
-void
-_initialize_gdbtk ()
-{
- if (use_windows)
- {
- /* Tell the rest of the world that Gdbtk is now set up. */
-
- init_ui_hook = gdbtk_init;
- }
-}
projects / deliverable / binutils-gdb.git / blobdiff