home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 March / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / examine.C < prev    next >
Encoding:
C/C++ Source or Header  |  1998-11-09  |  7.9 KB  |  294 lines
  1. // $Id: examine.C,v 1.7 1998/11/09 13:57:16 zeller Exp $ -*- C++ -*-
  2. // Examine range of memory
  3.  
  4. // Copyright (C) 1998 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of DDD.
  8. // 
  9. // DDD is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // DDD is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU General Public
  20. // License along with DDD -- see the file COPYING.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // DDD is the data display debugger.
  25. // For details, see the DDD World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ddd/',
  27. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  28.  
  29. char examine_rcsid[] = 
  30.     "$Id: examine.C,v 1.7 1998/11/09 13:57:16 zeller Exp $";
  31.  
  32. #ifdef __GNUG__
  33. #pragma implementation
  34. #endif
  35.  
  36. #include "examine.h"
  37.  
  38. #include "bool.h"
  39. #include "ddd.h"
  40. #include "disp-read.h"
  41. #include "history.h"
  42. #include "strclass.h"
  43. #include "string-fun.h"
  44. #include "verify.h"
  45. #include "wm.h"
  46. #include "ArgField.h"
  47. #include "Command.h"
  48. #include "Delay.h"
  49. #include "DestroyCB.h"
  50. #include "HelpCB.h"
  51. #include "HistoryD.h"
  52. #include "MakeMenu.h"
  53.  
  54. #include <Xm/SelectioB.h>
  55. #include <Xm/TextF.h>
  56.  
  57.  
  58. static Widget repeat_w;        // Repeat count
  59. static Widget address_w;    // Starting address
  60.  
  61. static string the_format = "";    // The format
  62.  
  63. static void SetFormatCB(Widget w, XtPointer, XtPointer)
  64. {
  65.     the_format = XtName(w);
  66. }
  67.  
  68. static string the_size   = "";    // The size
  69.  
  70. static void SetSizeCB(Widget w, XtPointer, XtPointer)
  71. {
  72.     the_size = XtName(w);
  73. }
  74.  
  75. static Widget octal_w;        // Initial items
  76. static Widget byte_w;
  77. static Widget long_w;
  78.  
  79. static Widget unsigned_char_w;
  80. static Widget binary_w;
  81. static Widget address_format_w;
  82. static Widget wide_char_w;
  83. static Widget wide_string_w;
  84.  
  85. static MMDesc format_menu[] = { 
  86.     { "o", MMPush, { SetFormatCB, 0 }, NULL, &octal_w, 0, 0 },
  87.     { "x", MMPush, { SetFormatCB, 0 }, 0, 0, 0, 0},
  88.     { "d", MMPush, { SetFormatCB, 0 }, 0, 0, 0, 0},
  89.     { "u", MMPush, { SetFormatCB, 0 }, NULL, &unsigned_char_w, 0, 0 },
  90.     { "t", MMPush, { SetFormatCB, 0 }, NULL, &binary_w, 0, 0 },
  91.     { "f", MMPush, { SetFormatCB, 0 }, 0, 0, 0, 0},
  92.     { "a", MMPush, { SetFormatCB, 0 }, NULL, &address_format_w, 0, 0 },
  93.     { "i", MMPush, { SetFormatCB, 0 }, 0, 0, 0, 0},
  94.     { "c", MMPush, { SetFormatCB, 0 }, 0, 0, 0, 0},
  95.     { "C", MMPush, { SetFormatCB, 0 }, NULL, &wide_char_w, 0, 0 },
  96.     { "s", MMPush, { SetFormatCB, 0 }, 0, 0, 0, 0},
  97.     { "W", MMPush, { SetFormatCB, 0 }, NULL, &wide_string_w, 0, 0 },
  98.     MMEnd
  99. };
  100.  
  101. static MMDesc size_menu[] = { 
  102.     { "b", MMPush, { SetSizeCB, 0 }, NULL, &byte_w, 0, 0 },
  103.     { "h", MMPush, { SetSizeCB, 0 }, 0, 0, 0, 0},
  104.     { "w", MMPush, { SetSizeCB, 0 }, 0, 0, 0, 0},
  105.     { "g", MMPush, { SetSizeCB, 0 }, 0, 0, 0, 0},
  106.     { "G", MMPush, { SetSizeCB, 0 }, NULL, &long_w, 0, 0 },
  107.     MMEnd
  108. };
  109.  
  110. static MMDesc examine_menu[] = { 
  111.     { "examine", MMSpinBox,    MMNoCB, NULL, &repeat_w, 0, 0 },
  112.     { "format",  MMOptionMenu, MMNoCB, format_menu, 0, 0, 0 },
  113.     { "size",    MMOptionMenu, MMNoCB, size_menu, 0, 0, 0 },
  114.     { "address", MMComboBox,   MMNoCB, NULL, &address_w, 0, 0 },
  115.     MMEnd
  116. };
  117.  
  118. static string format(const string& format, const string& size)
  119. {
  120.     switch (gdb->type())
  121.     {
  122.     case GDB:
  123.     return format + size;
  124.  
  125.     case DBX:
  126.     // Translate GDB spec to DBX spec.
  127.     //
  128.     // Legal values for FORMAT are:
  129.     //
  130.     // i     instruction (disassembly)
  131.     // d,D   decimal (2 or 4 bytes)
  132.     // o,O   octal (2 or 4 bytes)
  133.     // x,X   hexadecimal (2 or 4 bytes)
  134.     // b     octal (1 byte)
  135.     // c     character
  136.     // w     wide character
  137.     // s     string
  138.     // W     wide character string
  139.     // f     hex and float (4 bytes, 6 digit prec.)
  140.     // F     hex and float (8 bytes, 14 digit prec.)
  141.     // g     same as `F'
  142.     // E     hex and float (16 bytes, 14 digit prec.)
  143.     // ld,lD decimal (4 bytes, same as D)
  144.     // lo,lO octal (4 bytes, same as O)
  145.     // lx,LX hexadecimal (4 bytes, same as X)
  146.     // Ld,LD decimal (8 bytes)
  147.  
  148.     // Handle bytes
  149.     if (format == 'o' && size == 'b')
  150.         return "b";
  151.  
  152.     // Handle wide characters
  153.     if (format == "C")
  154.         return "w";
  155.  
  156.     // Handle float lengths
  157.     if (format == 'f' && size == 'w')
  158.         return "f";
  159.     if (format == 'f' && size == 'g')
  160.         return "g";
  161.     if (format == 'f' && size == 'G')
  162.         return "E";
  163.  
  164.     // Handle size
  165.     if (format == 'd' || format == 'o' || format == 'x')
  166.     {
  167.         if (size == 'w')
  168.         return "l" + format;
  169.         if (size == 'g')
  170.         return "L" + format;
  171.     }
  172.  
  173.     // Ignore size in all other cases
  174.     return format;
  175.  
  176.     case XDB:
  177.     case JDB:
  178.     case PYDB:
  179.     case PERL:
  180.     // No way
  181.     break;
  182.     }
  183.  
  184.     return "";
  185. }
  186.  
  187. static string examine_command()
  188. {
  189.     String s_repeat = XmTextFieldGetString(repeat_w);
  190.     string repeat(s_repeat);
  191.     XtFree(s_repeat);
  192.  
  193.     String s_address = XmTextFieldGetString(address_w);
  194.     string address(s_address);
  195.     XtFree(s_address);
  196.  
  197.     strip_space(repeat);
  198.     strip_space(address);
  199.  
  200.     string fmt = "/" + repeat + format(the_format, the_size);
  201.     switch (gdb->type())
  202.     {
  203.     case DBX:
  204.     // x ADDRESS /FMT
  205.     return "x " + address + " " + fmt;
  206.  
  207.     case GDB:
  208.     // x /FMT ADDRESS
  209.     return "x " + fmt + " " + address;
  210.  
  211.     case XDB:
  212.     case JDB:
  213.     case PYDB:
  214.     case PERL:
  215.     break;            // No way
  216.     }
  217.  
  218.     return "";
  219. }
  220.  
  221. static void DisplayExaminedCB(Widget w, XtPointer, XtPointer)
  222. {
  223.     gdb_command("graph display `" + examine_command() + "`", w);
  224. }
  225.  
  226. static void PrintExaminedCB(Widget w, XtPointer, XtPointer)
  227. {
  228.     gdb_command(examine_command(), w);
  229. }
  230.  
  231. void gdbExamineCB(Widget w, XtPointer, XtPointer)
  232. {
  233.     static Widget dialog = 0;
  234.     if (dialog == 0)
  235.     {
  236.     Arg args[10];
  237.     Cardinal arg = 0;
  238.     XtSetArg(args[arg], XmNautoUnmanage, False); arg++;
  239.     dialog = verify(XmCreatePromptDialog(find_shell(w),
  240.                          "examine_dialog",
  241.                          args, arg));
  242.     Delay::register_shell(dialog);
  243.  
  244.     XtManageChild(XmSelectionBoxGetChild(dialog,
  245.                          XmDIALOG_APPLY_BUTTON));
  246.     XtUnmanageChild(XmSelectionBoxGetChild(dialog, 
  247.                            XmDIALOG_SELECTION_LABEL));
  248.     XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_TEXT));
  249.  
  250.     arg = 0;
  251.     XtSetArg(args[arg], XmNorientation, XmHORIZONTAL); arg++;
  252.     XtSetArg(args[arg], XmNborderWidth,  0); arg++;
  253.     XtSetArg(args[arg], XmNentryBorder,  0); arg++;
  254.     XtSetArg(args[arg], XmNspacing,      0); arg++;
  255.     XtSetArg(args[arg], XmNmarginWidth,  0); arg++;
  256.     XtSetArg(args[arg], XmNmarginHeight, 0); arg++;
  257.     Widget panel = MMcreateButtonPanel(dialog, "panel", examine_menu, 
  258.                        args, arg);
  259.     (void) panel;
  260.     MMaddCallbacks(examine_menu);
  261.     MMaddHelpCallback(examine_menu, ImmediateHelpCB);
  262.  
  263.     manage_child(unsigned_char_w,  gdb->type() == GDB);
  264.     manage_child(binary_w,         gdb->type() == GDB);
  265.     manage_child(address_format_w, gdb->type() == GDB);
  266.     manage_child(wide_char_w,      gdb->type() == DBX);
  267.     manage_child(wide_string_w,    gdb->type() == DBX);
  268.     manage_child(long_w,           gdb->type() == DBX);
  269.  
  270.     // Initialize: use `o' and `b' as default menu items
  271.     XtCallActionProc(octal_w, "ArmAndActivate", 
  272.              (XEvent *)0, (String *)0, 0);
  273.     XtCallActionProc(byte_w, "ArmAndActivate", 
  274.              (XEvent *)0, (String *)0, 0);
  275.  
  276.     tie_combo_box_to_history(address_w, arg_history_filter);
  277.  
  278.     XtAddCallback(dialog, XmNokCallback,
  279.               PrintExaminedCB, XtPointer(0));
  280.     XtAddCallback(dialog, XmNapplyCallback, 
  281.               DisplayExaminedCB, XtPointer(0));
  282.     XtAddCallback(dialog, XmNcancelCallback, 
  283.               UnmanageThisCB, XtPointer(dialog));
  284.     XtAddCallback(dialog, XmNhelpCallback,
  285.               ImmediateHelpCB, XtPointer(0));
  286.     }
  287.  
  288.     string arg = source_arg->get_string();
  289.     if (!is_file_pos(arg) && arg != "")
  290.     XmTextFieldSetString(address_w, arg);
  291.  
  292.     manage_and_raise(dialog);
  293. }
  294.