gdb-2.4+.aux.coff

1 files changed, 672 insertions, 0 deletions

diff --git a/gdb/xgdb.c b/gdb/xgdb.c
new file mode 100644
index 0000000..1b858e8
--- /dev/null
+++ b/gdb/xgdb.c
@@ -0,0 +1,672 @@
+/* Interface from GDB to X windows.
+   Copyright (C) 1987 Free Software Foundation, Inc.
+
+GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY.  No author or distributor accepts responsibility to anyone
+for the consequences of using it or for whether it serves any
+particular purpose or works at all, unless he says so in writing.
+Refer to the GDB General Public License for full details.
+
+Everyone is granted permission to copy, modify and redistribute GDB,
+but only under the conditions described in the GDB General Public
+License.  A copy of this license is supposed to have been given to you
+along with GDB so you can know your rights and responsibilities.  It
+should be in a file named COPYING.  Among other things, the copyright
+notice and this notice must be preserved on all copies.
+
+In other words, go ahead and share GDB, but don't try to stop
+anyone else from sharing it farther.  Help stamp out software hoarding!
+*/
+
+/* Original version was contributed by Derek Beatty, 30 June 87.  */
+
+#include "defs.h"
+#include "initialize.h"
+#include "param.h"
+#include "symtab.h"
+#include "frame.h"
+
+#include <X11/Xlib.h>
+#include <X11/Intrinsic.h>
+#include <X11/Xresource.h>
+#include <X11/Atoms.h>
+#include <X11/TopLevel.h>
+#include <X11/VPane.h>
+#include <X11/Label.h>
+#include <X11/Text.h>
+#include <X11/Command.h>
+#include <X11/ButtonBox.h>
+
+#include <stdio.h>
+
+/* Cursor used in GDB window.  */
+
+#define gdb_width 16
+#define gdb_height 16
+#define gdb_x_hot 7
+#define gdb_y_hot 0
+static short gdb_bits[] = {
+   0x0000, 0x0140, 0x0220, 0x0220,
+   0x23e2, 0x13e4, 0x09c8, 0x0ff8,
+   0x0220, 0x3ffe, 0x0630, 0x03e0,
+   0x0220, 0x1ffc, 0x2632, 0x01c0};
+
+#define gdb_mask_width 16
+#define gdb_mask_height 16
+#define gdb_mask_x_hot 7
+#define gdb_mask_y_hot 0
+static short gdb_mask_bits[] = {
+   0x0360, 0x07f0, 0x07f0, 0x77f7,
+   0x7fff, 0x7fff, 0x1ffc, 0x1ffc,
+   0x7fff, 0x7fff, 0x7fff, 0x0ff8,
+   0x3ffe, 0x7fff, 0x7fff, 0x7fff};
+
+/* The X display on which the window appears.  */
+
+Display *screen_display;
+
+/* The graphics context.  */
+
+GC default_gc;
+
+/* Windows manipulated by this package.  */
+
+static Window icon_window;
+static Widget containing_widget;
+static Widget source_name_widget;
+static Widget source_text_widget;
+static Widget exec_name_widget;
+static Widget button_box_widget;
+
+/* Source text display.  */
+
+static struct symtab *source_window_symtab = 0;
+
+/* Forward declarations */
+
+static Widget create_text_widget ();
+
+START_FILE
+
+/* Display an appropriate piece of source code in the source window.  */
+
+xgdb_display_source ()
+{
+  char *filename;
+  static Arg labelArgs[1];
+  int linenumbers_changed = 0;
+  static int new = 1;
+
+  struct symtab_and_line get_selected_frame_sal ();
+  struct symtab_and_line sal;
+  struct frame_info fi;
+
+  /* Do nothing if called before we are initialized */
+
+  if (!containing_widget) return;
+
+  /* Get the symtab and line number of the selected frame.  */
+
+  fi = get_frame_info (selected_frame);
+  sal = find_pc_line (fi.pc, fi.next_frame);
+
+  /* Strictly this is wrong, but better than a blank display */
+
+  if (sal.symtab == NULL) 
+    {
+      sal.symtab = current_source_symtab;
+      /* current_source_line may be off by a small number like 4 */
+      sal.line = current_source_line;
+    }
+
+  /* Do a path search and get the exact filename of this source file.
+     Also scan it and find its source lines if not already done.  */
+
+  if (sal.symtab)
+    linenumbers_changed = get_filename_and_charpos (sal.symtab, sal.line,
+						    &filename);
+
+  if (!filename) sal.symtab = NULL;
+
+  /* If the source window may be wrong, destroy it (and make a new one).  */
+
+  if (linenumbers_changed || source_window_symtab != sal.symtab)
+    {
+      static Arg fileArgs[1];
+      new = 1;
+      source_window_symtab = sal.symtab;
+
+      XtSetArg (fileArgs[0], XtNfile, filename);
+      XtSetValues (source_text_widget, fileArgs, XtNumber (fileArgs));
+
+      XtSetArg (labelArgs[0], XtNlabel,
+		filename ? filename : "No source displayed.");
+      XtSetValues (source_name_widget, labelArgs, XtNumber (labelArgs));
+      if (filename) free (filename);
+    }
+
+  /* Update display and cursor positions as necessary.
+     Cursor should be placed on line sal.line.  */
+
+  {
+    static int top_line_number, bottom_line_number;
+    int current_top;
+    Arg textArgs[1];
+
+    if (! new)
+      {
+	int new_top;
+
+	/* Get positions of start of display, and caret */
+	XtSetArg (textArgs[0], XtNdisplayPosition, NULL);
+	XtGetValues (source_text_widget, textArgs, XtNumber (textArgs));
+	new_top = source_charpos_line (source_window_symtab,
+				       (int) textArgs[0].value);
+	bottom_line_number += new_top - top_line_number;
+	top_line_number = new_top;
+      }
+
+    /* If appropriate, scroll the text display.  */
+    if (sal.line < top_line_number
+	|| sal.line > bottom_line_number
+	|| new)
+      {
+	/* yes, these magic numbers are ugly, but I don't know how
+	 * to get the height of a text widget in a V11-portable way
+	 */
+	top_line_number = (sal.line > 15) ? sal.line - 15 : 0;
+	bottom_line_number = top_line_number + 35;
+      
+	XtSetArg (textArgs[0], XtNdisplayPosition,
+		  source_line_charpos (source_window_symtab, top_line_number));
+	XtSetValues (source_text_widget, textArgs, XtNumber (textArgs));
+      }
+
+    /* Set the text display cursor position within the text.  */
+
+    XtSetArg (textArgs[0], XtNinsertPosition, 
+	      source_line_charpos (source_window_symtab, sal.line));
+    XtSetValues (source_text_widget, textArgs, XtNumber (textArgs));
+  }
+}
+
+/* Display FILENAME in the title bar at bottom of window.  */
+
+xgdb_display_exec_file (filename)
+     char *filename;
+{
+  static Arg labelArgs[1];
+
+  XtSetArg (labelArgs[0], XtNlabel, filename);
+  XtSetValues (exec_name_widget, labelArgs, XtNumber (labelArgs));
+}
+
+/* Do any necessary prompting, etc.  */
+
+static char *prompt_string;
+
+static void
+print_prompt ()
+{
+  if (prompt_string)
+    printf ("%s", prompt_string);
+}
+
+/* Handlers for buttons.  */
+
+/* Subroutine used by "print" and "print*" buttons.
+   STARFLAG is 1 for print*, 0 for print.
+   Get the "selection" from X and use it as the operand of a print command.  */
+
+static void
+print_1 (starflag)
+     int starflag;
+{
+  int selected_length;
+  char *selected_text;
+
+  char *cmd = starflag ? "print * " : "print ";
+  register int cmdlen = strlen (cmd);
+  
+  selected_text = XFetchBytes (&selected_length);
+  if (selected_length)
+    {
+      char *line = xmalloc (cmdlen + selected_length + 1);
+      strcpy (line, cmd);
+      strncpy (line + cmdlen, selected_text, selected_length);
+      line[cmdlen + selected_length] = 0;
+
+      execute_command (line, 0);
+
+      free (selected_text);
+      free (line);
+    }
+
+  print_prompt ();
+}
+
+static void
+print_button () 
+{
+  print_1 (0);
+}
+
+static void
+print_star_button () 
+{
+  print_1 (1);
+}
+
+/* Subroutine used by "stop at" and "go till" buttons.
+   Set a breakpoint at the position indicated by the "selection"
+   in the source window, and, if RUNFLAG is nonzero, continue.  */
+
+static void
+breakpoint_button_1 (runflag)
+     int runflag;
+{
+  XtTextPosition start, finish;
+  
+  XtTextGetSelectionPos (screen_display, source_text_widget, &start, &finish);
+  if (!source_window_symtab)
+    printf ("No source file displayed.\n");
+  else
+    {
+      set_breakpoint (source_window_symtab, 
+		      source_charpos_line (source_window_symtab, start),
+		      runflag);
+      if (runflag)
+	{
+	  cont_command (0, 1);
+	  xgdb_display_source ();
+	}
+    }
+  print_prompt ();
+}
+
+static void
+breakpoint_button ()
+{
+  breakpoint_button_1 (0);
+}
+
+static void
+until_button ()
+{
+  breakpoint_button_1 (1);
+}
+
+/* decide if a character is trash */
+static int
+garbage (c)
+     char c;
+{
+  if ('a' <= c && c <= 'z') return 0;
+  if ('A' <= c && c <= 'Z') return 0;
+  if ('0' <= c && c <= '9') return 0;
+  if (c == '_') return 0;
+  return 1;
+}
+
+/* Set a breakpoint at the place specified by the "selection" in X.  */
+
+static void
+explicit_breakpoint_button ()
+{
+  int selected_length;
+  char *selected_text;
+
+  selected_text = XFetchBytes (screen_display, &selected_length);
+  if (selected_length)
+    {
+      char *line = (char *) xmalloc (selected_length + 6);
+      register char *p, *sp, *end;
+
+      strcpy (line, "break ");
+
+      /* Copy selection but exclude "garbage" characters.  */
+
+      p = selected_text;
+      end = p + selected_length;
+      sp = line + strlen (line);
+
+      while (garbage (*p) && p != end) p++;
+      while (!garbage (*p) && p != end)
+	*sp++ = *p++;
+      *sp = 0;
+
+      execute_command (line, 0);
+      free (selected_text);
+      free (line);
+    }
+  print_prompt ();
+}
+
+/* Various trivial buttons,
+   most of which just run one GDB command with no arg.  */
+
+static void
+next_button ()
+{
+  execute_command ("next", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+static void
+step_button ()
+{
+  execute_command ("step", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+static void
+cont_button ()
+{
+  execute_command ("cont", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+static void
+finish_button ()
+{
+  execute_command ("finish", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+#if 0
+static void
+deiconify_button ()
+{
+  XUnmapWindow (screen_display, icon_window);
+  XMapWindow (screen_display, containing_widget);
+}
+
+static void
+iconify_button ()
+{
+#if 0
+  static Arg iconArgs[1];
+  XtSetArg (iconArgs[0], XtNlabel, prompt_string);
+  XtCommandSetValues (icon_window, iconArgs, XtNumber (iconArgs));
+#endif 0
+  XUnmapWindow (screen_display, containing_widget);
+  XMapWindow (screen_display, icon_window);
+}
+#endif 0
+
+static void
+up_button ()
+{
+  execute_command ("up", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+static void
+down_button ()
+{
+  execute_command ("down", 0);
+  xgdb_display_source ();
+  print_prompt ();
+}
+
+/* Define and display all the buttons.  */
+
+static void
+addbutton (parent, name, function)
+     Widget parent;
+     char *name;
+     void (*function) ();
+{
+  static Arg commandArgs[2];
+
+  XtSetArg (commandArgs[0], XtNlabel, name);
+  XtSetArg (commandArgs[1], XtNfunction, function);
+  XtCreateWidget (name, commandWidgetClass, parent,
+		  commandArgs, XtNumber (commandArgs));
+}
+
+/* Create the button windows and store them in `buttons'.  */
+
+static void
+create_buttons (parent)
+     Widget parent;
+{
+  addbutton (parent, "Brk At", breakpoint_button);
+  addbutton (parent, "Brk In", explicit_breakpoint_button);
+  addbutton (parent, "Go 'til", until_button);
+
+  addbutton (parent, "Print", print_button);
+  addbutton (parent, "Print*", print_star_button);
+
+  addbutton (parent, "Next", next_button);
+  addbutton (parent, "Step", step_button);
+  addbutton (parent, "Cont", cont_button);
+  addbutton (parent, "Finish", finish_button);
+  
+  addbutton (parent, "Up", up_button);
+  addbutton (parent, "Down", down_button);
+
+/*  addbutton (parent, "Iconify", iconify_button); */
+}
+
+/* Create a "label window" that just displays the string LABEL.  */
+
+static Widget
+create_label (name, label)
+     char *name, *label;
+{
+  static Arg labelArgs[2];
+  
+  XtSetArg (labelArgs[0], XtNname, name);
+  XtSetArg (labelArgs[1], XtNlabel, label);
+  return XtCreateWidget ("label1", labelWidgetClass, containing_widget,
+			 labelArgs, XtNumber (labelArgs));
+}
+
+/* Create a subwindow of PARENT that displays and scrolls the contents
+   of file FILENAME.  */
+
+static Widget
+create_text_widget (parent, filename)
+     Window parent;
+     char *filename;
+{
+  static Arg fileArgs[2];
+  
+  XtSetArg (fileArgs[0], XtNfile, filename);
+  XtSetArg (fileArgs[1], XtNtextOptions, scrollVertical);
+  return XtTextDiskCreate (parent, fileArgs, XtNumber (fileArgs));
+}
+
+/* Entry point to create the widgets representing our display.  */
+
+int
+xgdb_create_window ()
+{
+  static Arg frameArgs[]= {
+      {XtNwidth, (XtArgVal) 600},
+      {XtNheight, (XtArgVal) 700},
+  };
+  
+  XrmResourceDataBase db;
+  FILE *rdb_file;
+  XGCValues dummy;
+  
+  /* Init and database stuff.  */
+  screen_display = XOpenDisplay (NULL);
+  if (screen_display == 0)
+    {
+      fprintf (stderr, "Cannot connect to X server");
+      return 0;
+    }
+
+  {
+    char *dummy1[1];
+    dummy1[0] = 0;
+    XtInitialize ("gdb", "gdb", 0, 0, 0, dummy1);
+  }
+
+  /* should be checking .Xdefaults in $HOME */
+  rdb_file = fopen (".Xresources", "r");
+  if (rdb_file != NULL)
+    {
+      XrmGetDataBase (rdb_file, &db);
+      XrmSetCurrentDataBase (db);
+      fclose (rdb_file);
+    }
+  
+  /* Create the containing_widget.  */
+
+  containing_widget = XtCreateWidget ("frame", vPaneWidgetClass, 0,
+				      frameArgs, XtNumber (frameArgs));
+  
+  default_gc = XCreateGC (screen_display, containing_widget, 0, dummy);
+
+  /* Create source file name window and add to containing_widget */
+  source_name_widget
+    = create_label ("Source File", "No source file yet.");
+
+  /* Create an empty source-display window and add to containing_widget */
+  source_text_widget = create_text_widget (containing_widget, "/dev/null");
+
+  /* Create window full of buttons.  */
+  button_box_widget = XtCreateWidget ("Buttons", buttonBoxWidgetClass,
+				      containing_widget, NULL, 0);
+  create_buttons (button_box_widget);
+
+  /* Create exec file name window and add */
+  exec_name_widget = create_label ("Executable", "No executable specified.");
+
+#if 0
+  /* Create icon window.  */
+  {
+    static Arg iconArgs[2];
+    void (*compiler_bug) () = deiconify_button;
+    XtSetArg (iconArgs[0], XtNlabel, "(gdb)");
+    XtSetArg (iconArgs[1], XtNfunction, compiler_bug);
+    icon_window = XtCommandCreate (DefaultRootWindow (screen_display),
+				   iconArgs, XtNumber (iconArgs));
+    XMoveWindow (screen_display, icon_window, 100, 100);	/* HACK */
+#if 0
+    XSetIconWindow (screen_display, containing_widget, icon_window);
+#endif 0
+  }
+#endif 0
+
+#if 0
+  /* Now make the whole thing appear on the display.  */
+  {
+    Pixmap pm1, pm2;
+    XImage image;
+    Cursor curse;
+
+    image.width = gdb_width;
+    image.height = gdb_height;
+    image.xoffset = 0;
+    image.format = XYBitmap;
+    image.byte_order = LSBFirst;
+    image.bitmap_unit = 16;
+    image.bitmap_bit_order = LSBFirst;
+    image.depth = 1;
+    image.bytes_per_line = 2;
+    image.bits_per_pixel = 1;
+
+    pm1 = XCreatePixmap (screen_display, DefaultScreen (screen_display),
+			 gdb_width, gdb_height, 1);
+    pm2 = XCreatePixmap (screen_display, DefaultScreen (screen_display),
+			 gdb_width, gdb_height, 1);
+
+    image.data = (char *) gdb_bits;
+    XPutImage (screen_display, pm1, default_gc, &image, 0, 0, 0, 0,
+	       gdb_width, gdb_height);
+
+    image.data = (char *) gdb_mask_bits;
+    XPutImage (screen_display, pm2, default_gc, &image, 0, 0, 0, 0,
+	       gdb_width, gdb_height);
+
+    curse = XCreatePixmapCursor (screen_display, pm1, pm2,
+				 BlackPixel (screen_display,
+					     DefaultScreen (screen_display)),
+				 WhitePixel (screen_display,
+					     DefaultScreen (screen_display)),
+				 gdb_x_hot, gdb_y_hot);
+
+    XFreePixmap (screen_display, pm1);
+    XFreePixmap (screen_display, pm2);
+
+    XDefineCursor (screen_display, containing_widget, curse);
+    XDefineCursor (screen_display, icon_window, curse);
+  }
+#endif 0
+
+  XtRealizeWidget (containing_widget);
+  XFlush (screen_display);
+
+  return 1;
+}
+
+/* xgdb_dispatch -- Loop, dispatching on window events,
+   until data is available on FP (which is normally stdin).
+   Then return, so the data on FP can be processed.  */
+
+void
+xgdb_dispatch (fp)
+     FILE *fp;
+{
+  int inmask = 1 << fileno (fp);
+  int xmask = 1 << ConnectionNumber (screen_display);
+  int rfds = 0;
+  int nfds;
+  XEvent ev;
+  int pend;
+  
+  while (! (rfds & inmask))
+    {
+      pend = XPending ();
+      if (!pend)
+	{
+	  rfds = inmask | xmask;
+	  /* this isn't right for 4.3 but it works 'cuz of 4.2 compatibility */
+	  nfds = select (32, &rfds, 0, 0, (struct timeval *) 0);
+	}
+      if (pend || rfds & xmask)
+	{
+	  XNextEvent (screen_display, &ev);
+	  XtDispatchEvent (&ev);
+	}
+    }
+}  
+
+/* If we use an X window, the GDB command loop is told to call this function
+   before reading a command from stdin.
+   PROMPT is saved for later use so buttons can print a prompt-string.  */
+
+void
+xgdb_window_hook (infile, prompt)
+     FILE *infile;
+     char *prompt;
+{
+  prompt_string = prompt;
+  xgdb_display_source ();
+  xgdb_dispatch (infile);
+}
+
+static
+initialize ()
+{
+  extern void (*window_hook) ();
+  extern int inhibit_windows;
+
+  if (getenv ("DISPLAY") && ! inhibit_windows)
+    if (xgdb_create_window ())
+      window_hook = xgdb_window_hook;
+
+  specify_exec_file_hook (xgdb_display_exec_file);
+}
+
+END_FILE