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 / GDBAgent.h < prev    next >
C/C++ Source or Header  |  1998-10-23  |  26KB  |  771 lines
  1. // $Id: GDBAgent.h,v 1.107 1998/10/24 00:10:47 zeller Exp $
  2. // Communicate with separate GDB process
  3.  
  4. // Copyright (C) 1995 Technische Universitaet Braunschweig, Germany.
  5. // Written by Dorothea Luetkehaus <luetke@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. //-----------------------------------------------------------------------------
  30. // A GDBAgent creates a connection to an inferior GDB via a TTYAgent.
  31. // There are three ways to send commands to GDB:
  32. // 1. send_user_cmd: is used for user input at the GDB prompt.  GDB output
  33. //    (partial answers) are processed immediately.
  34. // 2. send_question: is used for internal communication.  All answers
  35. //    are buffered until the whole answer is received.  send_question can
  36. //    only be used if GDB is ready for input.
  37. // 3. send_qu_array: issues a list of queries to GDB.  The passed function
  38. //    is called as soon as the last query is processed.  The passed function
  39. //    must free the memory claimed by the query array.
  40. //-----------------------------------------------------------------------------
  41.  
  42. #ifndef _DDD_GDBAgent_h
  43. #define _DDD_GDBAgent_h
  44.  
  45. #ifdef __GNUG__
  46. #pragma interface
  47. #endif
  48.  
  49. #include "TTYAgent.h"
  50. #include "HandlerL.h"
  51. #include "strclass.h"
  52. #include "bool.h"
  53. #include "assert.h"
  54. #include "StringA.h"
  55. #include "VoidArray.h"
  56.  
  57. //-----------------------------------------------------------------------------
  58. // Debugger types
  59. //-----------------------------------------------------------------------------
  60.  
  61. enum DebuggerType { GDB, DBX, XDB, JDB, PYDB, PERL };
  62.  
  63.  
  64. //-----------------------------------------------------------------------------
  65. // Program language
  66. //-----------------------------------------------------------------------------
  67.  
  68. #ifdef LANGUAGE_C
  69. #undef LANGUAGE_C        // DEC defines this
  70. #endif
  71.  
  72. enum ProgramLanguage { 
  73.     LANGUAGE_C,            // C-like: C, C++
  74.     LANGUAGE_JAVA,        // Java, as supported by GDB.
  75.     LANGUAGE_PASCAL,        // Pascal-like: Pascal, Modula...
  76.     LANGUAGE_ADA,        // Ada (GNAT), as supported by GDB
  77.     LANGUAGE_CHILL,        // Chill, as supported by GDB.
  78.     LANGUAGE_FORTRAN,        // FORTRAN, as supported by GDB.
  79.     LANGUAGE_PYTHON,        // Python, as supported by PYDB.
  80.     LANGUAGE_PERL,        // Perl, as supported by Perl.
  81.     LANGUAGE_OTHER        // Others
  82. };
  83.  
  84. //-----------------------------------------------------------------------------
  85. // Watch modes
  86. //-----------------------------------------------------------------------------
  87.  
  88. typedef int WatchMode;
  89.  
  90. const int WATCH_CHANGE = 1;    // break if value changes
  91. const int WATCH_READ   = 2;    // break if value is read
  92. const int WATCH_WRITE  = 4;    // break if value is written
  93.  
  94. const int WATCH_ACCESS = WATCH_READ | WATCH_WRITE; // shorthand
  95.  
  96. //-----------------------------------------------------------------------------
  97. // Procedure types.
  98. //-----------------------------------------------------------------------------
  99.  
  100. // Called as soon as an ANSWER on send_user_cmd (or a part of it)
  101. // is received
  102. typedef void (* OAProc) (const string& answer,
  103.              void* user_data);
  104.  
  105. // Called after the whole answer to send_user_cmd has been received
  106. typedef void (* OACProc) (void* user_data);
  107.  
  108. // Called from send_question with the complete answer
  109. typedef void (* OQCProc) (const string& complete_answer,
  110.               void*  qu_data);
  111.  
  112. // Called from send_qu_array with the complete answers
  113. typedef void (* OQACProc) (const StringArray& complete_answers,
  114.                const VoidArray& user_datas,
  115.                void *user_data);
  116.  
  117. //-----------------------------------------------------------------------------
  118.  
  119. // Create appropriate call for the given debugger
  120. string build_gdb_call(DebuggerType debugger_type,
  121.               const string& debugger_command,
  122.               const string& init_file,
  123.               int argc, char *argv[],
  124.               string myArguments = "");
  125.  
  126. // Handlers
  127. const unsigned ReadyForQuestion = TTYAgent_NTypes;
  128. const unsigned ReadyForCmd      = ReadyForQuestion + 1;
  129. const unsigned LanguageChanged  = ReadyForCmd + 1;
  130. const unsigned ReplyRequired    = LanguageChanged + 1;
  131. const unsigned EchoDetected     = ReplyRequired + 1;
  132. const unsigned AsyncAnswer      = EchoDetected + 1;
  133. const unsigned Recording        = AsyncAnswer + 1;
  134. const unsigned GDBAgent_NTypes  = Recording + 1;
  135.  
  136. // Handler info
  137. struct ReplyRequiredInfo {
  138.     string question;        // Question asked by GDB
  139.     string reply;        // Our reply
  140.  
  141.     ReplyRequiredInfo()
  142.     : question(), reply()
  143.     {}
  144. };
  145.  
  146. //-----------------------------------------------------------------------------
  147. // The GDBAgent class.
  148. //-----------------------------------------------------------------------------
  149.  
  150. class GDBAgent: public TTYAgent {
  151. public:
  152.     DECLARE_TYPE_INFO
  153.  
  154. protected:
  155.     enum State {
  156.     ReadyWithPrompt,
  157.     BusyOnCmd, 
  158.     BusyOnQuestion, 
  159.     BusyOnQuArray,
  160.     BusyOnInitialCmds
  161.     };
  162.     State state;        // Current state
  163.  
  164. private:
  165.     DebuggerType    _type;    // Debugger type
  166.     void*           _user_data;    // used in callbacks etc.
  167.  
  168.     bool _has_frame_command;    // Debugger properties
  169.     bool _has_func_command;    
  170.     bool _has_run_io_command;
  171.     bool _has_print_r_option;
  172.     bool _has_output_command;
  173.     bool _has_where_h_option;
  174.     bool _has_display_command;
  175.     bool _has_clear_command;
  176.     bool _has_handler_command;
  177.     bool _has_pwd_command;
  178.     bool _has_setenv_command;
  179.     bool _has_edit_command;
  180.     bool _has_make_command;
  181.     bool _has_jump_command;
  182.     bool _has_regs_command;
  183.     WatchMode _has_watch_command;
  184.     bool _has_named_values;
  185.     bool _has_when_command;
  186.     bool _has_when_semicolon;
  187.     bool _wants_delete_comma;
  188.     bool _has_err_redirection;
  189.     bool _has_givenfile_command;
  190.     bool _has_cont_sig_command;
  191.     bool _has_examine_command;
  192.     bool _has_rerun_command;
  193.     bool _rerun_clears_args;
  194.  
  195.     ProgramLanguage _program_language; // Current program language
  196.  
  197.     bool _verbatim;        // True if in verbatim mode
  198.     bool _recording;        // True if we are recording commands
  199.     bool _detect_echos;        // True if echos are to be detected
  200.  
  201.     string last_prompt;        // Last prompt received
  202.     string last_written;    // Last command sent
  203.     int echoed_characters;      // # of echoed characters so far (-1: no echo)
  204.  
  205.     GDBAgent& operator = (const GDBAgent&) { assert(0); return *this; }
  206.  
  207. protected:
  208.     // Return PREFIX + EXPR, parenthesizing EXPR if needed
  209.     static string prepend_prefix(const string& prefix, const string& expr);
  210.  
  211.     // Return EXPR + SUFFIX, parenthesizing EXPR if needed
  212.     static string append_suffix(const string& expr, const string& suffix);
  213.  
  214.     // General trace function
  215.     void trace(char *prefix, void *call_data) const;
  216.  
  217.     // Perl specials
  218.     static void munch_perl_array(string& value, bool hash);
  219.     static void munch_perl_scalar(string& value);
  220.  
  221. public:
  222.     // Constructor
  223.     GDBAgent (XtAppContext app_context,
  224.           const string& gdb_call,
  225.           DebuggerType type,
  226.           unsigned nTypes = GDBAgent_NTypes);
  227.  
  228.     // Duplicator
  229.     GDBAgent (const GDBAgent& gdb);
  230.     virtual Agent *dup() const { return new GDBAgent(*this); }
  231.  
  232.     ~GDBAgent ();
  233.  
  234.     // Start new process
  235.     void do_start (OAProc  on_answer,
  236.            OACProc on_answer_completion,
  237.            void*   user_data);
  238.  
  239.     // After receiving the first GDB prompt, send commands to GDB.
  240.     // Processing is very much like send_user_cmd_plus.
  241.     void start_plus (OAProc   on_answer,
  242.              OACProc  on_answer_completion,
  243.              void*    user_data,
  244.              const StringArray& cmds,
  245.              const VoidArray& user_datas,
  246.              int      qu_count,
  247.              OQACProc on_qu_array_completion,
  248.              void*    qa_data);
  249.  
  250.     // true iff command was sent.
  251.     // If user_data == 0, _user_data remains unchanged.
  252.     bool send_user_cmd      (string cmd, void* user_data = 0);  
  253.     bool send_user_ctrl_cmd (string cmd, void* user_data = 0);
  254.  
  255.  
  256.     // Order of tasks:
  257.     // 1. Send USER_CMD to GDB, as in send_user_cmd
  258.     //    (state: ReadyWithPrompt --> BusyOnCmd)
  259.     // 2. Call OAProc when answer comes in
  260.     //    (state:BusyOnCmd --> BusyOnQuArray)
  261.     // 3. Send CMDS, as in send_qu_array.
  262.     // 4. When all replies have come in: call OACProc and OQACProc.
  263.     //
  264.     bool send_user_cmd_plus (const StringArray& cmds,
  265.                  const VoidArray& qu_datas,
  266.                  int      qu_count,
  267.                  OQACProc on_qu_array_completion,
  268.                  void*    qa_data,
  269.                  string user_cmd,
  270.                  void* user_data = 0);
  271.  
  272.     bool send_question (string  cmd,
  273.             OQCProc on_question_completion,
  274.             void*   qu_data);
  275.  
  276.     bool send_qu_array (const StringArray& cmds,
  277.             const VoidArray& qu_datas,
  278.             int      qu_count,
  279.             OQACProc on_qu_array_completion,
  280.             void*    qa_data);
  281.  
  282.  
  283.     // Resources
  284.     DebuggerType type()       const { return _type; }
  285.     string title()            const;
  286.     bool isReadyWithPrompt()  const { return state == ReadyWithPrompt; }
  287.     bool isBusyOnCmd()        const { return state == BusyOnCmd
  288.                       || state == BusyOnInitialCmds; }
  289.     bool isBusyOnQuestion()   const { return state == BusyOnQuestion
  290.                       || state == BusyOnQuArray; }
  291.     string prompt()           const { return last_prompt; }
  292.  
  293.  
  294.     // Debugger properties
  295.     // True if debugger has `frame' command
  296.     bool has_frame_command() const    { return _has_frame_command; }    
  297.     bool has_frame_command(bool val)  { return _has_frame_command = val; }
  298.  
  299.     // True if debugger has `func' command
  300.     bool has_func_command() const    { return _has_func_command; }    
  301.     bool has_func_command(bool val)  { return _has_func_command = val; }
  302.  
  303.     // True if debugger has `run_io' command
  304.     bool has_run_io_command() const    { return _has_run_io_command; }
  305.     bool has_run_io_command(bool val)  { return _has_run_io_command = val; }
  306.  
  307.     // True if debugger has `-r' option in `print' and `display'
  308.     bool has_print_r_option() const   { return _has_print_r_option; }
  309.     bool has_print_r_option(bool val) { return _has_print_r_option = val; }
  310.  
  311.     // True if debugger has `output' command
  312.     bool has_output_command() const   { return _has_output_command; }
  313.     bool has_output_command(bool val) { return _has_output_command = val; }
  314.  
  315.     // True if debugger has `-h' option in `where'
  316.     bool has_where_h_option() const   { return _has_where_h_option; }
  317.     bool has_where_h_option(bool val) { return _has_where_h_option = val; }
  318.  
  319.     // True if debugger has `display' command
  320.     bool has_display_command() const   { return _has_display_command; }
  321.     bool has_display_command(bool val) { return _has_display_command = val; }
  322.  
  323.     // True if debugger has `clear' command
  324.     bool has_clear_command() const     { return _has_clear_command; }
  325.     bool has_clear_command(bool val)   { return _has_clear_command = val; }
  326.  
  327.     // True if debugger has `handler' command
  328.     bool has_handler_command() const   { return _has_handler_command; }
  329.     bool has_handler_command(bool val) { return _has_handler_command = val; }
  330.  
  331.     // True if debugger has `pwd' command
  332.     bool has_pwd_command() const       { return _has_pwd_command; }
  333.     bool has_pwd_command(bool val)     { return _has_pwd_command = val; }
  334.  
  335.     // True if debugger has `setenv' command
  336.     bool has_setenv_command() const    { return _has_setenv_command; }
  337.     bool has_setenv_command(bool val)  { return _has_setenv_command = val; }
  338.  
  339.     // True if debugger has `edit' command
  340.     bool has_edit_command() const      { return _has_edit_command; }
  341.     bool has_edit_command(bool val)    { return _has_edit_command = val; }
  342.  
  343.     // True if debugger has `make' command
  344.     bool has_make_command() const      { return _has_make_command; }
  345.     bool has_make_command(bool val)    { return _has_make_command = val; }
  346.  
  347.     // True if debugger has `jump' command
  348.     bool has_jump_command() const      { return _has_jump_command; }
  349.     bool has_jump_command(bool val)    { return _has_jump_command = val; }
  350.  
  351.     // True if debugger has `regs' command
  352.     bool has_regs_command() const      { return _has_regs_command; }
  353.     bool has_regs_command(bool val)    { return _has_regs_command = val; }
  354.  
  355.     // Non-zero if debugger has `watch' command; also indicates
  356.     // `watch' capabilities
  357.     WatchMode has_watch_command() const { return _has_watch_command; }
  358.     WatchMode has_watch_command(WatchMode val)
  359.     { 
  360.     return _has_watch_command = val;
  361.     }
  362.  
  363.     // True if debugger issues `NAME = VALUE' upon `print' commands
  364.     bool has_named_values() const      { return _has_named_values; }
  365.     bool has_named_values(bool val)    { return _has_named_values = val; }
  366.  
  367.     // True if debugger has `when' command
  368.     bool has_when_command() const      { return _has_when_command; }
  369.     bool has_when_command(bool val)    { return _has_when_command = val; }
  370.  
  371.     // True if debugger wants `;' at the end of `when' command specs
  372.     bool has_when_semicolon() const    { return _has_when_semicolon; }
  373.     bool has_when_semicolon(bool val)  { return _has_when_semicolon = val; }
  374.  
  375.     // True if debugger wants events separated by `,'
  376.     bool wants_delete_comma() const      { return _wants_delete_comma; }
  377.     bool wants_delete_comma(bool val)    { return _wants_delete_comma = val; }
  378.  
  379.     // True if debugger has stderr redirection using `>&'
  380.     bool has_err_redirection() const   { return _has_err_redirection; }
  381.     bool has_err_redirection(bool val) { return _has_err_redirection = val; }
  382.  
  383.     // True if debugger has `givenfile' command
  384.     bool has_givenfile_command() const   { return _has_givenfile_command; }
  385.     bool has_givenfile_command(bool val) 
  386.     {
  387.     return _has_givenfile_command = val;
  388.     }
  389.  
  390.     // True if debugger has `cont sig' command
  391.     bool has_cont_sig_command() const   { return _has_cont_sig_command; }
  392.     bool has_cont_sig_command(bool val) { return _has_cont_sig_command = val; }
  393.  
  394.     // True if debugger has `examine' or `x' command
  395.     bool has_examine_command() const   { return _has_examine_command; }
  396.     bool has_examine_command(bool val) { return _has_examine_command = val; }
  397.  
  398.     // True if debugger has `rerun' command
  399.     bool has_rerun_command() const   { return _has_rerun_command; }
  400.     bool has_rerun_command(bool val) { return _has_rerun_command = val; }
  401.  
  402.     // True if `rerun' command clears current arguments
  403.     bool rerun_clears_args() const   { return _rerun_clears_args; }
  404.     bool rerun_clears_args(bool val) { return _rerun_clears_args = val; }
  405.  
  406.     // Current program language
  407.     ProgramLanguage program_language() const   { return _program_language; }
  408.     ProgramLanguage program_language(ProgramLanguage val) 
  409.     {
  410.     if (_program_language != val)
  411.     {
  412.         _program_language = val;
  413.         callHandlers(LanguageChanged, (void *)val);
  414.     }
  415.     return program_language();
  416.     }
  417.     ProgramLanguage program_language(string text);
  418.  
  419.     // True if debugger can enable breakpoints
  420.     bool has_enable_command() const
  421.     { 
  422.     return type() == GDB || type() == XDB || type() == PYDB || 
  423.         has_handler_command();
  424.     }
  425.     bool has_disable_command() const
  426.     {
  427.     return has_enable_command();
  428.     }
  429.  
  430.     // True if debugger can set ignore counts on breakpoints
  431.     bool has_ignore_command() const
  432.     {
  433.     return type() == GDB || type() == XDB || type() == PYDB || 
  434.         has_handler_command();
  435.     }
  436.  
  437.     // True if debugger can set conditions on breakpoints
  438.     bool has_condition_command() const
  439.     {
  440.     return type() == GDB || type() == PYDB;
  441.     }
  442.  
  443.     // True if debugger can delete breakpoints by number
  444.     bool has_delete_command() const
  445.     {
  446.     return type() == GDB || type() == XDB || 
  447.         type() == DBX || type() == PYDB;
  448.     }
  449.  
  450.     // True if debugger has volatile breakpoints (i.e. breakpoints may
  451.     // change at any time)
  452.     bool has_volatile_breakpoints() const
  453.     {
  454.     return type() == GDB || type() == XDB || 
  455.         type() == DBX || type() == PYDB || type() == PERL;
  456.     }
  457.  
  458.     // True if debugger supports I/O redirection
  459.     bool has_redirection() const
  460.     {
  461.     return type() == GDB || type() == XDB || type() == DBX;
  462.     }
  463.  
  464.     // True if debugger supports assignments
  465.     bool has_assign_command() const
  466.     {
  467.     return type() == GDB || type() == XDB || type() == DBX || 
  468.         type() == PYDB || type() == PERL;
  469.     }
  470.  
  471.     // True if debugger supports calling system functions
  472.     bool has_system_calls() const
  473.     {
  474.     return type() == GDB || type() == XDB || type() == DBX || 
  475.         type() == PERL;
  476.     }
  477.  
  478.     // True if debugger supports loading and examining executables
  479.     bool has_exec_files() const
  480.     {
  481.     return type() == GDB || type() == XDB || type() == DBX;
  482.     }
  483.  
  484.     // True if debugger supports loading and examining classes
  485.     bool has_classes() const
  486.     {
  487.     return type() == JDB;
  488.     }
  489.  
  490.     // True if debugger supports loading and examining core files
  491.     bool has_core_files() const
  492.     {
  493.     return type() == GDB || type() == XDB || type() == DBX;
  494.     }
  495.  
  496.     // True if debugger supports separate processes (attach, detach)
  497.     bool has_processes() const
  498.     {
  499.     return type() == GDB || type() == XDB || type() == DBX;
  500.     }
  501.  
  502.     // True if debugger supports `cd'
  503.     bool has_cd_command() const
  504.     {
  505.     return type() == GDB || type() == XDB || 
  506.         type() == DBX || type() == PYDB || type() == PERL;
  507.     }
  508.  
  509.     // True if debugger supports `shell'
  510.     bool has_shell_command() const
  511.     {
  512.     return type() == GDB || type() == XDB || type() == DBX || 
  513.         type() == PERL;
  514.     }
  515.  
  516.     // True if debugger has numbered breakpoints
  517.     bool has_numbered_breakpoints()
  518.     {
  519.     return type() == GDB || type() == DBX || type() == XDB || 
  520.         type() == PYDB;
  521.     }
  522.  
  523.     // True if debugger supports temporary breakpoints
  524.     bool has_temporary_breakpoints() const
  525.     {
  526.     return type() == GDB || type() == XDB || type() == PYDB || 
  527.         has_when_command();
  528.     }
  529.  
  530.     // True if debugger supports breakpoint conditions
  531.     bool has_breakpoint_conditions() const
  532.     {
  533.     return type() == GDB || type() == XDB || 
  534.         type() == DBX || type() == PYDB || type() == PERL;
  535.     }
  536.  
  537.     // True if debugger has typed pointers, as in `(TYPE)0x0'
  538.     bool has_typed_pointers() const
  539.     {
  540.     return type() == GDB || type() == JDB;
  541.     }
  542.  
  543.     // True if debugger has typed structs, as in `(TYPE)0x1234 { ... }'
  544.     bool has_typed_structs() const
  545.     {
  546.     return type() == JDB;
  547.     }
  548.  
  549.     // True if debugger uses `(scalar = ...)' for out-of-range enumerations
  550.     bool has_scalars() const
  551.     {
  552.     return type() == DBX;
  553.     }
  554.  
  555.     // True if debugger can use quotes for complex expressions
  556.     bool has_quotes() const
  557.     {
  558.     return type() == GDB;
  559.     }
  560.  
  561.     // True if `display X' automatically prints X
  562.     bool display_prints_values() const
  563.     {
  564.     return type() == GDB || type() == PYDB;
  565.     }
  566.  
  567.     // True if debugger can enable displays
  568.     bool has_enable_display_command() const
  569.     {
  570.     return type() == GDB || type() == PYDB;
  571.     }
  572.     bool has_disable_display_command() const
  573.     {
  574.     return has_enable_display_command();
  575.     }
  576.  
  577.     // True if debugger has numbered displays
  578.     bool has_numbered_displays()
  579.     {
  580.     return type() == GDB || type() == PYDB;
  581.     }
  582.  
  583.     // True if debugger wants displays separated by `,'
  584.     bool wants_display_comma() const
  585.     {
  586.     return type() == DBX;
  587.     }
  588.  
  589.     // True if debugger has `info displays' command
  590.     bool has_info_display_command() const
  591.     {
  592.     return display_command() != "";
  593.     }
  594.  
  595.     // True if `undisplay' redisplays remaining values
  596.     bool has_redisplaying_undisplay() const
  597.     {
  598.     return type() == DBX;
  599.     }
  600.  
  601.     // True if debugger supports breakpoint conditions
  602.     bool has_conditions() const
  603.     {
  604.     return has_condition_command() || type() != JDB;
  605.     }
  606.  
  607.     // True if debugger can disable breakpoints
  608.     bool can_disable() const
  609.     {
  610.     return has_disable_command() || has_conditions();
  611.     }
  612.  
  613.     // True if debugger can enable breakpoints
  614.     bool can_enable() const
  615.     {
  616.     return has_enable_command() || has_conditions();
  617.     }
  618.  
  619.     // True if a minimum indent is required.  This is true for
  620.     // scripting languages.
  621.     bool requires_script_indent() const
  622.     {
  623.     return program_language() == LANGUAGE_PERL ||
  624.         program_language() == LANGUAGE_PYTHON;
  625.     }
  626.  
  627.     // True if DBX output is to be processed verbatim
  628.     bool verbatim() const        { return _verbatim; }
  629.     bool verbatim(bool val)      { return _verbatim = val; }
  630.  
  631.     // True if we are recording commands
  632.     bool recording() const         { return _recording; }
  633.     bool recording(bool val);
  634.  
  635.     // True if checking for echos
  636.     bool detect_echos() const        { return _detect_echos; }
  637.     bool detect_echos(bool val)      { return _detect_echos = val; }
  638.  
  639.     // Several commands
  640.                                     // GDB command
  641.                             // -----------------------
  642.     string print_command(string expr = "",          // print|output EXP
  643.              bool internal = true) const;
  644.     string assign_command(string var,               // set variable VAR = EXPR
  645.               string expr) const;
  646.     string display_command(string expr = "") const; // display EXPR
  647.     string where_command(int count = 0) const;        // where COUNT
  648.     string pwd_command() const;                        // pwd
  649.     string frame_command(int number) const;         // frame NUMBER
  650.     string relative_frame_command(int offset) const;// up|down OFFSET
  651.     string frame_command() const;                   // frame
  652.     string func_command() const;                    // func
  653.     string echo_command(string text) const;         // echo TEXT
  654.     string whatis_command(string expr) const;       // whatis EXPR
  655.     string dereferenced_expr(string expr) const;    // *EXPR
  656.     string address_expr(string expr) const;         // &EXPR
  657.     string index_expr(string expr, string index) const; // EXPR[INDEX]
  658.     int default_index_base() const;                 // 0 in C, else 1
  659.     string member_separator() const;                // " = " in C
  660.  
  661.     string info_locals_command() const;                // info locals
  662.     string info_args_command() const;                // info args
  663.     string info_display_command() const;        // info display
  664.     string disassemble_command(string start, string end = "") const;
  665.                                                     // disassemble START END
  666.     string make_command(string target) const;       // make TARGET
  667.     string jump_command(string pc) const;           // jump PC
  668.     string regs_command(bool all = true) const;        // info registers
  669.     string watch_command(string expr, WatchMode w = WATCH_CHANGE) const;
  670.                                     // watch EXPR
  671.     string kill_command() const;                    // kill
  672.     string enable_command(string bp = "") const;    // enable BP
  673.     string disable_command(string bp = "") const;   // disable BP
  674.     string delete_command(string bp = "") const;    // delete BP
  675.     string ignore_command(string bp, int count) const; 
  676.                                                     // ignore BP COUNT
  677.     string condition_command(string bp, string expr) const; 
  678.                                     // cond BP EXPR
  679.     string shell_command(string cmd) const;        // shell CMD
  680.     string debug_command(string file = "",          // file FILE
  681.              string args = "") const;
  682.     string signal_command(int sig) const;           // signal SIG
  683.     string nop_command(string comment = "") const;  // # comment
  684.  
  685.     // Bring VALUE of VAR into a form understood by DDD
  686.     void munch_value(string& value, const string& var) const;
  687.  
  688.     // Split a Perl variable into its components
  689.     static void split_perl_var(const string& var,
  690.                    string& prefix, string& package, string& name);
  691.  
  692.     // Run program with given arguments
  693.     string run_command(string args) const;        // set args ARGS\nrun
  694.  
  695.     // Run program, re-using current arguments
  696.     string rerun_command() const;                   // run
  697.  
  698.     // Default history file
  699.     string history_file() const;                    // GDB: ~/.gdb_history
  700.  
  701.     // Send DATA to process
  702.     virtual int write(const char *data, int length)
  703.     {
  704.     last_written = string(data, length);
  705.     echoed_characters = 0;
  706.     return TTYAgent::write(data, length);
  707.     }
  708.  
  709.     // Custom function
  710.     int write(const string& data)
  711.     {
  712.     return write(data.chars(), data.length());
  713.     }
  714.  
  715.     bool ends_with_prompt(const string& answer);
  716.     bool ends_with_secondary_prompt(const string& answer);
  717.  
  718. private:
  719.     bool questions_waiting;
  720.  
  721.     void* _qu_data;
  722.  
  723.     int     qu_index;
  724.     int    _qu_count;
  725.     StringArray cmd_array;
  726.     StringArray complete_answers;
  727.     VoidArray _qu_datas;
  728.     void*   _qa_data;
  729.  
  730.     OAProc   _on_answer;
  731.     OACProc  _on_answer_completion;
  732.     OQCProc  _on_question_completion;
  733.     OQACProc _on_qu_array_completion;
  734.  
  735.     void    init_qu_array (const StringArray& cmds,
  736.                const VoidArray& qu_datas,
  737.                int      qu_count,
  738.                OQACProc on_qu_array_completion,
  739.                void*    qa_data);
  740.  
  741.     string requires_reply(const string& answer);
  742.  
  743.     void cut_off_prompt(string& answer) const;
  744.     void strip_dbx_comments(string& answer) const;
  745.     void strip_control(string& answer) const;
  746.  
  747.     void normalize_answer(string& answer) const;
  748.     void normalize_address(string& addr) const;
  749.  
  750.     void handle_echo(string& answer);
  751.     void handle_more(string& answer);
  752.     void handle_reply(string& answer);
  753.     void handle_input(string& answer);
  754.     void handle_died();
  755.  
  756. protected:
  757.     string complete_answer;
  758.  
  759.     static void InputHP  (Agent *, void *, void *);
  760.     static void PanicHP  (Agent *, void *, void *);
  761.     static void StrangeHP(Agent *, void *, void *);
  762.     static void DiedHP   (Agent *, void *, void *);
  763.  
  764.     static void traceInputHP (Agent *, void *, void *);
  765.     static void traceOutputHP(Agent *, void *, void *);
  766.     static void traceErrorHP (Agent *, void *, void *);
  767. };
  768.  
  769. #endif // _DDD_GDBAgent_h
  770. // DON'T ADD ANYTHING BEHIND THIS #endif
  771.