1 /* Startup code for gdbtk.
2 Copyright 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
4 Written by Stu Grossman <grossman@cygnus.com> of Cygnus Support.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
31 #include "tracepoint.h"
48 /* start-sanitize-ide */
52 /* end-sanitize-ide */
55 #ifdef ANSI_PROTOTYPES
65 #include <sys/ioctl.h>
66 #include "gdb_string.h"
74 /* For Cygwin32, we use a timer to periodically check for Windows
75 messages. FIXME: It would be better to not poll, but to instead
76 rewrite the target_wait routines to serve as input sources.
77 Unfortunately, that will be a lot of work. */
78 static sigset_t nullsigmask;
79 static struct sigaction act1, act2;
80 static struct itimerval it_on, it_off;
82 extern int Tktable_Init PARAMS ((Tcl_Interp *interp));
84 static void gdbtk_init PARAMS ((char *));
85 void gdbtk_interactive PARAMS ((void));
86 static void cleanup_init PARAMS ((int));
87 static void tk_command PARAMS ((char *, int));
89 void gdbtk_add_hooks PARAMS ((void));
90 int gdbtk_test PARAMS ((char *));
93 * gdbtk_fputs is defined in the gdbtk_hooks.c, but we need it here
94 * because we delay adding this hook till all the setup is done. That
95 * way errors will go to stdout.
98 extern void gdbtk_fputs PARAMS ((const char *, FILE *));
100 /* Handle for TCL interpreter */
101 Tcl_Interp *gdbtk_interp = NULL;
103 static int gdbtk_timer_going = 0;
105 /* linked variable used to tell tcl what the current thread is */
108 /* This variable is true when the inferior is running. See note in
109 * gdbtk.h for details.
113 /* This variable determines where memory used for disassembly is read from.
114 * See note in gdbtk.h for details.
116 int disassemble_from_exec = -1;
118 /* This variable holds the name of a Tcl file which should be sourced by the
119 interpreter when it goes idle at startup. Used with the testsuite. */
120 static char *gdbtk_source_filename = NULL;
124 /* Supply malloc calls for tcl/tk. We do not want to do this on
125 Windows, because Tcl_Alloc is probably in a DLL which will not call
126 the mmalloc routines. */
132 return xmalloc (size);
136 Tcl_Realloc (ptr, size)
140 return xrealloc (ptr, size);
150 #endif /* ! _WIN32 */
154 /* On Windows, if we hold a file open, other programs can't write to
155 * it. In particular, we don't want to hold the executable open,
156 * because it will mean that people have to get out of the debugging
157 * session in order to remake their program. So we close it, although
158 * this will cost us if and when we need to reopen it.
169 bfd_cache_close (o->obfd);
172 if (exec_bfd != NULL)
173 bfd_cache_close (exec_bfd);
179 /* TclDebug (const char *fmt, ...) works just like printf() but
180 * sends the output to the GDB TK debug window.
181 * Not for normal use; just a convenient tool for debugging
185 #ifdef ANSI_PROTOTYPES
186 TclDebug (const char *fmt, ...)
193 char buf[512], *v[2], *merge;
195 #ifdef ANSI_PROTOTYPES
196 va_start (args, fmt);
200 fmt = va_arg (args, char *);
206 vsprintf (buf, fmt, args);
209 merge = Tcl_Merge (2, v);
210 Tcl_Eval (gdbtk_interp, merge);
216 * The rest of this file contains the start-up, and event handling code for gdbtk.
220 * This cleanup function is added to the cleanup list that surrounds the Tk
221 * main in gdbtk_init. It deletes the Tcl interpreter.
225 cleanup_init (ignored)
228 if (gdbtk_interp != NULL)
229 Tcl_DeleteInterp (gdbtk_interp);
233 /* Come here during long calculations to check for GUI events. Usually invoked
234 via the QUIT macro. */
239 /* Tk_DoOneEvent (TK_DONT_WAIT|TK_IDLE_EVENTS); */
246 static int first = 1;
247 /*TclDebug ("Starting timer....");*/
250 /* first time called, set up all the structs */
252 sigemptyset (&nullsigmask);
254 act1.sa_handler = x_event;
255 act1.sa_mask = nullsigmask;
258 act2.sa_handler = SIG_IGN;
259 act2.sa_mask = nullsigmask;
262 it_on.it_interval.tv_sec = 0;
263 it_on.it_interval.tv_usec = 250000; /* .25 sec */
264 it_on.it_value.tv_sec = 0;
265 it_on.it_value.tv_usec = 250000;
267 it_off.it_interval.tv_sec = 0;
268 it_off.it_interval.tv_usec = 0;
269 it_off.it_value.tv_sec = 0;
270 it_off.it_value.tv_usec = 0;
273 if (!gdbtk_timer_going)
275 sigaction (SIGALRM, &act1, NULL);
276 setitimer (ITIMER_REAL, &it_on, NULL);
277 gdbtk_timer_going = 1;
284 if (gdbtk_timer_going)
286 gdbtk_timer_going = 0;
287 /*TclDebug ("Stopping timer.");*/
288 setitimer (ITIMER_REAL, &it_off, NULL);
289 sigaction (SIGALRM, &act2, NULL);
293 /* gdbtk_init installs this function as a final cleanup. */
296 gdbtk_cleanup (dummy)
299 Tcl_Eval (gdbtk_interp, "gdbtk_cleanup");
302 struct ide_event_handle *h = (struct ide_event_handle *) dummy;
303 ide_interface_deregister_all (h);
309 /* Initialize gdbtk. This involves creating a Tcl interpreter,
310 * defining all the Tcl commands that the GUI will use, pointing
311 * all the gdb "hooks" to the correct functions,
312 * and setting the Tcl auto loading environment so that we can find all
313 * the Tcl based library files.
320 struct cleanup *old_chain;
321 char *lib, *gdbtk_lib, *gdbtk_lib_tmp, *gdbtk_file;
323 Tcl_Obj *auto_path_elem, *auto_path_name;
326 /* start-sanitize-ide */
327 struct ide_event_handle *h;
330 /* end-sanitize-ide */
333 /* If there is no DISPLAY environment variable, Tk_Init below will fail,
334 causing gdb to abort. If instead we simply return here, gdb will
335 gracefully degrade to using the command line interface. */
338 if (getenv ("DISPLAY") == NULL)
342 old_chain = make_cleanup (cleanup_init, 0);
344 /* First init tcl and tk. */
345 Tcl_FindExecutable (argv0);
346 gdbtk_interp = Tcl_CreateInterp ();
349 Tcl_InitMemory (gdbtk_interp);
353 error ("Tcl_CreateInterp failed");
355 if (Tcl_Init(gdbtk_interp) != TCL_OK)
356 error ("Tcl_Init failed: %s", gdbtk_interp->result);
359 /* For the IDE we register the cleanup later, after we've
360 initialized events. */
361 make_final_cleanup (gdbtk_cleanup, NULL);
364 /* Initialize the Paths variable. */
365 if (ide_initialize_paths (gdbtk_interp, "gdbtcl") != TCL_OK)
366 error ("ide_initialize_paths failed: %s", gdbtk_interp->result);
369 /* start-sanitize-ide */
370 /* Find the directory where we expect to find idemanager. We ignore
371 errors since it doesn't really matter if this fails. */
372 libexecdir = Tcl_GetVar2 (gdbtk_interp, "Paths", "libexecdir", TCL_GLOBAL_ONLY);
376 h = ide_event_init_from_environment (&errmsg, libexecdir);
377 make_final_cleanup (gdbtk_cleanup, h);
380 Tcl_AppendResult (gdbtk_interp, "can't initialize event system: ", errmsg,
382 fprintf(stderr, "WARNING: ide_event_init_client failed: %s\n", gdbtk_interp->result);
384 Tcl_SetVar (gdbtk_interp, "IDE_ENABLED", "0", 0);
388 if (ide_create_tclevent_command (gdbtk_interp, h) != TCL_OK)
389 error ("ide_create_tclevent_command failed: %s", gdbtk_interp->result);
391 if (ide_create_edit_command (gdbtk_interp, h) != TCL_OK)
392 error ("ide_create_edit_command failed: %s", gdbtk_interp->result);
394 if (ide_create_property_command (gdbtk_interp, h) != TCL_OK)
395 error ("ide_create_property_command failed: %s", gdbtk_interp->result);
397 if (ide_create_build_command (gdbtk_interp, h) != TCL_OK)
398 error ("ide_create_build_command failed: %s", gdbtk_interp->result);
400 if (ide_create_window_register_command (gdbtk_interp, h, "gdb-restore")
402 error ("ide_create_window_register_command failed: %s",
403 gdbtk_interp->result);
405 if (ide_create_window_command (gdbtk_interp, h) != TCL_OK)
406 error ("ide_create_window_command failed: %s", gdbtk_interp->result);
408 if (ide_create_exit_command (gdbtk_interp, h) != TCL_OK)
409 error ("ide_create_exit_command failed: %s", gdbtk_interp->result);
411 if (ide_create_help_command (gdbtk_interp) != TCL_OK)
412 error ("ide_create_help_command failed: %s", gdbtk_interp->result);
415 if (ide_initialize (gdbtk_interp, "gdb") != TCL_OK)
416 error ("ide_initialize failed: %s", gdbtk_interp->result);
419 Tcl_SetVar (gdbtk_interp, "IDE_ENABLED", "1", 0);
421 /* end-sanitize-ide */
423 Tcl_SetVar (gdbtk_interp, "IDE_ENABLED", "0", 0);
426 /* We don't want to open the X connection until we've done all the
427 IDE initialization. Otherwise, goofy looking unfinished windows
428 pop up when ILU drops into the TCL event loop. */
430 if (Tk_Init(gdbtk_interp) != TCL_OK)
431 error ("Tk_Init failed: %s", gdbtk_interp->result);
433 if (Itcl_Init(gdbtk_interp) == TCL_ERROR)
434 error ("Itcl_Init failed: %s", gdbtk_interp->result);
435 Tcl_StaticPackage(gdbtk_interp, "Tktable", Tktable_Init,
436 (Tcl_PackageInitProc *) NULL);
438 if (Tix_Init(gdbtk_interp) != TCL_OK)
439 error ("Tix_Init failed: %s", gdbtk_interp->result);
440 Tcl_StaticPackage(gdbtk_interp, "Tktable", Tktable_Init,
441 (Tcl_PackageInitProc *) NULL);
443 if (Tktable_Init(gdbtk_interp) != TCL_OK)
444 error ("Tktable_Init failed: %s", gdbtk_interp->result);
446 Tcl_StaticPackage(gdbtk_interp, "Tktable", Tktable_Init,
447 (Tcl_PackageInitProc *) NULL);
449 * These are the commands to do some Windows Specific stuff...
453 if (ide_create_messagebox_command (gdbtk_interp) != TCL_OK)
454 error ("messagebox command initialization failed");
455 /* On Windows, create a sizebox widget command */
456 if (ide_create_sizebox_command (gdbtk_interp) != TCL_OK)
457 error ("sizebox creation failed");
458 if (ide_create_winprint_command (gdbtk_interp) != TCL_OK)
459 error ("windows print code initialization failed");
460 /* start-sanitize-ide */
461 /* An interface to ShellExecute. */
462 if (ide_create_shell_execute_command (gdbtk_interp) != TCL_OK)
463 error ("shell execute command initialization failed");
464 /* end-sanitize-ide */
465 if (ide_create_win_grab_command (gdbtk_interp) != TCL_OK)
466 error ("grab support command initialization failed");
467 /* Path conversion functions. */
468 if (ide_create_cygwin_path_command (gdbtk_interp) != TCL_OK)
469 error ("cygwin path command initialization failed");
473 * This adds all the Gdbtk commands.
476 if (Gdbtk_Init(gdbtk_interp) != TCL_OK)
478 error("Gdbtk_Init failed: %s", gdbtk_interp->result);
481 Tcl_StaticPackage(gdbtk_interp, "Gdbtk", Gdbtk_Init, NULL);
483 /* This adds all the hooks that call up from the bowels of gdb
484 * back into Tcl-land...
489 /* Add a back door to Tk from the gdb console... */
491 add_com ("tk", class_obscure, tk_command,
492 "Send a command directly into tk.");
494 Tcl_LinkVar (gdbtk_interp, "disassemble-from-exec", (char *) &disassemble_from_exec,
497 /* find the gdb tcl library and source main.tcl */
499 gdbtk_lib = getenv ("GDBTK_LIBRARY");
502 if (access ("gdbtcl/main.tcl", R_OK) == 0)
503 gdbtk_lib = "gdbtcl";
505 gdbtk_lib = GDBTK_LIBRARY;
508 gdbtk_lib_tmp = xstrdup (gdbtk_lib);
511 /* see if GDBTK_LIBRARY is a path list */
512 lib = strtok (gdbtk_lib_tmp, GDBTK_PATH_SEP);
514 auto_path_name = Tcl_NewStringObj ("auto_path", -1);
518 auto_path_elem = Tcl_NewStringObj (lib, -1);
519 if (Tcl_ObjSetVar2 (gdbtk_interp, auto_path_name, NULL, auto_path_elem,
520 TCL_GLOBAL_ONLY | TCL_APPEND_VALUE | TCL_LIST_ELEMENT ) == NULL)
522 fputs_unfiltered (Tcl_GetVar (gdbtk_interp, "errorInfo", 0), gdb_stderr);
527 gdbtk_file = concat (lib, "/main.tcl", (char *) NULL);
528 if (access (gdbtk_file, R_OK) == 0)
531 Tcl_SetVar (gdbtk_interp, "GDBTK_LIBRARY", lib, 0);
535 while ((lib = strtok (NULL, ":")) != NULL);
537 free (gdbtk_lib_tmp);
538 Tcl_DecrRefCount(auto_path_name);
542 /* Try finding it with the auto path. */
544 static const char script[] ="\
545 proc gdbtk_find_main {} {\n\
546 global auto_path GDBTK_LIBRARY\n\
547 foreach dir $auto_path {\n\
548 set f [file join $dir main.tcl]\n\
549 if {[file exists $f]} then {\n\
550 set GDBTK_LIBRARY $dir\n\
558 if (Tcl_GlobalEval (gdbtk_interp, (char *) script) != TCL_OK)
560 fputs_unfiltered (Tcl_GetVar (gdbtk_interp, "errorInfo", 0), gdb_stderr);
564 if (gdbtk_interp->result[0] != '\0')
566 gdbtk_file = xstrdup (gdbtk_interp->result);
573 fputs_unfiltered_hook = NULL; /* Force errors to stdout/stderr */
574 if (getenv("GDBTK_LIBRARY"))
576 fprintf_unfiltered (stderr, "Unable to find main.tcl in %s\n",getenv("GDBTK_LIBRARY"));
577 fprintf_unfiltered (stderr,
578 "Please set GDBTK_LIBRARY to a path that includes the GDB tcl files.\n");
582 fprintf_unfiltered (stderr, "Unable to find main.tcl in %s\n", GDBTK_LIBRARY);
583 fprintf_unfiltered (stderr, "You might want to set GDBTK_LIBRARY\n");
588 /* Defer setup of fputs_unfiltered_hook to near the end so that error messages
589 prior to this point go to stdout/stderr. */
591 fputs_unfiltered_hook = gdbtk_fputs;
593 /* start-sanitize-tclpro */
594 #ifdef TCLPRO_DEBUGGER
596 Tcl_DString source_cmd;
598 Tcl_DStringInit (&source_cmd);
599 Tcl_DStringAppend (&source_cmd,
600 "if {[info exists env(DEBUG_STUB)]} {source $env(DEBUG_STUB); " -1);
601 Tcl_DStringAppend (&source_cmd, "debugger_init; debugger_eval {source {", -1);
602 Tcl_DStringAppend (&source_cmd, gdbtk_file, -1);
603 Tcl_DStringAppend (&source_cmd, "}}} else {source {", -1);
604 Tcl_DStringAppend (&source_cmd, gdbtk_file, -1);
605 Tcl_DStringAppend (&source_cmd, "}}", -1);
606 if (Tcl_GlobalEval (gdbtk_interp, Tcl_DStringValue (&source_cmd)) != TCL_OK)
608 /* end-sanitize-tclpro */
609 if (Tcl_EvalFile (gdbtk_interp, gdbtk_file) != TCL_OK)
610 /* start-sanitize-tclpro */
612 /* end-sanitize-tclpro */
616 /* Force errorInfo to be set up propertly. */
617 Tcl_AddErrorInfo (gdbtk_interp, "");
619 msg = Tcl_GetVar (gdbtk_interp, "errorInfo", TCL_GLOBAL_ONLY);
621 fputs_unfiltered_hook = NULL; /* Force errors to stdout/stderr */
624 MessageBox (NULL, msg, NULL, MB_OK | MB_ICONERROR | MB_TASKMODAL);
626 fputs_unfiltered (msg, gdb_stderr);
631 /* start-sanitize-tclpro */
632 #ifdef TCLPRO_DEBUGGER
633 Tcl_DStringFree(&source_cmd);
636 /* end-sanitize-tclpro */
639 /* start-sanitize-ide */
640 /* Don't do this until we have initialized. Otherwise, we may get a
641 run command before we are ready for one. */
642 if (ide_run_server_init (gdbtk_interp, h) != TCL_OK)
643 error ("ide_run_server_init failed: %s", gdbtk_interp->result);
644 /* end-sanitize-ide */
649 /* Now source in the filename provided by the --tclcommand option.
650 This is mostly used for the gdbtk testsuite... */
652 if (gdbtk_source_filename != NULL)
654 char *s = "after idle source ";
655 char *script = concat (s, gdbtk_source_filename, (char *) NULL);
656 Tcl_Eval (gdbtk_interp, script);
657 free (gdbtk_source_filename);
662 discard_cleanups (old_chain);
665 /* gdbtk_test is used in main.c to validate the -tclcommand option to
666 gdb, which sources in a file of tcl code after idle during the
667 startup procedure. */
670 gdbtk_test (filename)
673 if (access (filename, R_OK) != 0)
676 gdbtk_source_filename = xstrdup (filename);
680 /* Come here during initialize_all_files () */
687 /* Tell the rest of the world that Gdbtk is now set up. */
689 init_ui_hook = gdbtk_init;
691 (void) FreeConsole ();
697 DWORD ft = GetFileType (GetStdHandle (STD_INPUT_HANDLE));
698 void cygwin32_attach_handle_to_fd (char *, int, HANDLE, int, int);
708 cygwin32_attach_handle_to_fd ("/dev/conin", 0,
709 GetStdHandle (STD_INPUT_HANDLE),
711 cygwin32_attach_handle_to_fd ("/dev/conout", 1,
712 GetStdHandle (STD_OUTPUT_HANDLE),
714 cygwin32_attach_handle_to_fd ("/dev/conout", 2,
715 GetStdHandle (STD_ERROR_HANDLE),
724 tk_command (cmd, from_tty)
730 struct cleanup *old_chain;
732 /* Catch case of no argument, since this will make the tcl interpreter dump core. */
734 error_no_arg ("tcl command to interpret");
736 retval = Tcl_Eval (gdbtk_interp, cmd);
738 result = strdup (gdbtk_interp->result);
740 old_chain = make_cleanup (free, result);
742 if (retval != TCL_OK)
745 printf_unfiltered ("%s\n", result);
747 do_cleanups (old_chain);