![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xgdb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb|
Return to xgdb.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 root 1: /* Interface from GDB to X windows.
2: Copyright (C) 1987 Free Software Foundation, Inc.
3:
4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY
5: WARRANTY. No author or distributor accepts responsibility to anyone
6: for the consequences of using it or for whether it serves any
7: particular purpose or works at all, unless he says so in writing.
8: Refer to the GDB General Public License for full details.
9:
10: Everyone is granted permission to copy, modify and redistribute GDB,
11: but only under the conditions described in the GDB General Public
12: License. A copy of this license is supposed to have been given to you
13: along with GDB so you can know your rights and responsibilities. It
14: should be in a file named COPYING. Among other things, the copyright
15: notice and this notice must be preserved on all copies.
16:
17: In other words, go ahead and share GDB, but don't try to stop
18: anyone else from sharing it farther. Help stamp out software hoarding!
19: */
20:
21: /* Original version was contributed by Derek Beatty, 30 June 87. */
22:
23: #include "defs.h"
24: #include "initialize.h"
25: #include "param.h"
26: #include "symtab.h"
27: #include "frame.h"
28:
29: #include <X11/IntrinsicP.h>
30: #include <X11/StringDefs.h>
31: #include <X11/Label.h>
32: #include <X11/Command.h>
33: #include <X11/TextP.h>
34: #include <X11/Box.h>
35: #include <X11/VPaned.h>
36:
37: #include <stdio.h>
38:
39: /* Cursor used in GDB window. */
40:
41: #define gdb_width 16
42: #define gdb_height 16
43: #define gdb_x_hot 7
44: #define gdb_y_hot 0
45: static short gdb_bits[] = {
46: 0x0000, 0x0140, 0x0220, 0x0220,
47: 0x23e2, 0x13e4, 0x09c8, 0x0ff8,
48: 0x0220, 0x3ffe, 0x0630, 0x03e0,
49: 0x0220, 0x1ffc, 0x2632, 0x01c0};
50:
51: #define gdb_mask_width 16
52: #define gdb_mask_height 16
53: #define gdb_mask_x_hot 7
54: #define gdb_mask_y_hot 0
55: static short gdb_mask_bits[] = {
56: 0x0360, 0x07f0, 0x07f0, 0x77f7,
57: 0x7fff, 0x7fff, 0x1ffc, 0x1ffc,
58: 0x7fff, 0x7fff, 0x7fff, 0x0ff8,
59: 0x3ffe, 0x7fff, 0x7fff, 0x7fff};
60:
61: /* The X display on which the window appears. */
62:
63: static Display *screen_display;
64:
65: /* Windows manipulated by this package. */
66:
67: static Widget main_widget;
68: static Widget containing_widget;
69: static Widget title_widget;
70: static Widget source_name_widget;
71: static Widget source_text_widget;
72: static Widget exec_name_widget;
73: static Widget button_box_widget;
74:
75: #ifdef VTFD
76: /* Interaction Window */
77:
78: static Widget interactive_widget;
79: XtTextSource PseudoDiskSourceCreate();
80: XtTextSource TSource;
81: static int vtfd[2], vifd[2];
82: #endif
83:
84: /* Source text display. */
85:
86: static struct symtab *source_window_symtab = 0;
87:
88: /* Forward declarations */
89:
90: static Widget create_text_widget ();
91:
92: START_FILE
93:
94: /* Return number of text lines displayed in text widget W. */
95:
96: int /* was XtTextPosition */
97: XtTextLines (w)
98: Widget w;
99: {
100: TextWidget ctx = (TextWidget)w;
101:
102: return ctx->text.lt.lines;
103: }
104:
105: /* Display an appropriate piece of source code in the source window. */
106:
107: xgdb_display_source ()
108: {
109: char *filename;
110: Arg args[1];
111: Arg labelArgs[1];
112: int linenumbers_changed = 0;
113: int must_scroll = 0;
114: int height = XtTextLines (source_text_widget);
115:
116: struct symtab_and_line get_selected_frame_sal ();
117: struct symtab_and_line sal;
118: struct frame_info fi;
119:
120: /* Do nothing if called before we are initialized */
121:
122: if (!containing_widget) return;
123:
124: /* Get the symtab and line number of the selected frame. */
125:
126: fi = get_frame_info (selected_frame);
127: sal = find_pc_line (fi.pc, fi.next_frame);
128:
129: /* Strictly this is wrong, but better than a blank display */
130:
131: if (sal.symtab == NULL)
132: {
133: sal.symtab = current_source_symtab;
134: /* current_source_line may be off by a small number like 4 */
135: sal.line = current_source_line;
136: }
137:
138: /* Do a path search and get the exact filename of this source file.
139: Also scan it and find its source lines if not already done. */
140:
141: if (sal.symtab)
142: linenumbers_changed = get_filename_and_charpos (sal.symtab, sal.line,
143: &filename);
144:
145: if (!filename) sal.symtab = NULL;
146:
147: /* If the source window may be wrong, destroy it (and make a new one). */
148:
149: if (linenumbers_changed || source_window_symtab != sal.symtab)
150: {
151: Arg fileArgs[1];
152: XtTextSource src;
153:
154: must_scroll = 1;
155: source_window_symtab = sal.symtab;
156:
157: src = XtTextGetSource (source_text_widget);
158: XtDiskSourceDestroy (src);
159:
160: XtSetArg (fileArgs[0], XtNfile, filename);
161: src = XtDiskSourceCreate (source_text_widget->core.parent, fileArgs, 1);
162: XtTextSetSource (source_text_widget, src, 0);
163:
164: XtSetArg (labelArgs[0], XtNlabel,
165: filename ? filename : "No source displayed.");
166: XtSetValues (source_name_widget, labelArgs, XtNumber (labelArgs));
167: if (filename) free (filename);
168: }
169:
170: /* Update display and cursor positions as necessary.
171: Cursor should be placed on line sal.line. */
172:
173: /* Find out where the display is positioned (in case user scrolled it). */
174:
175: if (! must_scroll)
176: {
177: int top_line_number;
178:
179: XtSetArg (args[0], XtNdisplayPosition, NULL);
180: XtGetValues (source_text_widget, args, 1);
181: top_line_number = source_charpos_line (source_window_symtab,
182: (int) args[0].value);
183: /* If desired position is off screen, we must scroll. */
184: if (sal.line < top_line_number
185: || sal.line >= top_line_number + height)
186: must_scroll = 1;
187: }
188:
189: /* If appropriate, scroll the text display. */
190:
191: if (must_scroll)
192: {
193: int top_line_number = (sal.line > height/3) ? sal.line - height/3 : 1;
194:
195: XtSetArg (args[0], XtNdisplayPosition,
196: source_line_charpos (source_window_symtab, top_line_number));
197: XtSetValues (source_text_widget, args, 1);
198: }
199:
200: /* Set the text display cursor position within the text. */
201:
202: XtSetArg (args[0], XtNinsertPosition,
203: source_line_charpos (source_window_symtab, sal.line));
204: XtSetValues (source_text_widget, args, 1);
205: }
206:
207: /* Display FILENAME in the title bar at bottom of window. */
208:
209: xgdb_display_exec_file (filename)
210: char *filename;
211: {
212: static Arg labelArgs[1];
213:
214: XtSetArg (labelArgs[0], XtNlabel, filename);
215: XtSetValues (exec_name_widget, labelArgs, XtNumber (labelArgs));
216: }
217:
218: /* Do any necessary prompting, etc. */
219:
220: static char *prompt_string;
221:
222: static void
223: print_prompt ()
224: {
225: if (prompt_string)
226: {
227: printf ("%s", prompt_string);
228: fflush (stdout);
229: }
230: }
231:
232: /* Handlers for buttons. */
233:
234: /* Subroutine used by "print" and "print*" buttons.
235: STARFLAG is 1 for print*, 0 for print.
236: Get the "selection" from X and use it as the operand of a print command. */
237:
238: static void
239: print_button (w, starflag, call_data)
240: Widget w;
241: int starflag;
242: caddr_t call_data;
243: {
244: int selected_length;
245: char *selected_text;
246: char *cmd = starflag ? "print * " : "print ";
247: register int cmdlen = strlen (cmd);
248:
249: selected_text = XFetchBytes (screen_display, &selected_length);
250: if (selected_length)
251: {
252: char *line = xmalloc (cmdlen + selected_length + 1);
253: strcpy (line, cmd);
254: strncpy (line + cmdlen, selected_text, selected_length);
255: line[cmdlen + selected_length] = 0;
256:
257: execute_command (line, 0);
258:
259: free (selected_text);
260: free (line);
261: }
262:
263: print_prompt ();
264: }
265:
266:
267: /* Subroutine used by "stop at" and "go till" buttons.
268: Set a breakpoint at the position indicated by the "selection"
269: in the source window, and, if RUNFLAG is nonzero, continue. */
270:
271: static void
272: breakpoint_button (w, runflag, call_data)
273: Widget w;
274: int runflag;
275: caddr_t call_data;
276: {
277: XtTextPosition start, finish;
278:
279: XtTextGetSelectionPos (source_text_widget, &start, &finish);
280: if (!source_window_symtab)
281: printf ("No source file displayed.\n");
282: else
283: {
284: set_breakpoint (source_window_symtab,
285: source_charpos_line (source_window_symtab, start),
286: runflag);
287: if (runflag)
288: {
289: cont_command (0, 1);
290: xgdb_display_source ();
291: }
292: }
293: print_prompt ();
294: }
295:
296: /* decide if a character is trash */
297: static int
298: garbage (c)
299: char c;
300: {
301: if ('a' <= c && c <= 'z') return 0;
302: if ('A' <= c && c <= 'Z') return 0;
303: if ('0' <= c && c <= '9') return 0;
304: if (c == '_') return 0;
305: return 1;
306: }
307:
308: /* Set a breakpoint at the place specified by the "selection" in X. */
309:
310: static void
311: explicit_breakpoint_button ()
312: {
313: int selected_length;
314: char *selected_text;
315:
316: selected_text = XFetchBytes (screen_display, &selected_length);
317: if (selected_length)
318: {
319: char *line = (char *) xmalloc (selected_length + 6);
320: register char *p, *sp, *end;
321:
322: strcpy (line, "break ");
323:
324: /* Copy selection but exclude "garbage" characters. */
325:
326: p = selected_text;
327: end = p + selected_length;
328: sp = line + strlen (line);
329:
330: while (garbage (*p) && p != end) p++;
331: while (!garbage (*p) && p != end)
332: *sp++ = *p++;
333: *sp = 0;
334:
335: execute_command (line, 0);
336: free (selected_text);
337: free (line);
338: }
339: print_prompt ();
340: }
341:
342: /* Handle a button by running the command COMMAND. */
343:
344: static void
345: do_command (w, command, call_data)
346: Widget w;
347: char *command;
348: caddr_t call_data;
349: {
350: execute_command (command, 0);
351: xgdb_display_source ();
352: print_prompt ();
353: }
354:
355: static void
356: redisplay_button()
357: {
358: xgdb_display_source();
359: }
360:
361: /* Define and display all the buttons. */
362:
363: static void
364: addbutton (parent, name, function, closure)
365: Widget parent;
366: char *name;
367: void (*function) ();
368: caddr_t closure;
369: {
370: static XtCallbackRec Callback[] =
371: {
372: {NULL, (caddr_t)NULL},
373: {NULL, (caddr_t)NULL},
374: };
375: static Arg commandArgs[] =
376: {
377: {XtNlabel, (XtArgVal)NULL},
378: {XtNcallback, (XtArgVal)Callback},
379: };
380:
381: Callback[0].callback = (XtCallbackProc)function;
382: Callback[0].closure = (caddr_t)closure;
383: commandArgs[0].value = (XtArgVal)name;
384: XtCreateManagedWidget (name, commandWidgetClass, parent,
385: commandArgs, XtNumber(commandArgs));
386: }
387:
388: /* Create the button windows and store them in `buttons'. */
389:
390: static void
391: create_buttons (parent)
392: Widget parent;
393: {
394: addbutton (parent, "run", do_command, "run");
395: addbutton (parent, "quit", do_command, "quit");
396:
397: addbutton (parent, "break in", explicit_breakpoint_button, NULL);
398: addbutton (parent, "break at", breakpoint_button, 0);
399: addbutton (parent, "go until", breakpoint_button, 1);
400:
401: addbutton (parent, "print", print_button, 0);
402: addbutton (parent, "print*", print_button, 1);
403:
404: addbutton (parent, "next", do_command, "next");
405: addbutton (parent, "step", do_command, "step");
406: addbutton (parent, "cont", do_command, "cont");
407: addbutton (parent, "finish", do_command, "finish");
408:
409: addbutton (parent, "up", do_command, "up");
410: addbutton (parent, "down", do_command, "down");
411:
412: addbutton (parent, "redisplay", redisplay_button, NULL);
413: }
414:
415: /* Create a "label window" that just displays the string LABEL. */
416:
417: static Widget
418: create_label (name, label)
419: char *name, *label;
420: {
421: Arg labelArgs[2];
422: Widget w;
423:
424: XtSetArg (labelArgs[0], XtNname, name);
425: XtSetArg (labelArgs[1], XtNlabel, label);
426:
427: w = XtCreateManagedWidget ("label", labelWidgetClass, containing_widget,
428: labelArgs, XtNumber (labelArgs));
429: XtPanedSetMinMax (w, w->core.height, w->core.height);
430: return w;
431: }
432:
433: /* Create a subwindow of PARENT that displays and scrolls the contents
434: of file FILENAME. */
435:
436: static Widget
437: create_text_widget (parent, filename)
438: Widget parent;
439: char *filename;
440: {
441: static Arg fileArgs[3];
442: XtTextSource src;
443: XtTextSink sink;
444:
445: XtSetArg (fileArgs[0], XtNfile, filename);
446: src = XtDiskSourceCreate(parent, fileArgs, 1);
447: sink = XtAsciiSinkCreate(parent, NULL, 0);
448:
449: XtSetArg (fileArgs[0], XtNtextOptions, scrollVertical);
450: XtSetArg (fileArgs[1], XtNtextSource, src);
451: XtSetArg (fileArgs[2], XtNtextSink, sink);
452: return XtCreateManagedWidget ("disk", textWidgetClass, parent,
453: fileArgs, XtNumber (fileArgs));
454:
455: #if 0 /* This is tucker's method. */
456:
457: /* Create an empty source-display window and add to containing_widget */
458: XtSetArg (argl[0], XtNfile, "/dev/null");
459: XtSetArg (argl[1], XtNtextOptions, scrollVertical);
460: XtSetArg (argl[2], XtNheight, (XtArgVal)sheight);
461: source_text_widget = XtCreateManagedWidget (NULL, asciiDiskWidgetClass,
462: containing_widget, argl,
463: XtNumber (argl));
464:
465: /* Create NULL disk source */
466: XtSetArg (argl[0], XtNfile, "/dev/null");
467: NullSource = XtDiskSourceCreate (source_text_widget, argl, ONE);
468: #endif
469: }
470:
471: /* window manager argument parsing */
472: extern int *win_argc;
473: extern char **win_argv;
474:
475: /* Entry point to create the widgets representing our display. */
476: int
477: xgdb_create_window ()
478: {
479: int width, height;
480: int sheight;
481: Arg argl[3];
482:
483: /* initialize toolkit, setup defaults */
484: main_widget = XtInitialize ("gdb", "gdb", NULL, 0, win_argc, win_argv);
485: screen_display = XtDisplay (main_widget);
486:
487: /* Find out what size the user specified. */
488:
489: XtSetArg (argl[0], XtNwidth, (XtArgVal)&width);
490: XtSetArg (argl[1], XtNheight, (XtArgVal)&height);
491: XtGetValues (main_widget, argl, XtNumber(argl));
492:
493: /* If none specified, set a default size. */
494:
495: if (!width || !height)
496: {
497: width = 500, height = 700;
498: XtSetArg (argl[0], XtNwidth, (XtArgVal)width);
499: XtSetArg (argl[1], XtNheight, (XtArgVal)height);
500: XtSetValues (main_widget, argl, XtNumber(argl));
501: }
502: sheight = (float)height / 2.5;
503:
504: /* Create the (toplevel) main_widget */
505: XtSetArg (argl[0], XtNwidth, (XtArgVal)width);
506: XtSetArg (argl[1], XtNheight, (XtArgVal)height);
507: containing_widget
508: = XtCreateManagedWidget ("vpaned", vPanedWidgetClass,
509: main_widget, argl, XtNumber (argl));
510: XtPanedSetRefigureMode (containing_widget, FALSE);
511:
512: /* Create title */
513: {
514: char buf[200];
515: extern char *version;
516: sprintf (buf, "GDB %s", version);
517: title_widget =
518: create_label ("Title", buf);
519: }
520:
521: /* Create exec file name window and add */
522: exec_name_widget =
523: create_label ("Executable", "No executable specified");
524:
525: /* Create window full of buttons. */
526: button_box_widget = XtCreateManagedWidget ("buttons", boxWidgetClass,
527: containing_widget, NULL, 0);
528: create_buttons (button_box_widget);
529:
530: /* Create source file name window and add to containing_widget */
531: source_name_widget =
532: create_label ("Source File", "No source file yet.");
533:
534: /* Create an empty source-display window and add to containing_widget */
535: source_text_widget = create_text_widget (containing_widget, "/dev/null");
536:
537: #ifdef VFTD
538: /* Create Fake Text source */
539: {
540: extern XtTextSource TCreateApAsSource();
541: TSource = TCreateApAsSource();
542: }
543:
544: /* Create interactive box */
545: XtSetArg (argl[0], XtNtextSource, (XtArgVal)TSource);
546: XtSetArg (argl[1], XtNtextSink,
547: (XtArgVal)XtAsciiSinkCreate(containing_widget, NULL, 0));
548: XtSetArg (argl[2], XtNtextOptions,
549: (XtArgVal)(scrollVertical | wordBreak));
550: interactive_widget = XtCreateManagedWidget ("gdbWindow", textWidgetClass,
551: containing_widget, argl, THREE);
552: #endif
553:
554: /* Put them one screen */
555: XtPanedSetRefigureMode(containing_widget, TRUE);
556: XtRealizeWidget (main_widget);
557:
558: /* Define GDB cursor */
559: #if 0
560: XDefineCursor (screen_display, XtWindow (main_widget),
561: XCreateFontCursor (screen_display, XC_circle));
562: #endif
563:
564: XFlush (screen_display);
565: return 1;
566: }
567:
568: #define MAX_XGDB_READ 128
569:
570: /* xgdb_dispatch -- Loop, dispatching on window events,
571: until data is available on FP (which is normally stdin).
572: Then return, so the data on FP can be processed. */
573:
574: void
575: xgdb_dispatch (fp)
576: FILE *fp;
577: {
578: int inmask = 1 << fileno (fp);
579: int xmask = 1 << ConnectionNumber (screen_display);
580: int rfds = 0;
581: int nfds;
582: XEvent ev;
583: int pend;
584: int nread;
585: char buf[1024];
586: int ipmask;
587:
588: #ifdef VTFD
589: ipmask = 1 << vtfd[0];
590: #endif
591:
592: while (! (rfds & inmask))
593: {
594: pend = XPending (screen_display);
595: if (!pend)
596: {
597: rfds = inmask | xmask | ipmask;
598: /* this isn't right for 4.3 but it works 'cuz of 4.2 compatibility */
599: nfds = select (32, &rfds, 0, 0, (struct timeval *) 0);
600: }
601: if (pend || rfds & xmask)
602: {
603: XNextEvent (screen_display, &ev);
604: XtDispatchEvent (&ev);
605: }
606:
607: #ifdef VTFD
608: /* Handle I/O through the command window. */
609: if (pend == 0 && (rfds & ipmask))
610: {
611: nread = read (vtfd[0], buf, sizeof(buf));
612: xgdb_write (buf, nread);
613: }
614: nread = xgdb_read (buf, MAX_XGDB_READ);
615: if (pend == 0 && nread > 0)
616: {
617: write (vifd[1], buf, nread);
618: }
619: #endif
620: }
621: }
622:
623: #ifdef VTFD
624:
625: static int output_size;
626: static int used_size;
627: static char *output_string;
628:
629: static void
630: xgdb_init_text ()
631: {
632: Arg args[2];
633:
634: output_size = 1000;
635: output_string = (char *) xmalloc (output_size);
636: used_size = 0;
637:
638: XtSetArg (args[0], XtNstring, (XtArgVal) output_string);
639: XtSetArg (args[1], XtNlength, (XtArgVal) output_size);
640: TSource
641: = XtStringSourceCreate (toplevel, args, 2);
642:
643: XtSetArg (args[0], XtNtextSource, TSource);
644: XtSetValues (interaction_widget, Args, 1);
645: }
646:
647: static void
648: xgdb_grow_text (size)
649: int size;
650: {
651: if (output_size < used_size + size + 200)
652: {
653: Arg args[2];
654:
655: XtStringSourceDestroy (TSource);
656:
657: output_size = (used_size + size + 1010 + 512) / 1010 * 1010;
658: output_string = xrealloc (output_string, output_size);
659:
660: XtSetArg (args[0], XtNstring, (XtArgVal) output_string);
661: XtSetArg (args[1], XtNlength, (XtArgVal) output_size);
662: TSource
663: = XtStringSourceCreate (toplevel, args, 2);
664:
665: XtSetArg (args[0], XtNtextSource, TSource);
666: XtSetValues (interaction_widget, Args, 1);
667: }
668: }
669:
670: /*VARARGS*/
671: xgdb_printf (fmt, arg1, arg2, arg3, arg4)
672: char *fmt;
673: {
674: char buf[1024];
675: XtTextBlock text;
676: XtTextPosition pos;
677:
678: /* ??? This will crash on the wrong data. */
679: pos = (*TSource->Scan)(TSource, 0, XtstAll, XtsdRight, 1, 0);
680: sprintf (buf, fmt, arg1, arg2, arg3, arg4);
681: text.length = strlen (buf);
682: text.ptr = buf;
683: xgdb_grow_text (text.length);
684: used_size += text.length;
685: XtTextReplace (interactive_widget, pos, pos, &text);
686: XtTextSetInsertionPoint (interactive_widget, pos + text.length);
687: XFlush (screen_display);
688: }
689:
690: int
691: xgdb_write (buf, len)
692: char *buf;
693: int len;
694: {
695: XtTextBlock text;
696: XtTextPosition pos;
697:
698: pos = (*TSource->Scan)(TSource, 0, XtstAll, XtsdRight, 1, 0);
699: text.length = len;
700: text.ptr = buf;
701: xgdb_grow_text (text.length);
702: used_size += text.length;
703: XtTextReplace (interactive_widget, pos, pos, &text);
704: XtTextSetInsertionPoint (interactive_widget, pos + text.length);
705: XFlush (screen_display);
706: }
707:
708: int
709: xgdb_read (buf, maxlen)
710: char *buf;
711: int maxlen;
712: {
713: XtTextBlock text;
714: XtTextPosition endpos;
715: int length = 0;
716:
717: xgdb_grow_text (maxlen);
718: endpos = XtTextGetInsertionPoint (interactive_widget);
719: length = endpos - used_size;
720: if (length > 0)
721: {
722: (*TSource->Read) (TSource, lastpos, &text, maxlen - 10);
723: length = text.length;
724: strncpy(buf, text.ptr, length);
725: buf[length] = NULL;
726: used_size += length;
727: }
728: return length;
729: }
730: #endif /* VTFD */
731:
732: /* If we use an X window, the GDB command loop is told to call this function
733: before reading a command from stdin.
734: PROMPT is saved for later use so buttons can print a prompt-string. */
735:
736: void
737: xgdb_window_hook (infile, prompt)
738: FILE *infile;
739: char *prompt;
740: {
741: prompt_string = prompt;
742: xgdb_display_source ();
743: xgdb_dispatch (infile);
744: }
745:
746: static
747: initialize ()
748: {
749: extern void (*window_hook) ();
750: extern int inhibit_windows;
751:
752: if (getenv ("DISPLAY") && ! inhibit_windows)
753: if (xgdb_create_window ())
754: window_hook = xgdb_window_hook;
755:
756: specify_exec_file_hook (xgdb_display_exec_file);
757: }
758:
759: END_FILE
760:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.