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.C < prev    next >
Encoding:
C/C++ Source or Header  |  1998-11-24  |  60.1 KB  |  2,778 lines
  1. // $Id: GDBAgent.C,v 1.181 1998/11/24 15:07:03 zeller Exp $
  2. // Communicate with separate GDB process
  3.  
  4. // Copyright (C) 1995-1998 Technische Universitaet Braunschweig, Germany.
  5. // Written by Dorothea Luetkehaus <luetke@ips.cs.tu-bs.de>
  6. // and Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  7. // 
  8. // This file is part of DDD.
  9. // 
  10. // DDD is free software; you can redistribute it and/or
  11. // modify it under the terms of the GNU General Public
  12. // License as published by the Free Software Foundation; either
  13. // version 2 of the License, or (at your option) any later version.
  14. // 
  15. // DDD is distributed in the hope that it will be useful,
  16. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18. // See the GNU General Public License for more details.
  19. // 
  20. // You should have received a copy of the GNU General Public
  21. // License along with DDD -- see the file COPYING.
  22. // If not, write to the Free Software Foundation, Inc.,
  23. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24. // 
  25. // DDD is the data display debugger.
  26. // For details, see the DDD World-Wide-Web page, 
  27. // `http://www.cs.tu-bs.de/softech/ddd/',
  28. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  29.  
  30. char GDBAgent_rcsid[] =
  31.     "$Id: GDBAgent.C,v 1.181 1998/11/24 15:07:03 zeller Exp $";
  32.  
  33. // From: hobson@pipper.enet.dec.com
  34. // Subject: And the Twelve Bugs of Christmas ....
  35. // Keywords: topical, heard it, computers, chuckle, originally
  36. //           appeared in fourth quarter, 1992
  37. // Newsgroups: rec.humor.funny.reruns
  38. // Date: Tue, 23 Dec 97 13:20:02 EST
  39. // 
  40. // For the first bug of Christmas, my manager said to me
  41. //      See if they can do it again.
  42. // 
  43. // For the second bug of Christmas, my manager said to me
  44. //      Ask them how they did it and
  45. //      See if they can do it again.
  46. // 
  47. // For the third bug of Christmas, my manager said to me
  48. //      Try to reproduce it
  49. //      Ask them how they did it and
  50. //      See if they can do it again.
  51. // 
  52. // For the fourth bug of Christmas, my manager said to me
  53. //      Run with the debugger
  54. //      Try to reproduce it
  55. //      Ask them how they did it and
  56. //      See if they can do it again.
  57. // 
  58. // For the fifth bug of Christmas, my manager said to me
  59. //      Ask for a dump
  60. //      Run with the debugger
  61. //      Try to reproduce it
  62. //      Ask them how they did it and
  63. //      See if they can do it again.
  64. // 
  65. // For the sixth bug of Christmas, my manager said to me
  66. //      Reinstall the software
  67. //      Ask for a dump
  68. //      Run with the debugger
  69. //      Try to reproduce it
  70. //      Ask them how they did it and
  71. //      See if they can do it again.
  72. // 
  73. // For the seventh bug of Christmas, my manager said to me
  74. //      Say they need an upgrade
  75. //      Reinstall the software
  76. //      Ask for a dump
  77. //      Run with the debugger
  78. //      Try to reproduce it
  79. //      Ask them how they did it and
  80. //      See if they can do it again.
  81. // 
  82. // For the eighth bug of Christmas, my manager said to me
  83. //      Find a way around it
  84. //      Say they need an upgrade
  85. //      Reinstall the software
  86. //      Ask for a dump
  87. //      Run with the debugger
  88. //      Try to reproduce it
  89. //      Ask them how they did it and
  90. //      See if they can do it again.
  91. // 
  92. // For the ninth bug of Christmas, my manager said to me
  93. //      Blame it on the hardware
  94. //      Find a way around it
  95. //      Say they need an upgrade
  96. //      Reinstall the software
  97. //      Ask for a dump
  98. //      Run with the debugger
  99. //      Try to reproduce it
  100. //      Ask them how they did it and
  101. //      See if they can do it again.
  102. // 
  103. // For the tenth bug of Christmas, my manager said to me
  104. //      Change the documentation
  105. //      Blame it on the hardware
  106. //      Find a way around it
  107. //      Say they need an upgrade
  108. //      Reinstall the software
  109. //      Ask for a dump
  110. //      Run with the debugger
  111. //      Try to reproduce it
  112. //      Ask them how they did it and
  113. //      See if they can do it again.
  114. // 
  115. // For the eleventh bug of Christmas, my manager said to me
  116. //      Say it's not supported
  117. //      Change the documentation
  118. //      Blame it on the hardware
  119. //      Find a way around it
  120. //      Say they need an upgrade
  121. //      Reinstall the software
  122. //      Ask for a dump
  123. //      Run with the debugger
  124. //      Try to reproduce it
  125. //      Ask them how they did it and
  126. //      See if they can do it again.
  127. // 
  128. // For the twelfth bug of Christmas, my manager said to me
  129. //      Tell them it's a feature
  130. //      Say it's not supported
  131. //      Change the documentation
  132. //      Blame it on the hardware
  133. //      Find a way around it
  134. //      Say they need an upgrade
  135. //      Reinstall the software
  136. //      Ask for a dump
  137. //      Run with the debugger
  138. //      Try to reproduce it
  139. //      Ask them how they did it and
  140. //      See if they can do it again.
  141.  
  142. #ifdef __GNUG__
  143. #pragma implementation
  144. #endif
  145.  
  146. //-----------------------------------------------------------------------------
  147. // GDBAgent implementation
  148. //-----------------------------------------------------------------------------
  149.  
  150. #include "GDBAgent.h"
  151. #include "cook.h"
  152. #include "ddd.h"
  153. #include "string-fun.h"
  154. #include "regexps.h"
  155. #include "index.h"
  156. #include "isid.h"
  157. #include "home.h"
  158. #include "value-read.h"        // read_token
  159.  
  160. #include <stdlib.h>
  161. #include <iostream.h>
  162. #include <fstream.h>
  163. #include <ctype.h>
  164.  
  165. #ifndef EXIT_SUCCESS
  166. #define EXIT_SUCCESS 0
  167. #endif
  168.  
  169. #ifndef EXIT_FAILURE
  170. #define EXIT_FAILURE 1
  171. #endif
  172.  
  173.  
  174. DEFINE_TYPE_INFO_1(GDBAgent, TTYAgent);
  175.  
  176.  
  177. //-----------------------------------------------------------------------------
  178. // Construction and setup
  179. //-----------------------------------------------------------------------------
  180.  
  181. // Constructor
  182. GDBAgent::GDBAgent (XtAppContext app_context,
  183.             const string& gdb_call,
  184.             DebuggerType tp,
  185.             unsigned int nTypes)
  186.     : TTYAgent (app_context, gdb_call, nTypes),
  187.       state(BusyOnInitialCmds),
  188.       _type(tp),
  189.       _user_data(0),
  190.       _has_frame_command(tp == GDB || tp == XDB),
  191.       _has_func_command(tp == DBX),
  192.       _has_run_io_command(false),
  193.       _has_print_r_option(false),
  194.       _has_output_command(false),
  195.       _has_where_h_option(false),
  196.       _has_display_command(tp == GDB || tp == DBX || tp == PYDB),
  197.       _has_clear_command(tp == GDB || tp == DBX || tp == JDB || tp == PERL),
  198.       _has_handler_command(false),
  199.       _has_pwd_command(tp == GDB || tp == DBX || tp == PYDB || tp == PERL),
  200.       _has_setenv_command(tp == DBX),
  201.       _has_edit_command(tp == DBX),
  202.       _has_make_command(tp == GDB || tp == DBX || tp == PERL),
  203.       _has_jump_command(tp == GDB || tp == DBX || tp == XDB),
  204.       _has_regs_command(tp == GDB),
  205.       _has_watch_command(0),    // see below
  206.       _has_named_values(tp == GDB || tp == DBX || tp == JDB),
  207.       _has_when_command(tp == DBX),
  208.       _has_when_semicolon(tp == DBX),
  209.       _wants_delete_comma(false),
  210.       _has_err_redirection(tp == GDB || tp == DBX || tp == XDB),
  211.       _has_givenfile_command(false),
  212.       _has_cont_sig_command(false),
  213.       _has_examine_command(tp == GDB || tp == DBX),
  214.       _has_rerun_command(tp == DBX),
  215.       _rerun_clears_args(false),
  216.       _program_language((tp == JDB) ? LANGUAGE_JAVA :
  217.             (tp == PYDB) ? LANGUAGE_PYTHON : 
  218.             (tp == PERL) ? LANGUAGE_PERL : 
  219.             LANGUAGE_C),
  220.       _verbatim(false),
  221.       _recording(false),
  222.       _detect_echos(true),
  223.       last_prompt(""),
  224.       last_written(""),
  225.       echoed_characters(-1),
  226.       questions_waiting(false),
  227.       _qu_data(0),
  228.       qu_index(0),
  229.       _qu_count(0),
  230.       cmd_array(0),
  231.       complete_answers(0),
  232.       _qu_datas(0),
  233.       _qa_data(0),
  234.       _on_answer(0),
  235.       _on_answer_completion(0),
  236.       _on_question_completion(0),
  237.       _on_qu_array_completion(0),
  238.       complete_answer("")
  239. {
  240.     // Suppress default error handlers
  241.     removeAllHandlers(Panic);
  242.     removeAllHandlers(Strange);
  243.     removeAllHandlers(Died);
  244.  
  245.     // Add own handlers
  246.     addHandler(Panic,   PanicHP);
  247.     addHandler(Strange, StrangeHP);
  248.     addHandler(Died,    DiedHP);
  249.     addHandler(Input,   InputHP);
  250.  
  251.     // Add trace handlers
  252.     addHandler(Input,  traceInputHP);     // GDB => DDD
  253.     addHandler(Output, traceOutputHP);    // DDD => GDB
  254.     addHandler(Error,  traceErrorHP);     // GDB Errors => DDD
  255.  
  256.     // Setup watch mode
  257.     if (type() == GDB)
  258.     _has_watch_command = WATCH_CHANGE | WATCH_READ | WATCH_WRITE;
  259.     else if (type() == DBX)
  260.     _has_watch_command = WATCH_CHANGE;
  261.     else
  262.     _has_watch_command = 0;
  263. }
  264.  
  265.  
  266. // Copy constructor
  267. GDBAgent::GDBAgent(const GDBAgent& gdb)
  268.     : TTYAgent(gdb),
  269.       state(gdb.state),
  270.       _type(gdb.type()),
  271.       _user_data(0),
  272.       _has_frame_command(gdb.has_frame_command()),
  273.       _has_func_command(gdb.has_func_command()),
  274.       _has_run_io_command(gdb.has_run_io_command()),
  275.       _has_print_r_option(gdb.has_print_r_option()),
  276.       _has_output_command(gdb.has_output_command()),
  277.       _has_where_h_option(gdb.has_where_h_option()),
  278.       _has_display_command(gdb.has_display_command()),
  279.       _has_clear_command(gdb.has_clear_command()),
  280.       _has_handler_command(gdb.has_handler_command()),
  281.       _has_pwd_command(gdb.has_pwd_command()),
  282.       _has_setenv_command(gdb.has_setenv_command()),
  283.       _has_edit_command(gdb.has_edit_command()),
  284.       _has_make_command(gdb.has_make_command()),
  285.       _has_jump_command(gdb.has_jump_command()),
  286.       _has_regs_command(gdb.has_regs_command()),
  287.       _has_watch_command(gdb.has_watch_command()),
  288.       _has_named_values(gdb.has_named_values()),
  289.       _has_when_command(gdb.has_when_command()),
  290.       _has_when_semicolon(gdb.has_when_semicolon()),
  291.       _wants_delete_comma(gdb.wants_delete_comma()),
  292.       _has_err_redirection(gdb.has_err_redirection()),
  293.       _has_givenfile_command(gdb.has_givenfile_command()),
  294.       _has_cont_sig_command(gdb.has_cont_sig_command()),
  295.       _has_examine_command(gdb.has_examine_command()),
  296.       _has_rerun_command(gdb.has_rerun_command()),
  297.       _rerun_clears_args(gdb.rerun_clears_args()),
  298.       _program_language(gdb.program_language()),
  299.       _verbatim(gdb.verbatim()),
  300.       _recording(gdb.recording()),
  301.       _detect_echos(gdb.detect_echos()),
  302.       last_prompt(""),
  303.       last_written(""),
  304.       echoed_characters(-1),
  305.       questions_waiting(false),
  306.       _qu_data(0),
  307.       qu_index(0),
  308.       _qu_count(0),
  309.       cmd_array(0),
  310.       complete_answers(0),
  311.       _qu_datas(0),
  312.       _qa_data(0),
  313.       _on_answer(0),
  314.       _on_answer_completion(0),
  315.       _on_question_completion(0),
  316.       _on_qu_array_completion(0),
  317.       complete_answer("")
  318. {}
  319.  
  320. // Return default title
  321. string GDBAgent::title() const
  322. {
  323.     switch (type())
  324.     {
  325.     case GDB:
  326.     return "GDB";
  327.     case DBX:
  328.     return "DBX";
  329.     case XDB:
  330.     return "XDB";
  331.     case JDB:
  332.     return "JDB";
  333.     case PYDB:
  334.     return "PYDB";
  335.     case PERL:
  336.     return "Perl";
  337.     }
  338.  
  339.     return "debugger";
  340. }
  341.  
  342. // Trace communication
  343. void GDBAgent::trace(char *prefix, void *call_data) const
  344. {
  345.     DataLength* dl    = (DataLength *) call_data;
  346.     string s(dl->data, dl->length);
  347.  
  348.     bool s_ends_with_nl = false;
  349.     if (s.length() > 0 && s[s.length() - 1] == '\n')
  350.     {
  351.     s_ends_with_nl = true;
  352.     s = s.before(int(s.length() - 1));
  353.     }
  354.  
  355.     s = quote(s);
  356.     string nl = string("\\n\"\n") + replicate(' ', strlen(prefix)) + "\"";
  357.     s.gsub("\\n", nl);
  358.  
  359.     if (s_ends_with_nl)
  360.     s(s.length() - 1, 0) = "\\n";
  361.  
  362.     dddlog << prefix << s << '\n';
  363.     dddlog.flush();
  364. }
  365.     
  366. void GDBAgent::traceInputHP(Agent *source, void *, void *call_data)
  367. {
  368.     GDBAgent *gdb = ptr_cast(GDBAgent, source);
  369.     if (gdb != 0)
  370.     gdb->trace("<- ", call_data);
  371. }
  372.  
  373. void GDBAgent::traceOutputHP(Agent *source, void *, void *call_data)
  374. {
  375.     GDBAgent *gdb = ptr_cast(GDBAgent, source);
  376.     if (gdb != 0)
  377.     gdb->trace("-> ", call_data);
  378. }
  379.  
  380. void GDBAgent::traceErrorHP(Agent *source, void *, void *call_data)
  381. {
  382.     GDBAgent *gdb = ptr_cast(GDBAgent, source);
  383.     if (gdb != 0)
  384.     gdb->trace("<= ", call_data);
  385. }
  386.  
  387. // Start GDBAgent
  388. void GDBAgent::do_start (OAProc  on_answer,
  389.              OACProc on_answer_completion,
  390.              void*   user_data)
  391. {
  392.     _on_answer = on_answer;
  393.     _on_answer_completion = on_answer_completion;
  394.     _user_data = user_data;
  395.     TTYAgent::start();
  396.     callHandlers(ReadyForQuestion, (void *)false);
  397.     callHandlers(ReadyForCmd, (void *)false);
  398.     callHandlers(LanguageChanged, (void *)this);
  399. }
  400.  
  401. // Start with some extra commands
  402. void GDBAgent::start_plus (OAProc   on_answer,
  403.                OACProc  on_answer_completion,
  404.                void*    user_data,
  405.                const StringArray& cmds,
  406.                const VoidArray& qu_datas,
  407.                int      qu_count,
  408.                OQACProc on_qu_array_completion,
  409.                void*    qa_data)
  410. {
  411.     state = BusyOnInitialCmds;
  412.  
  413.     if (qu_count > 0) {
  414.     questions_waiting = true;
  415.     init_qu_array(cmds, qu_datas, qu_count, 
  416.               on_qu_array_completion, qa_data);
  417.     }
  418.  
  419.     do_start(on_answer, on_answer_completion, user_data);
  420. }
  421.  
  422. // Destructor
  423. GDBAgent::~GDBAgent ()
  424. {
  425.     shutdown();
  426. }
  427.  
  428.  
  429.  
  430. //-----------------------------------------------------------------------------
  431. // Command sending
  432. //-----------------------------------------------------------------------------
  433.  
  434. // Send CMD to GDB, associated with USER_DATA.  Return false iff busy.
  435. bool GDBAgent::send_user_cmd(string cmd, void *user_data)  // without '\n'
  436. {
  437.     if (user_data)
  438.     _user_data = user_data;
  439.  
  440.     switch (state) {
  441.     case ReadyWithPrompt:
  442.     case BusyOnInitialCmds:
  443.  
  444.     // Process CMD
  445.     state = BusyOnCmd;
  446.     complete_answer = "";
  447.     callHandlers(ReadyForQuestion, (void *)false);
  448.     cmd += '\n';
  449.     write(cmd);
  450.     flush();
  451.  
  452.     return true;
  453.  
  454.     case BusyOnQuestion:
  455.     case BusyOnQuArray:
  456.     case BusyOnCmd:
  457.     break;
  458.     }
  459.  
  460.     return false;
  461. }
  462.  
  463. // Send CMD to GDB (unconditionally), associated with USER_DATA.
  464. bool GDBAgent::send_user_ctrl_cmd(string cmd, void *user_data)
  465. {
  466.     if (user_data)
  467.     _user_data = user_data;
  468.  
  469.     // Upon ^D, GDB is no more in state to receive commands.
  470.     // Expect a new prompt to appear.
  471.     if (cmd == '\004' && state == ReadyWithPrompt)
  472.     {
  473.     state = BusyOnCmd;
  474.     complete_answer = "";
  475.     }
  476.  
  477.     write(cmd);
  478.     flush();
  479.     return true;
  480. }
  481.  
  482. // Send command array CMDS to GDB, associated with QU_DATAS.
  483. bool GDBAgent::send_user_cmd_plus (const StringArray& cmds,
  484.                    const VoidArray& qu_datas,
  485.                    int      qu_count,
  486.                    OQACProc on_qu_array_completion,
  487.                    void*    qa_data,
  488.                    string   user_cmd,
  489.                    void* user_data)
  490. {
  491.     if (state != ReadyWithPrompt) 
  492.     return false;
  493.  
  494.     if (user_data)
  495.     _user_data = user_data;
  496.     if (qu_count > 0)
  497.     {
  498.     questions_waiting = true;
  499.     init_qu_array(cmds, qu_datas, qu_count,
  500.               on_qu_array_completion, qa_data);
  501.     }
  502.  
  503.     // Process command
  504.     state = BusyOnCmd;
  505.     complete_answer = "";
  506.     callHandlers(ReadyForQuestion, (void *)false);
  507.     user_cmd += '\n';
  508.     write(user_cmd);
  509.     flush();
  510.  
  511.     return true;
  512. }
  513.  
  514. // Send CMD to GDB; upon completion, call ON_QUESTION_COMPLETION with QU_DATA
  515. bool GDBAgent::send_question (string  cmd,
  516.                   OQCProc on_question_completion,
  517.                   void*   qu_data)
  518. {
  519.     if (state != ReadyWithPrompt) 
  520.     return false;
  521.  
  522.     state = BusyOnQuestion;
  523.     callHandlers(ReadyForQuestion, (void *)false);
  524.     callHandlers(ReadyForCmd, (void *)false);
  525.  
  526.     _on_question_completion = on_question_completion;
  527.     _qu_data = qu_data;
  528.     complete_answer = "";
  529.  
  530.     cmd += '\n';
  531.     write(cmd);
  532.     flush();
  533.  
  534.     return true;
  535. }
  536.  
  537. // Send CMDS to GDB; upon completion, call ON_QU_ARRAY_COMPLETION with QU_DATAS
  538. bool GDBAgent::send_qu_array (const StringArray& cmds,
  539.                   const VoidArray& qu_datas,
  540.                   int      qu_count,
  541.                   OQACProc on_qu_array_completion,
  542.                   void*    qa_data)
  543. {
  544.     if (qu_count == 0)
  545.     return true;
  546.     if (state != ReadyWithPrompt)
  547.     return false;
  548.  
  549.     state = BusyOnQuArray;
  550.     callHandlers(ReadyForQuestion, (void *)false);
  551.     callHandlers(ReadyForCmd, (void *)false);
  552.  
  553.     init_qu_array(cmds, qu_datas, qu_count, on_qu_array_completion, qa_data);
  554.     
  555.     // Send first question
  556.     write(cmd_array[0]);
  557.     flush();
  558.  
  559.     return true;
  560. }
  561.  
  562. // Initialize GDB question array
  563. void GDBAgent::init_qu_array (const StringArray& cmds,
  564.                   const VoidArray& qu_datas,
  565.                   int      qu_count,
  566.                   OQACProc on_qu_array_completion,
  567.                   void*    qa_data)
  568. {
  569.     _on_qu_array_completion = on_qu_array_completion;
  570.     qu_index  = 0;
  571.     _qu_count = qu_count;
  572.     _qa_data  = qa_data;
  573.  
  574.     StringArray empty_s;
  575.     VoidArray   empty_v;
  576.  
  577.     complete_answers = empty_s;
  578.     cmd_array        = empty_s;
  579.     _qu_datas        = empty_v;
  580.     for (int i = 0; i < qu_count; i++)
  581.     {
  582.     complete_answers += "";
  583.     cmd_array        += cmds[i] + '\n';
  584.     _qu_datas        += qu_datas[i];
  585.     }
  586. }
  587.  
  588.  
  589. //-----------------------------------------------------------------------------
  590. // Prompt Recognition
  591. //-----------------------------------------------------------------------------
  592.  
  593. // Return true iff ANSWER ends with primary prompt.
  594. bool GDBAgent::ends_with_prompt (const string& ans)
  595. {
  596.     string answer = ans;
  597.     strip_control(answer);
  598.  
  599.     switch (type())
  600.     {
  601.     case GDB:
  602.     // GDB reads in breakpoint commands using a `>' prompt
  603.     if (recording() && answer.contains('>', -1))
  604.     {
  605.         last_prompt = ">";
  606.         return true;
  607.     }
  608.  
  609.     // In annotation level 2, GDB `annotates' its prompt.
  610.     if (answer.contains("\032\032prompt\n", -1))
  611.         return true;
  612.  
  613.     // FALL THROUGH
  614.     case DBX:
  615.     case PYDB:
  616.     {
  617.     // Any line ending in `(gdb) ' or `(dbx) ' is a prompt.
  618.     int i = answer.length() - 1;
  619.     if (i < 0 || answer[i] != ' ')
  620.         return false;
  621.  
  622.     while (i >= 0 && answer[i] != '\n' && answer[i] != '(')
  623.         i--;
  624.     if (i < 0 || answer[i] != '(')
  625.         return false;
  626.  
  627.     string possible_prompt = answer.from(i);
  628. #if RUNTIME_REGEX
  629.     // Marc Lepage <mlepage@kingston.hummingbird.com> says that
  630.     // DBX on Solaris 2.5 has a prompt like `(dbx N) '.  We're
  631.     // liberal here and allow anything in the form `(NAME) ',
  632.     // where the first word in NAME must contain a `db'.
  633.     static regex rxprompt("[(][^ )]*db[^)]*[)] ");
  634. #endif
  635.     if (possible_prompt.matches(rxprompt))
  636.     {
  637.         last_prompt = possible_prompt;
  638.         recording(false);
  639.         return true;
  640.     }
  641.     return false;
  642.     }
  643.  
  644.     case XDB:
  645.     {
  646.     // Any line equal to `>' is a prompt.
  647.     unsigned beginning_of_line = answer.index('\n', -1) + 1;
  648.     if (beginning_of_line < answer.length()
  649.         && answer.length() > 0
  650.         && answer[beginning_of_line] == '>')
  651.     {
  652.         last_prompt = ">";
  653.         return true;
  654.     }
  655.     return false;
  656.     }
  657.  
  658.     case PERL:
  659.     {
  660.     // Any line ending in `DB<N> ' is a prompt.
  661.     // Since N does not make sense in DDD, we use `DB<> ' instead.
  662. #if RUNTIME_REGEX
  663.     static regex rxperlprompt("[ \t]*DB<+[0-9]*>+[ \t]*");
  664. #endif
  665.  
  666.     int i = answer.length() - 1;
  667.     if (i < 1 || answer[i] != ' ' || answer[i - 1] != '>')
  668.         return false;
  669.  
  670.     while (i > 0 && answer[i - 1] != '\n' && !answer.contains("DB", i))
  671.         i--;
  672.  
  673.     string possible_prompt = answer.from(i);
  674.     if (possible_prompt.matches(rxperlprompt))
  675.     {
  676.         last_prompt = "DB<> ";
  677.         return true;
  678.     }
  679.     return false;
  680.     }
  681.  
  682.     case JDB:
  683.     {
  684.     // JDB prompts using "> " or "THREAD[DEPTH] ".  All these
  685.     // prompts may also occur asynchronously.
  686.  
  687. #if RUNTIME_REGEX
  688.     // Threaded prompt: "THREAD[DEPTH] "
  689.     static regex rxjdbprompt        
  690.         ("[a-zA-Z][a-zA-Z0-9 ]*[a-zA-Z0-9][[][1-9][0-9]*[]] ");
  691.     // Same, but in reverse
  692.     static regex rxjdbprompt_reverse
  693.         (" []][0-9]*[1-9][[][a-zA-Z0-9][a-zA-Z0-9 ]*[a-zA-Z]");
  694.     // Non-threaded prompt: "[DEPTH] " or "> "
  695.     static regex rxjdbprompt_nothread
  696.         ("(>|[[][1-9][0-9]*[]]) ");
  697. #endif
  698.  
  699.     // Check for threaded prompt at the end of the last line
  700.     string reverse_answer = reverse(answer);
  701.     int match_len = rxjdbprompt_reverse.match(reverse_answer.chars(), 
  702.                           reverse_answer.length(), 0);
  703.     if (match_len > 0)
  704.     {
  705.         last_prompt = reverse(reverse_answer.at(0, match_len));
  706.         return true;
  707.     }
  708.  
  709.     // Check for non-threaded prompt as the last line
  710.     int beginning_of_line = answer.index('\n', -1) + 1;
  711.     string possible_prompt = ((string &) answer).from(beginning_of_line);
  712.     if (possible_prompt.matches(rxjdbprompt_nothread))
  713.     {
  714.         last_prompt = possible_prompt;
  715.         return true;
  716.     }
  717.  
  718.     // Check for threaded prompt at the beginning of each line
  719.     int last_nl = answer.length() - 1;
  720.     while (last_nl >= 0)
  721.     {
  722.         last_nl = answer.index('\n', last_nl - answer.length());
  723.         int beginning_of_line = last_nl + 1;
  724.  
  725.         match_len = rxjdbprompt.match(answer.chars(), answer.length(), 
  726.                       beginning_of_line);
  727.         if (match_len > 0)
  728.         {
  729.         int i = beginning_of_line + match_len;
  730.         while (i < int(answer.length()) && isspace(answer[i]))
  731.             i++;
  732.         if (i < int(answer.length()) && answer[i] == '=')
  733.         {
  734.             // This is no prompt, but something like `dates[1] = 33'.
  735.         }
  736.         else
  737.         {
  738.             last_prompt = answer.at(beginning_of_line, match_len);
  739.             return true;
  740.         }
  741.         }
  742.  
  743.         last_nl--;
  744.     }
  745.  
  746.     return false;
  747.     }
  748.     }
  749.  
  750.     return false;        // Never reached
  751. }
  752.  
  753.  
  754. static bool ends_in(const string& answer, const string& prompt)
  755. {
  756.     return answer.contains(prompt, answer.length() - prompt.length());
  757. }
  758.  
  759. // Return true iff ANSWER ends with secondary prompt.
  760. bool GDBAgent::ends_with_secondary_prompt (const string& ans)
  761. {
  762.     string answer = ans;
  763.     strip_control(answer);
  764.  
  765.     switch (type())
  766.     {
  767.     case DBX:
  768.     if (ends_in(answer, "]: "))
  769.     {
  770.         // AIX DBX issues `Select one of [FROM - TO]: ' in the last line
  771.         // Reported by Jonathan Edwards <edwards@intranet.com>
  772. #if RUNTIME_REGEX
  773.         static regex rxselect("Select one of \\[[0-9]+ - [0-9]+\\]: ");
  774. #endif
  775.         int idx = index(answer, rxselect, "Select one of ", -1);
  776.         if (idx >= 0 && answer.index('\n', idx) < 0)
  777.         return true;
  778.     }
  779.  
  780.     // Prompt is `> ' at beginning of line
  781.     return answer == "> " || ends_in(answer, "\n> ");
  782.  
  783.     case GDB:
  784.     // Prompt is `> ' at beginning of line
  785.     return answer == "> " || ends_in(answer, "\n> ");
  786.     
  787.     case XDB:
  788.     case JDB:
  789.     case PYDB:
  790.     case PERL:
  791.     // Is there any secondary prompt in these debuggers? (FIXME)
  792.     return false;
  793.     }
  794.  
  795.     return false;        // Never reached
  796. }
  797.  
  798.  
  799. // Check if ANSWER requires an immediate reply; return it.
  800. string GDBAgent::requires_reply (const string& answer)
  801. {
  802.     // GDB says: `---Type <return> to continue, or q <return> to quit---'
  803.     // DBX 3.0 says: `line N', `(END)', `(press RETURN)', and `More (n if no)?'
  804.     // XDB says: `--More--' and `Hit RETURN to continue'.
  805.     // Escape sequences may also be embedded, but the prompt never
  806.     // ends in a newline.
  807.  
  808.     if (answer.contains('\n', -1) || ends_with_prompt(answer))
  809.     return "";
  810.     int last_line_index = answer.index('\n', -1) + 1;
  811.  
  812.     string last_line = answer.chars() + last_line_index;
  813.     last_line.downcase();
  814.     strip_control(last_line);
  815.  
  816.     if (last_line.contains("end") 
  817.     || last_line.contains("line")
  818.     || last_line.contains("more")
  819.     || last_line.contains("cont:")
  820.     || last_line.contains("return"))
  821.     {
  822. #if RUNTIME_REGEX
  823.     static regex rxq(".*[(]END[)][^\n]*");
  824. #endif
  825.     if (answer.matches(rxq, last_line_index))
  826.         return "q";        // Stop this
  827.  
  828. #if RUNTIME_REGEX
  829.     static regex rxspace(".*(--More--|line [0-9])[^\n]*");
  830. #endif
  831.     if (answer.matches(rxspace, last_line_index))
  832.         return " ";        // Keep on scrolling
  833.  
  834. #if RUNTIME_REGEX
  835.     static regex rxreturn(".*([(]press RETURN[)]"
  836.                   "|Hit RETURN to continue"
  837.                   "|Type <return> to continue"
  838.                   "|  cont: "
  839.                   "|More [(]n if no[)][?])[^\n]*");
  840. #endif
  841.     if (answer.matches(rxreturn, last_line_index))
  842.         return "\n";        // Keep on scrolling
  843.  
  844.     if (type() == XDB)
  845.     {
  846.         // Added regular expression for "Standard input: END" to
  847.         // GDBAgent::requires_reply 
  848.         // -- wiegand@kong.gsfc.nasa.gov (Robert Wiegand)
  849. #if RUNTIME_REGEX
  850.         static regex rxxdb(".*Standard input: END.*");
  851. #endif
  852.         if (answer.matches(rxxdb, last_line_index))
  853.         return "\n";    // Keep on scrolling
  854.     }
  855.     }
  856.  
  857.     return "";
  858. }
  859.  
  860.  
  861.  
  862. //-----------------------------------------------------------------------------
  863. // Filters
  864. //-----------------------------------------------------------------------------
  865.  
  866. // Normalize answer - handle control characters, remove comments and prompt
  867. void GDBAgent::normalize_answer(string& answer) const
  868. {
  869.     strip_control(answer);
  870.     strip_dbx_comments(answer);
  871.     cut_off_prompt(answer);
  872. }
  873.  
  874. // Remove GDB prompt
  875. void GDBAgent::cut_off_prompt(string& answer) const
  876. {
  877.     switch (type())
  878.     {
  879.     case GDB:
  880.     if (recording() && answer.contains('>', -1))
  881.     {
  882.         answer = answer.before('>', -1);
  883.         break;
  884.     }
  885.  
  886.     // FALL THROUGH
  887.     case DBX:
  888.     case PYDB:
  889.     answer = answer.before('(', -1);
  890.     break;
  891.  
  892.     case XDB:
  893.     answer = answer.before('>', -1);
  894.     break;
  895.  
  896.     case PERL:
  897.     {
  898.     int i = answer.index("DB<", -1);
  899.     while (i > 0 && answer[i - 1] == ' ')
  900.         i--;
  901.     answer.from(i) = "";
  902.     break;
  903.     }
  904.  
  905.     case JDB:
  906.     {
  907.     // Check for prompt at the end of the last line
  908.     if (answer.contains(last_prompt, -1))
  909.     {
  910.         answer = answer.before(int(answer.length()) - 
  911.                    int(last_prompt.length()));
  912.     }
  913.     break;
  914.     }
  915.     }
  916. }
  917.  
  918. // Strip annoying DBX comments
  919. void GDBAgent::strip_dbx_comments(string& s) const
  920. {
  921.     if (type() == DBX)
  922.     {
  923.     // Weed out annoying DBX warnings like
  924.     // `WARNING: terminal cannot clear to end of line'
  925.     for (;;)
  926.     {
  927.         int warning = s.index("WARNING: terminal cannot ");
  928.         if (warning < 0)
  929.         break;
  930.         int eol = s.index('\n', warning) + 1;
  931.         if (eol <= 0)
  932.         eol = s.length();
  933.         s(warning, eol - warning) = "";
  934.     }
  935.     }
  936.  
  937.     // If we're verbatim, leave output unchanged.
  938.     if (verbatim())
  939.     return;
  940.  
  941.     // All remaining problems occur in Sun DBX 3.x only.
  942.     if (!has_print_r_option())
  943.     return;
  944.  
  945.     if (s.contains('/'))
  946.     {
  947.     // Check for C and C++ comments
  948.     char quoted = '\0';
  949.  
  950.     unsigned int i = 0;
  951.     while (i < s.length())
  952.     {
  953.         char c = s[i++];
  954.         switch (c)
  955.         {
  956.         case '\\':
  957.         if (i < s.length())
  958.             i++;
  959.         break;
  960.  
  961.         case '\'':
  962.         case '\"':
  963.         if (c == quoted)
  964.             quoted = '\0';
  965.         else if (!quoted)
  966.             quoted = c;
  967.         break;
  968.  
  969.         case '/':
  970.         if (i < s.length() && !quoted)
  971.         {
  972.             if (s[i] == '*')
  973.             {
  974.             /* C-style comment */
  975.             int end = s.index("*/", i + 1);
  976.             if (end == -1)
  977.             {
  978.                 // unterminated comment -- keep it now
  979.                 break;
  980.             }
  981.  
  982.             // Remove comment
  983.             i--;
  984.             s.at(int(i), int(end - i + 2)) = "";
  985.             }
  986.             else if (s[i] == '/')
  987.             {
  988.             // C++-style comment
  989.             int end = s.index('\n', i + 1);
  990.             i--;
  991.  
  992.             // Remove comment
  993.             if (end == -1)
  994.                 s.from(int(i)) = "";
  995.             else
  996.                 s.at(int(i), int(end - i)) = "";
  997.             }
  998.         }
  999.         }
  1000.     }
  1001.     }
  1002.  
  1003.     if (s.contains("dbx: warning:"))
  1004.     {
  1005.     // Weed out annoying DBX warnings like
  1006.     // `dbx: warning: -r option only recognized for C++' and
  1007.     // `dbx: warning: unknown language, 'c' assumed'
  1008.  
  1009. #if RUNTIME_REGEX
  1010.     static regex rxdbxwarn1("dbx: warning:[^\n]*"
  1011.                 "option only recognized for[^\n]*\n");
  1012.     static regex rxdbxwarn2("dbx: warning:[^\n]*"
  1013.                 "unknown language[^\n]*\n");
  1014. #endif
  1015.     s.gsub(rxdbxwarn1, "");
  1016.     s.gsub(rxdbxwarn2, "");
  1017.     }
  1018. }
  1019.  
  1020. // Strip control characters
  1021. void GDBAgent::strip_control(string& answer) const
  1022. {
  1023.     int source_index = 0;
  1024.     int target_index = 0;
  1025.  
  1026.     for (source_index = 0; source_index < int(answer.length()); source_index++)
  1027.     {
  1028.     char c = answer[source_index];
  1029.     switch (c)
  1030.     {
  1031.     case '\b':
  1032.         // Delete last character
  1033.         if (target_index > 0 && answer[target_index - 1] != '\n')
  1034.         target_index--;
  1035.         else
  1036.         {
  1037.         // Nothing to erase -- keep the '\b'.
  1038.         goto copy;
  1039.         }
  1040.         break;
  1041.  
  1042.     case '\r':
  1043.         if (source_index + 1 < int(answer.length()))
  1044.         {
  1045.         if (answer[source_index + 1] == '\n' ||
  1046.             answer[source_index + 1] == '\r')
  1047.         {
  1048.             // '\r' followed by '\n' or '\r' -- don't copy
  1049.             break;
  1050.         }
  1051.             else
  1052.         {
  1053.             // '\r' followed by something else: 
  1054.             // Return to beginning of line
  1055.             while (target_index > 0 && 
  1056.                answer[target_index - 1] != '\n')
  1057.             target_index--;
  1058.         }
  1059.         }
  1060.         else
  1061.         {
  1062.         // Trailing '\r' -- keep it
  1063.         goto copy;
  1064.         }
  1065.         break;
  1066.  
  1067.     case '\032':
  1068.         // In annotation level 2, GDB sends out `annotation'
  1069.         // sequences like `\n\032\032prompt\n'.  Future DDD
  1070.         // versions might want to look at these annotations; right
  1071.         // now, we simply weed them out.
  1072.         if (target_index > 0 &&
  1073.         answer[target_index - 1] == '\n' &&
  1074.         source_index + 1 < int(answer.length()) && 
  1075.         answer[source_index + 1] == '\032')
  1076.         {
  1077.         // Ignore everything up to and including the next '\n'.
  1078.         int i = source_index;
  1079.         while (i < int(answer.length()) &&
  1080.                answer[i] != '\n' && answer[i] != ':')
  1081.             i++;
  1082.         if (i >= int(answer.length()))
  1083.         {
  1084.             // The annotation is not finished yet -- copy it
  1085.             goto copy;
  1086.         }
  1087.         else if (answer[i] == ':')
  1088.         {
  1089.             // This is a normal `fullname' annotation, handled by DDD
  1090.             goto copy;
  1091.         }
  1092.         else
  1093.         {
  1094.             // Annotation found -- ignore it
  1095.             assert(answer[target_index - 1] == '\n');
  1096.             target_index--;
  1097.  
  1098.             assert(answer[i] == '\n');
  1099.             source_index = i;
  1100.         }
  1101.         }
  1102.         else
  1103.         {
  1104.         // Single or trailing `\032' -- keep it
  1105.         goto copy;
  1106.         }
  1107.         break;
  1108.  
  1109.     case '\033':        // aka `\e'
  1110.         // XDB `more' sends VT100 escape sequences like `\e[m',
  1111.         // `\e[22;1H', `\e[7m', `\e[K', regardless of TERM
  1112.         // settings.  We simply weed out everything up to and
  1113.         // including to the next letter.
  1114.         while (source_index < int(answer.length()) && 
  1115.            !isalpha(answer[source_index]))
  1116.         source_index++;
  1117.  
  1118.         if (source_index >= int(answer.length()))
  1119.         {
  1120.         // The escape sequence is not finished yet - keep the '\e'.
  1121.         answer[target_index++] = c;
  1122.         }
  1123.         break;
  1124.  
  1125.     copy:
  1126.     default:
  1127.         // Leave character unchanged
  1128.         answer[target_index++] = answer[source_index];
  1129.         break;
  1130.     }
  1131.     }
  1132.  
  1133.     answer = answer.before(target_index);
  1134. }
  1135.  
  1136.  
  1137. //-----------------------------------------------------------------------------
  1138. // Event handlers
  1139. //-----------------------------------------------------------------------------
  1140.  
  1141. // Received data from GDB
  1142.  
  1143. void GDBAgent::InputHP(Agent *agent, void *, void *call_data)
  1144. {
  1145.     GDBAgent* gdb = ptr_cast(GDBAgent, agent);
  1146.     assert(gdb != 0);
  1147.  
  1148.     DataLength* dl = (DataLength *) call_data;
  1149.     string answer(dl->data, dl->length);
  1150.  
  1151.     gdb->handle_input(answer);
  1152. }
  1153.  
  1154. void GDBAgent::handle_echo(string& answer)
  1155. {
  1156.     // If we don't detect echos, leave output unchanged.
  1157.     if (!detect_echos())
  1158.     return;
  1159.  
  1160.     // Check for echoed characters.  Every now and then, the TTY setup
  1161.     // fails such that we get characters echoed back.  This may also
  1162.     // happen with remote connections.
  1163.     if (echoed_characters >= 0)
  1164.     {
  1165.     int i = 0;
  1166.     int e = echoed_characters;
  1167.     while (i < int(answer.length()) && e < int(last_written.length()))
  1168.     {
  1169.         if (answer[i] == '\r')
  1170.         {
  1171.         // Ignore '\r' in comparisons
  1172.         i++;
  1173.         }
  1174.         else if (answer[i] == last_written[e])
  1175.         {
  1176.         i++, e++;
  1177.         }
  1178.         else
  1179.         {
  1180.         // No echo
  1181.         break;
  1182.         }
  1183.     }
  1184.  
  1185.     if (e >= int(last_written.length()))
  1186.     {
  1187.         // All characters written have been echoed.
  1188.         // Remove echoed characters and keep on processing.
  1189.         callHandlers(EchoDetected, (void *)true);
  1190.         answer = answer.from(i);
  1191.         echoed_characters = -1;
  1192.     }
  1193.     else if (i >= int(answer.length()))
  1194.     {
  1195.         // A prefix of the last characters written has been echoed.
  1196.         // Wait for further echos.
  1197.         answer = "";
  1198.         echoed_characters = e;
  1199.     }
  1200.     else
  1201.     {
  1202.         // No echo.
  1203.         // => Restore any echoed characters and keep on processing
  1204.         answer.prepend(last_written.before(echoed_characters));
  1205.         echoed_characters = -1;
  1206.  
  1207.         // If a command of length ECHO_THRESHOLD is not echoed,
  1208.         // disable echo detection.  The idea behind this is that
  1209.         // echo disabling seems to have succeeded and we thus no
  1210.         // longer need to check for echos.  This reduces the risk
  1211.         // of echo detection altering output data.
  1212.  
  1213.         // ECHO_THRESHOLD is 4 because the inferior debugger might
  1214.         // not echo short interludes like `yes\n', `no\n' or `^C'.
  1215.         const unsigned int ECHO_THRESHOLD = 4;
  1216.  
  1217.         if (last_written.length() > ECHO_THRESHOLD)
  1218.         {
  1219.         // No more echos - disable echo detection until re-activated
  1220.         callHandlers(EchoDetected, (void *)false);
  1221.         detect_echos(false);
  1222.         }
  1223.     }
  1224.     }
  1225. }
  1226.  
  1227. void GDBAgent::handle_more(string& answer)
  1228. {
  1229.     // Check for `More' prompt
  1230.     string reply = requires_reply(answer);
  1231.     if (reply != "")
  1232.     {
  1233.     // Oops - this should not happen.  Just hit the reply key.
  1234.     write(reply);
  1235.     flush();
  1236.  
  1237.     // Ignore the last line (containing the `More' prompt)
  1238.     int last_beginning_of_line = answer.index('\n', -1) + 1;
  1239.     answer.from(last_beginning_of_line) = "";
  1240.     }
  1241. }
  1242.  
  1243. void GDBAgent::handle_reply(string& answer)
  1244. {
  1245.     if (recording())
  1246.     return;
  1247.  
  1248.     // Check for secondary prompt
  1249.     if (ends_with_secondary_prompt(answer))
  1250.     {
  1251.     // GDB requires more information here: probably the
  1252.     // selection of an ambiguous C++ name.
  1253.     // We simply try the first alternative here:
  1254.     // - in GDB, this means `all';
  1255.     // - in DBX and XDB, this is a non-deterministic selection.
  1256.  
  1257.     ReplyRequiredInfo info;
  1258.     info.question = answer;
  1259.     info.reply    = "1\n";
  1260.  
  1261.     // Allow handlers to override the default reply
  1262.     callHandlers(ReplyRequired, (void *)&info);
  1263.  
  1264.     // Send reply immediately
  1265.     write(info.reply);
  1266.     flush();
  1267.  
  1268.     // Ignore the selection
  1269.     answer = info.question;
  1270.     }
  1271. }
  1272.  
  1273. bool GDBAgent::recording(bool val)
  1274. {
  1275.     if (_recording != val)
  1276.     {
  1277.     _recording = val;
  1278.     callHandlers(Recording, (void *)recording());
  1279.     }
  1280.     return recording();
  1281. }
  1282.  
  1283. void GDBAgent::handle_input(string& answer)
  1284. {
  1285.     handle_echo(answer);
  1286.     handle_more(answer);
  1287.     handle_reply(answer);
  1288.  
  1289.     // Handle all other GDB output, depending on current state.
  1290.     switch (state)
  1291.     {
  1292.     case ReadyWithPrompt:
  1293.     // We have a prompt, and still get input?  Maybe this is an
  1294.     // answer to a command sent before the prompt was received -
  1295.     // or a reply to a control character (`Quit').
  1296.     strip_control(answer);
  1297.     callHandlers(AsyncAnswer, (void *)&answer);
  1298.     break;
  1299.  
  1300.     case BusyOnInitialCmds:
  1301.     case BusyOnCmd:
  1302.     complete_answer += answer;
  1303.  
  1304.     if (_on_answer != 0)
  1305.     {
  1306.         if (ends_with_prompt(complete_answer))
  1307.         normalize_answer(answer);
  1308.         else
  1309.         {
  1310.         strip_control(answer);
  1311.         strip_dbx_comments(answer);
  1312.         }
  1313.         _on_answer(answer, _user_data);
  1314.     }
  1315.  
  1316.     if (ends_with_prompt(complete_answer))
  1317.     {
  1318.             // Received complete answer (GDB issued prompt)
  1319.  
  1320.             // Set new state and call answer procedure
  1321.         if (state == BusyOnInitialCmds)
  1322.         {
  1323.         if (!questions_waiting) 
  1324.         {
  1325.             state = ReadyWithPrompt;
  1326.             callHandlers(ReadyForCmd, (void *)true);
  1327.             callHandlers(ReadyForQuestion, (void *)true);
  1328.  
  1329.             if (_on_answer_completion != 0)
  1330.             _on_answer_completion (_user_data);
  1331.         }
  1332.         else
  1333.         {
  1334.             state = BusyOnQuArray;
  1335.  
  1336.             // Send first question
  1337.             write(cmd_array[0]);
  1338.             flush();
  1339.         }
  1340.         }
  1341.         else if (!questions_waiting)
  1342.         {
  1343.         state = ReadyWithPrompt;
  1344.         callHandlers(ReadyForQuestion, (void *)true);
  1345.  
  1346.         if (_on_answer_completion != 0)
  1347.             _on_answer_completion (_user_data);
  1348.         }
  1349.         else
  1350.         {
  1351.         state = BusyOnQuArray;
  1352.         callHandlers(ReadyForCmd, (void *)false);
  1353.  
  1354.         // Send first question
  1355.         write(cmd_array[0]);
  1356.         flush();
  1357.         }
  1358.     }
  1359.     break;
  1360.  
  1361.     case BusyOnQuestion:
  1362.     complete_answer += answer;
  1363.  
  1364.     if (ends_with_prompt(complete_answer))
  1365.     {
  1366.             // Received complete answer (GDB issued prompt)
  1367.         normalize_answer(complete_answer);
  1368.  
  1369.             // Set new state
  1370.         state = ReadyWithPrompt;
  1371.         callHandlers(ReadyForQuestion, (void *)true);
  1372.         callHandlers(ReadyForCmd, (void *)true);
  1373.  
  1374.         if (_on_question_completion != 0)
  1375.         {
  1376.         // We use a local copy of COMPLETE_ANSWER here, since
  1377.         // the callback may submit a new query, overriding
  1378.         // the original value.
  1379.         string c(complete_answer);
  1380.         _on_question_completion(c, _qu_data);
  1381.         }
  1382.     }
  1383.     break;
  1384.  
  1385.     case BusyOnQuArray:
  1386.     complete_answers[qu_index] += answer;
  1387.  
  1388.     if (ends_with_prompt(complete_answers[qu_index]))
  1389.     {
  1390.             // Answer is complete (GDB issued prompt)
  1391.         normalize_answer(complete_answers[qu_index]);
  1392.  
  1393.         if (qu_index == _qu_count - 1)
  1394.         {
  1395.         // Received all answers -- we're ready again
  1396.         state = ReadyWithPrompt;
  1397.         callHandlers(ReadyForQuestion, (void *)true);
  1398.         callHandlers(ReadyForCmd, (void *)true);
  1399.  
  1400.         if (questions_waiting || _on_qu_array_completion != 0)
  1401.         {
  1402.             // We use a local copy of the answers and user
  1403.             // data here, since the callback may submit a new
  1404.             // query, overriding the original value.
  1405.             StringArray answers(complete_answers);
  1406.             VoidArray datas(_qu_datas);
  1407.             OQACProc array_completion  = _on_qu_array_completion;
  1408.             OACProc  answer_completion = _on_answer_completion;
  1409.             void *array_data           = _qa_data;
  1410.  
  1411.             if (questions_waiting)
  1412.             {
  1413.             // We did not call the OACProc yet.
  1414.             questions_waiting = false;
  1415.  
  1416.             if (answer_completion != 0)
  1417.                 answer_completion(_user_data);
  1418.             }
  1419.             if (array_completion != 0)
  1420.             array_completion(answers, datas, array_data);
  1421.         }
  1422.         }
  1423.         else
  1424.         {
  1425.         // Send next question
  1426.         write(cmd_array[++qu_index]);
  1427.         flush();
  1428.         }
  1429.     }
  1430.     break;
  1431.  
  1432.     default:
  1433.     assert(0);
  1434.     break;
  1435.     }
  1436. }
  1437.  
  1438. // GDB died
  1439. void GDBAgent::DiedHP(Agent *agent, void *, void *)
  1440. {
  1441.     GDBAgent *gdb = ptr_cast(GDBAgent, agent);
  1442.     gdb->handle_died();
  1443. }
  1444.  
  1445. void GDBAgent::handle_died()
  1446. {
  1447.     // We have no prompt
  1448.     last_prompt = "";
  1449.  
  1450.     // Call answer completion handlers
  1451.     switch (state)
  1452.     {
  1453.     case ReadyWithPrompt:
  1454.     break;
  1455.  
  1456.     case BusyOnInitialCmds:
  1457.     case BusyOnCmd:
  1458.     if (_on_answer_completion != 0)
  1459.         _on_answer_completion (_user_data);
  1460.     break;
  1461.  
  1462.     case BusyOnQuestion:
  1463.     if (_on_question_completion != 0)
  1464.         _on_question_completion (complete_answer, _qu_data);
  1465.     break;
  1466.  
  1467.     case BusyOnQuArray:
  1468.     if (_on_qu_array_completion != 0)
  1469.         _on_qu_array_completion(complete_answers, _qu_datas, _qa_data);
  1470.     break;
  1471.     }
  1472.  
  1473.     // We're not ready anymore
  1474.     state = BusyOnCmd;
  1475.     complete_answer = "";
  1476.     callHandlers(ReadyForQuestion, (void *)false);
  1477.     callHandlers(ReadyForCmd,      (void *)false);
  1478. }
  1479.  
  1480.  
  1481. //-----------------------------------------------------------------------------
  1482. // Configuration
  1483. //-----------------------------------------------------------------------------
  1484.  
  1485. // DBX 3.0 wants `print -r' instead of `print' for C++
  1486. string GDBAgent::print_command(string expr, bool internal) const
  1487. {
  1488.     string cmd;
  1489.  
  1490.     switch (type())
  1491.     {
  1492.     case GDB:
  1493.     case DBX:
  1494.     if (internal && has_output_command())
  1495.         cmd = "output";
  1496.     else
  1497.         cmd = "print";
  1498.  
  1499.     if (has_print_r_option())
  1500.         cmd += " -r";
  1501.     break;
  1502.  
  1503.     case XDB:
  1504.     case PYDB:
  1505.     cmd = "p";
  1506.     break;
  1507.  
  1508.     case PERL:
  1509.     cmd = "x";
  1510.     break;
  1511.  
  1512.     case JDB:
  1513.     if (internal)
  1514.         cmd = "dump";
  1515.     else
  1516.         cmd = "print";
  1517.     break;
  1518.     }
  1519.  
  1520.     if (expr != "")
  1521.     cmd += " " + expr;
  1522.  
  1523.     return cmd;
  1524. }
  1525.  
  1526. // DBX 3.0 wants `display -r' instead of `display' for C++
  1527. string GDBAgent::display_command(string expr) const
  1528. {
  1529.     if (!has_display_command())
  1530.     return "";
  1531.  
  1532.     string cmd;
  1533.     if (has_print_r_option() && expr != "")
  1534.     cmd = "display -r";
  1535.     else
  1536.     cmd = "display";
  1537.  
  1538.     if (expr != "")
  1539.     cmd += " " + expr;
  1540.  
  1541.     return cmd;
  1542. }
  1543.  
  1544. // DBX 3.0 wants `where -h' instead of `where'
  1545. string GDBAgent::where_command(int count) const
  1546. {
  1547.     string cmd;
  1548.     switch (type())
  1549.     {
  1550.     case GDB:
  1551.     case DBX:
  1552.     case JDB:
  1553.     case PYDB:
  1554.     if (has_where_h_option())
  1555.         cmd = "where -h";
  1556.     else
  1557.         cmd = "where";
  1558.     break;
  1559.  
  1560.     case PERL:
  1561.     cmd = "T";
  1562.     break;
  1563.     
  1564.     case XDB:
  1565.     cmd = "t";
  1566.     break;
  1567.     }
  1568.  
  1569.     if (count != 0)
  1570.     cmd += " " + itostring(count);
  1571.  
  1572.     return cmd;
  1573. }
  1574.  
  1575. string GDBAgent::info_locals_command() const
  1576. {
  1577.     switch (type())
  1578.     {
  1579.     case GDB:
  1580.     case PYDB:
  1581.     return "info locals";
  1582.  
  1583.     case DBX:
  1584.     return "dump";
  1585.  
  1586.     case XDB:
  1587.     return "l";
  1588.  
  1589.     case JDB:
  1590.     return "locals";
  1591.  
  1592.     case PERL:
  1593.     return "V";
  1594.     }
  1595.  
  1596.     return "";            // Never reached
  1597. }
  1598.  
  1599. string GDBAgent::info_args_command() const
  1600. {
  1601.     switch (type())
  1602.     {
  1603.     case GDB:
  1604.     case PYDB:
  1605.     return "info args";
  1606.  
  1607.     default:
  1608.     break;
  1609.     }
  1610.  
  1611.     return info_locals_command();
  1612. }
  1613.  
  1614. string GDBAgent::info_display_command() const
  1615. {
  1616.     if (type() == GDB)
  1617.     return "info display";
  1618.     else
  1619.     return display_command();
  1620. }
  1621.  
  1622.  
  1623. // Some DBXes want `sh pwd' instead of `pwd'
  1624. string GDBAgent::pwd_command() const
  1625. {
  1626.     switch (type())
  1627.     {
  1628.     case GDB:
  1629.     case DBX:
  1630.     case PYDB:
  1631.     if (has_pwd_command())
  1632.         return "pwd";
  1633.     else
  1634.         return "sh pwd";
  1635.  
  1636.     case XDB:
  1637.     return "!pwd";
  1638.  
  1639.     case PERL:
  1640.     return "p $ENV{'PWD'} || `pwd`";
  1641.  
  1642.     case JDB:
  1643.     return "";
  1644.  
  1645.     }
  1646.  
  1647.     return "";            // Never reached
  1648. }
  1649.  
  1650. // Some DBXes want `sh make' instead of `make'
  1651. string GDBAgent::make_command(string args) const
  1652. {
  1653.     string cmd;
  1654.     switch (type())
  1655.     {
  1656.     case GDB:
  1657.     case DBX:
  1658.     if (has_make_command())
  1659.         cmd = "make";
  1660.     else
  1661.         cmd = "sh make";
  1662.     break;
  1663.  
  1664.     case XDB:
  1665.     cmd = "!make";
  1666.     break;
  1667.  
  1668.     case PERL:
  1669.     if (args == "")
  1670.         return "system 'make'";
  1671.     else
  1672.         return "system 'make " + args + "'";
  1673.  
  1674.     case JDB:
  1675.     case PYDB:
  1676.     return "";        // Not available
  1677.     }
  1678.  
  1679.     if (args == "")
  1680.     return cmd;
  1681.     else
  1682.     return cmd + " " + args;
  1683. }
  1684.  
  1685. // Move PC to POS
  1686. string GDBAgent::jump_command(string pos) const
  1687. {
  1688.     if (!has_jump_command())
  1689.     return "";
  1690.  
  1691.     switch (type())
  1692.     {
  1693.     case GDB:
  1694.     return "jump " + pos;
  1695.    
  1696.     case XDB:
  1697.     {
  1698.     if (pos.contains('*', 0))
  1699.         pos = pos.after('*');
  1700.     return "g " + pos;
  1701.     }
  1702.  
  1703.     case DBX:
  1704.     return "cont at " + pos;
  1705.  
  1706.     case JDB:
  1707.     case PYDB:
  1708.     case PERL:
  1709.     return "";        // Not available
  1710.     }
  1711.  
  1712.     return "";            // Never reached
  1713. }
  1714.  
  1715. // Show registers
  1716. string GDBAgent::regs_command(bool all) const
  1717. {
  1718.     if (!has_regs_command())
  1719.     return "";
  1720.  
  1721.     switch (type())
  1722.     {
  1723.     case GDB:
  1724.     if (all)
  1725.         return "info all-registers";
  1726.     else
  1727.         return "info registers";
  1728.    
  1729.     case DBX:
  1730.     if (all)
  1731.         return "regs -F";    // Sun DBX 4.0
  1732.     else
  1733.         return "regs";    
  1734.  
  1735.     case XDB:
  1736.     case JDB:
  1737.     case PYDB:
  1738.     case PERL:
  1739.     return "";        // Not available
  1740.     }
  1741.  
  1742.     return "";            // Never reached
  1743. }
  1744.  
  1745. // Watch expressions
  1746. string GDBAgent::watch_command(string expr, WatchMode w) const
  1747. {
  1748.     if ((has_watch_command() & w) != w)
  1749.     return "";
  1750.  
  1751.     switch (type())
  1752.     {
  1753.     case GDB:
  1754.     if ((w & WATCH_CHANGE) == WATCH_CHANGE)
  1755.         return "watch " + expr;
  1756.     if ((w & WATCH_ACCESS) == WATCH_ACCESS)
  1757.         return "awatch " + expr;
  1758.     if ((w & WATCH_READ) == WATCH_READ)
  1759.         return "rwatch " + expr;
  1760.     return "";
  1761.    
  1762.     case DBX:
  1763.     if ((w & WATCH_CHANGE) == WATCH_CHANGE)
  1764.     {
  1765.         if (has_handler_command())
  1766.         {
  1767.         // Solaris 2.6 DBX wants `stop change VARIABLE'
  1768.         return "stop change " + expr;
  1769.         }
  1770.         else
  1771.         {
  1772.         // `Traditional' DBX notation
  1773.         return "stop " + expr;
  1774.         }
  1775.     }
  1776.     return "";
  1777.  
  1778.     case XDB:
  1779.     // Not available.  (There is the `assertion' concept which is
  1780.     // similar but won't fit into the DDD GUI.)
  1781.     return "";
  1782.  
  1783.     case JDB:
  1784.     case PYDB:
  1785.     case PERL:
  1786.     return "";        // Not available
  1787.     }
  1788.  
  1789.     return "";            // Never reached
  1790. }
  1791.  
  1792.  
  1793. string GDBAgent::kill_command() const
  1794. {
  1795.     switch (type())
  1796.     {
  1797.     case GDB:
  1798.     case DBX:
  1799.     return "kill";
  1800.    
  1801.     case XDB:
  1802.     return "k";
  1803.  
  1804.     case PYDB:
  1805.     return "kill";
  1806.  
  1807.     case JDB:
  1808.     case PERL:
  1809.     return "";        // Not available
  1810.     }
  1811.  
  1812.     return "";            // Never reached
  1813. }
  1814.  
  1815. string GDBAgent::frame_command() const
  1816. {
  1817.     switch (type())
  1818.     {
  1819.     case GDB:
  1820.     case DBX:
  1821.     if (has_frame_command())
  1822.         return "frame";
  1823.     else
  1824.         return where_command(1);
  1825.  
  1826.     case XDB:
  1827.     return print_command("$depth");
  1828.  
  1829.     case PYDB:
  1830.     return where_command(0);
  1831.  
  1832.     case JDB:
  1833.     case PERL:
  1834.     return "";        // Not available
  1835.     }
  1836.  
  1837.     return "";            // Never reached
  1838. }
  1839.  
  1840. string GDBAgent::frame_command(int num) const
  1841. {
  1842.     if (!has_frame_command())
  1843.     return "";
  1844.  
  1845.     switch (type())
  1846.     {
  1847.     case GDB:
  1848.     case DBX:
  1849.     return frame_command() + " " + itostring(num);
  1850.  
  1851.     case XDB:
  1852.     return "V " + itostring(num);
  1853.  
  1854.     case JDB:
  1855.     case PYDB:
  1856.     case PERL:
  1857.     return "";        // Not available
  1858.     }
  1859.  
  1860.     return "";            // Never reached
  1861. }
  1862.  
  1863. // Add OFFSET to current frame (i.e. OFFSET > 0: up, OFFSET < 0: down)
  1864. string GDBAgent::relative_frame_command(int offset) const
  1865. {
  1866.     if (gdb->type() == PERL)
  1867.     return "";        // No such command in Perl
  1868.  
  1869.     if (offset == -1)
  1870.     return "down";
  1871.     else if (offset < 0)
  1872.     return "down " + itostring(-offset);
  1873.     else if (offset == 1)
  1874.     return "up";
  1875.     else if (offset > 0)
  1876.     return "up " + itostring(offset);
  1877.  
  1878.     return "";            // Offset == 0
  1879. }
  1880.  
  1881. string GDBAgent::func_command() const
  1882. {
  1883.     switch (type())
  1884.     {
  1885.     case GDB:
  1886.     case XDB:
  1887.     case JDB:
  1888.     case PYDB:
  1889.     case PERL:
  1890.     return frame_command();
  1891.  
  1892.     case DBX:
  1893.     return has_func_command() ? "func" : "";
  1894.     }
  1895.  
  1896.     return "";            // Never reached
  1897. }
  1898.  
  1899. // Each debugger has its own way of echoing (sigh)
  1900. string GDBAgent::echo_command(string text) const
  1901. {
  1902.     switch (type())
  1903.     {
  1904.     case GDB:
  1905.     return "echo " + cook(text);
  1906.  
  1907.     case DBX:
  1908.     return print_command(quote(text), false);
  1909.  
  1910.     case XDB:
  1911.     return quote(text);
  1912.  
  1913.     case PERL:
  1914.     if (text.contains('\n', -1))
  1915.         text = text.before(-1);
  1916.     return "p " + quote(text, '\'');
  1917.  
  1918.     case JDB:
  1919.     case PYDB:
  1920.     return "";        // Not available
  1921.     }
  1922.  
  1923.     return "";            // Never reached
  1924. }
  1925.  
  1926. // Prefer `ptype' on `whatis' in GDB
  1927. string GDBAgent::whatis_command(string text) const
  1928. {
  1929.     switch (type())
  1930.     {
  1931.     case GDB:
  1932.     return "ptype " + text;
  1933.  
  1934.     case DBX:
  1935.     case PYDB:
  1936.     if (has_print_r_option())
  1937.         return "whatis -r " + text;
  1938.     else
  1939.         return "whatis " + text;
  1940.  
  1941.     case XDB:
  1942.     return "p " + text + "\\T";
  1943.  
  1944.     case JDB:
  1945.     return "dump " + text;    // As close as we can get
  1946.  
  1947.     case PERL:
  1948.     return "";        // Who knows?
  1949.     }
  1950.  
  1951.     return "";            // Never reached
  1952. }
  1953.  
  1954. // Enable breakpoint BP
  1955. string GDBAgent::enable_command(string bp) const
  1956. {
  1957.     if (bp != "")
  1958.     bp.prepend(' ');
  1959.  
  1960.     switch (type())
  1961.     {
  1962.     case GDB:
  1963.     case PYDB:
  1964.     return "enable" + bp;
  1965.  
  1966.     case DBX:
  1967.     if (has_handler_command())
  1968.         return "handler -enable" + bp;
  1969.     else
  1970.         return "";
  1971.  
  1972.     case XDB:
  1973.     return "ab" + bp;
  1974.  
  1975.     case JDB:
  1976.     case PERL:
  1977.     return "";        // Not available
  1978.     }
  1979.  
  1980.     return "";            // Never reached
  1981. }
  1982.  
  1983. // Disable breakpoint BP
  1984. string GDBAgent::disable_command(string bp) const
  1985. {
  1986.     if (bp != "")
  1987.     bp.prepend(' ');
  1988.  
  1989.     switch (type())
  1990.     {
  1991.     case GDB:
  1992.     case PYDB:
  1993.     return "disable" + bp;
  1994.  
  1995.     case DBX:
  1996.     if (has_handler_command())
  1997.         return "handler -disable" + bp;
  1998.     else
  1999.         return "";
  2000.  
  2001.     case XDB:
  2002.     return "sb" + bp;
  2003.  
  2004.     case JDB:
  2005.     case PERL:
  2006.     return "";        // Not available
  2007.     }
  2008.  
  2009.     return "";            // Never reached
  2010. }
  2011.  
  2012. // Delete breakpoint BP
  2013. string GDBAgent::delete_command(string bp) const
  2014. {
  2015.     if (bp != "")
  2016.     bp.prepend(' ');
  2017.  
  2018.     switch (type())
  2019.     {
  2020.     case DBX:
  2021.     case GDB:
  2022.     case PYDB:
  2023.     return "delete" + bp;
  2024.  
  2025.     case XDB:
  2026.     return "db" + bp;
  2027.  
  2028.     case JDB:
  2029.     case PERL:
  2030.     return "";        // Not available
  2031.     }
  2032.  
  2033.     return "";            // Never reached
  2034. }
  2035.  
  2036. // Set ignore count of breakpoint BP to COUNT
  2037. string GDBAgent::ignore_command(string bp, int count) const
  2038. {
  2039.     switch (type())
  2040.     {
  2041.     case GDB:
  2042.     case PYDB:
  2043.     return "ignore " + bp + " " + itostring(count);
  2044.  
  2045.     case DBX:
  2046.     if (has_handler_command())
  2047.         return "handler -count " + bp + " " + itostring(count);
  2048.     else
  2049.         return "";
  2050.  
  2051.     case XDB:
  2052.     return "bc " + bp + " " + itostring(count);
  2053.  
  2054.     case JDB:
  2055.     case PERL:
  2056.     return "";        // Not available
  2057.     }
  2058.  
  2059.     return "";            // Never reached
  2060. }
  2061.  
  2062. // Set condition of breakpoint BP to EXPR
  2063. string GDBAgent::condition_command(string bp, string expr) const
  2064. {
  2065.     switch (type())
  2066.     {
  2067.     case GDB:
  2068.     case PYDB:
  2069.     return "condition " + bp + " " + expr;
  2070.  
  2071.     case DBX:
  2072.     case XDB:
  2073.     case JDB:
  2074.     case PERL:
  2075.     return "";        // FIXME
  2076.     }
  2077.  
  2078.     return "";            // Never reached
  2079. }
  2080.  
  2081. // Return shell escape command
  2082. string GDBAgent::shell_command(string cmd) const
  2083. {
  2084.     switch (type())
  2085.     {
  2086.     case GDB:
  2087.     return "shell " + cmd;
  2088.  
  2089.     case DBX:
  2090.     return "sh " + cmd;
  2091.  
  2092.     case XDB:
  2093.     return "!" + cmd;
  2094.  
  2095.     case PERL:
  2096.     return "system " + quote(cmd, '\'');
  2097.  
  2098.     case JDB:
  2099.     case PYDB:
  2100.     return "";        // Not available
  2101.     }
  2102.     return "";            // Never reached
  2103. }
  2104.  
  2105. // Return command to debug PROGRAM
  2106. string GDBAgent::debug_command(string program, string args) const
  2107. {
  2108.     if (args != "" && !args.contains(' ', 0))
  2109.     args = " " + args;
  2110.  
  2111.     switch (type())
  2112.     {
  2113.     case GDB:
  2114.     case PYDB:
  2115.     return "file " + program;
  2116.  
  2117.     case DBX:
  2118.     if (has_givenfile_command())
  2119.         return "givenfile " + program; // SGI DBX
  2120.     else
  2121.         return "debug " + program;     // SUN DBX
  2122.  
  2123.     case XDB:
  2124.     return "#file " + program; // just a dummy
  2125.  
  2126.     case JDB:
  2127.     return "load " + program;
  2128.  
  2129.     case PERL:
  2130.     return "exec " + quote("perl -d " + program + args);
  2131.     }
  2132.     return "";            // Never reached
  2133. }
  2134.  
  2135. // Return command to send signal SIG
  2136. string GDBAgent::signal_command(int sig) const
  2137. {
  2138.     string n = itostring(sig);
  2139.  
  2140.     switch (type())
  2141.     {
  2142.     case GDB:
  2143.     return "signal " + n;
  2144.  
  2145.     case DBX:
  2146.     if (has_cont_sig_command())
  2147.         return "cont sig " + n; // SUN DBX
  2148.     else
  2149.         return "cont " + n;     // Other DBXes
  2150.  
  2151.     case XDB:
  2152.     return "p $signal = " + n + "; C";
  2153.  
  2154.     case JDB:
  2155.     case PYDB:
  2156.     case PERL:
  2157.     return "";        // Not available
  2158.     }
  2159.  
  2160.     return "";            // Never reached
  2161. }
  2162.  
  2163.  
  2164. // Return a command that does nothing.
  2165. string GDBAgent::nop_command(string comment) const
  2166. {
  2167.     return "# " + comment;    // Works for all inferior debuggers
  2168. }
  2169.  
  2170. // Run program with given ARGS
  2171. string GDBAgent::run_command(string args) const
  2172. {
  2173.     if (args != "" && !args.contains(' ', 0))
  2174.     args = " " + args;
  2175.  
  2176.     switch (type())
  2177.     {
  2178.     case GDB:
  2179.     {
  2180.     string c;
  2181.     if (args == "")
  2182.         c = "set args\n";
  2183.     return c + "run" + args;
  2184.     }
  2185.  
  2186.     case DBX:
  2187.     if (args == "" && has_rerun_command() && rerun_clears_args())
  2188.         return "rerun";
  2189.     else
  2190.         return "run" + args;
  2191.  
  2192.     case JDB:
  2193.     case PYDB:
  2194.     return "run" + args;
  2195.  
  2196.     case XDB:
  2197.     if (args == "")
  2198.         return "R";
  2199.     else
  2200.         return "r" + args;
  2201.  
  2202.     case PERL:
  2203.     {
  2204.     string c = "R\n@ARGV = (";
  2205.     while (args != "")
  2206.     {
  2207.         strip_leading_space(args);
  2208.         string arg = read_token(args);
  2209.         c += quote(arg, '\'') + ", ";
  2210.     }
  2211.     c += ")";
  2212.     return c;
  2213.     }
  2214.     }
  2215.  
  2216.     return "";            // Never reached
  2217. }
  2218.  
  2219. // Re-run program with previous arguments
  2220. string GDBAgent::rerun_command() const
  2221. {
  2222.     switch (type())
  2223.     {
  2224.     case GDB:
  2225.     case JDB:
  2226.     case PYDB:
  2227.     return "run";
  2228.  
  2229.     case DBX:
  2230.     if (has_rerun_command() && !rerun_clears_args())
  2231.         return "rerun";
  2232.     else
  2233.         return "run";
  2234.  
  2235.     case XDB:
  2236.     return "r";
  2237.  
  2238.     case PERL:
  2239.     return "R";
  2240.     }
  2241.  
  2242.     return "";            // Never reached
  2243. }
  2244.  
  2245.  
  2246. // Return PREFIX + EXPR, parenthesizing EXPR if needed
  2247. string GDBAgent::prepend_prefix(const string& prefix, const string& expr)
  2248. {
  2249.     if (expr.matches(rxidentifier)
  2250.     || expr.contains("(", 0) && expr.contains(")", -1))
  2251.     return prefix + expr;
  2252.     else if (expr == "")
  2253.     return prefix;
  2254.     else
  2255.     return prefix + "(" + expr + ")";
  2256. }
  2257.  
  2258. // Return EXPR + SUFFIX, parenthesizing EXPR if needed
  2259. string GDBAgent::append_suffix(const string& expr, const string& suffix)
  2260. {
  2261.     if (expr.matches(rxidentifier)
  2262.     || expr.contains("(", 0) && expr.contains(")", -1))
  2263.     return expr + suffix;
  2264.     else if (expr == "")
  2265.     return suffix;
  2266.     else
  2267.     return "(" + expr + ")" + suffix;
  2268. }
  2269.  
  2270. // Dereference an expression.
  2271. string GDBAgent::dereferenced_expr(string expr) const
  2272. {
  2273.     switch (program_language())
  2274.     {
  2275.     case LANGUAGE_C:
  2276.     return prepend_prefix("*", expr);
  2277.  
  2278.     case LANGUAGE_PERL:
  2279.     // Perl has three `dereferencing' operators, depending on the
  2280.     // type of reference.  The `deref()' function provides a
  2281.     // better solution.
  2282.     return prepend_prefix("$", expr);
  2283.  
  2284.     case LANGUAGE_FORTRAN:
  2285.     // GDB prints dereferenced pointers as `**X', but accepts them as `*X'.
  2286.     return prepend_prefix("*", expr);
  2287.  
  2288.     case LANGUAGE_JAVA:
  2289.     if (type() == GDB)
  2290.     {
  2291.         // GDB dereferences JAVA references by prepending `*'
  2292.         return prepend_prefix("*", expr);
  2293.     }
  2294.  
  2295.     // JDB (and others?) dereference automatically
  2296.     return expr;
  2297.  
  2298.     case LANGUAGE_CHILL:
  2299.     return append_suffix(expr, "->");
  2300.  
  2301.     case LANGUAGE_PASCAL:
  2302.     return append_suffix(expr, "^");
  2303.  
  2304.     case LANGUAGE_ADA:
  2305.     // GDB 4.16.gnat.1.13 prepends `*' as in C
  2306.     return prepend_prefix("*", expr);
  2307.  
  2308.     case LANGUAGE_PYTHON:
  2309.     return "";        // No such thing in Python/PYDB
  2310.  
  2311.     case LANGUAGE_OTHER:
  2312.     return expr;        // All other languages
  2313.     }
  2314.  
  2315.     return expr;        // All other languages
  2316. }
  2317.  
  2318. // Give the address of an expression.
  2319. string GDBAgent::address_expr(string expr) const
  2320. {
  2321.     if (expr.contains('/', 0))
  2322.     expr = expr.after(' ');
  2323.  
  2324.     switch (program_language())
  2325.     {
  2326.     case LANGUAGE_C:
  2327.     return prepend_prefix("&", expr);
  2328.  
  2329.     case LANGUAGE_PASCAL:
  2330.     return "ADR(" + expr + ")"; // Modula-2 address operator
  2331.  
  2332.     case LANGUAGE_CHILL:    // FIXME: untested.
  2333.     return prepend_prefix("->", expr);
  2334.  
  2335.     case LANGUAGE_FORTRAN:
  2336.     return prepend_prefix("&", expr);
  2337.  
  2338.     case LANGUAGE_JAVA:
  2339.     return "";        // Not supported in GDB
  2340.  
  2341.     case LANGUAGE_PYTHON:
  2342.     return "";        // Not supported in Python
  2343.  
  2344.     case LANGUAGE_PERL:
  2345.     return "";        // No such thing in Perl
  2346.  
  2347.     case LANGUAGE_ADA:
  2348.     return "";        // Not supported in GNAT/Ada
  2349.  
  2350.     case LANGUAGE_OTHER:
  2351.     return "";        // All other languages
  2352.     }
  2353.  
  2354.     return "";            // All other languages
  2355. }
  2356.  
  2357. // Give the index of an expression.
  2358. string GDBAgent::index_expr(string expr, string index) const
  2359. {
  2360.     switch (program_language())
  2361.     {
  2362.     case LANGUAGE_FORTRAN:
  2363.     case LANGUAGE_ADA:
  2364.     return expr + "(" + index + ")";
  2365.  
  2366.     case LANGUAGE_PERL:
  2367.     if (expr != "" && expr[0] == '@')
  2368.         return '$' + expr.after(0) + "[" + index + "]";
  2369.     else
  2370.         return expr + "[" + index + "]";
  2371.  
  2372.     default:
  2373.     break;
  2374.     }
  2375.  
  2376.     // All other languages
  2377.     return expr + "[" + index + "]";
  2378. }
  2379.  
  2380. // Return default index base
  2381. int GDBAgent::default_index_base() const
  2382. {
  2383.     switch (program_language())
  2384.     {
  2385.     case LANGUAGE_FORTRAN:
  2386.     case LANGUAGE_PASCAL:
  2387.     case LANGUAGE_CHILL:
  2388.     return 1;
  2389.  
  2390.     case LANGUAGE_ADA:
  2391.     case LANGUAGE_C:
  2392.     case LANGUAGE_JAVA:
  2393.     case LANGUAGE_PYTHON:
  2394.     case LANGUAGE_PERL:
  2395.     case LANGUAGE_OTHER:
  2396.     return 0;
  2397.     }
  2398.  
  2399.     return 0;            // Never reached
  2400. }
  2401.  
  2402. // Return member separator
  2403. string GDBAgent::member_separator() const
  2404. {
  2405.     switch (program_language())
  2406.     {
  2407.     case LANGUAGE_FORTRAN:
  2408.     case LANGUAGE_PASCAL:
  2409.     case LANGUAGE_CHILL:
  2410.     case LANGUAGE_C:
  2411.     case LANGUAGE_PYTHON:
  2412.     case LANGUAGE_OTHER:
  2413.     case LANGUAGE_JAVA:
  2414.     return " = ";
  2415.  
  2416.     case LANGUAGE_ADA:
  2417.     case LANGUAGE_PERL:
  2418.     return " => ";
  2419.     }
  2420.  
  2421.     return "";            // Never reached
  2422. }
  2423.  
  2424. // Return assignment command
  2425. string GDBAgent::assign_command(string var, string expr) const
  2426. {
  2427.     string cmd;
  2428.  
  2429.     switch (type())
  2430.     {
  2431.     case GDB:
  2432.     cmd = "set variable";
  2433.     break;
  2434.  
  2435.     case DBX:
  2436.     cmd = "assign";
  2437.     break;
  2438.  
  2439.     case XDB:
  2440.     cmd = "pq";
  2441.     break;
  2442.  
  2443.     case PYDB:
  2444.     cmd = "";        // No command needed
  2445.     break;
  2446.  
  2447.     case PERL:
  2448.     if (var != "" || !is_perl_prefix(var[0]))
  2449.         return "";        // Cannot set this
  2450.  
  2451.     cmd = "";        // No command needed
  2452.     break;
  2453.  
  2454.     case JDB:
  2455.     return "";        // Not available
  2456.     }
  2457.  
  2458.     cmd += " " + var + " ";
  2459.  
  2460.     switch (program_language())
  2461.     {
  2462.     case LANGUAGE_C:
  2463.     case LANGUAGE_JAVA:
  2464.     case LANGUAGE_FORTRAN:
  2465.     case LANGUAGE_PYTHON:    // FIXME: vrbl names can conflict with commands
  2466.     case LANGUAGE_PERL:
  2467.     case LANGUAGE_OTHER:
  2468.     cmd += "=";
  2469.     break;
  2470.  
  2471.     case LANGUAGE_ADA:
  2472.     case LANGUAGE_PASCAL:
  2473.     case LANGUAGE_CHILL:
  2474.     cmd += ":=";
  2475.     break;
  2476.     }
  2477.  
  2478.     return cmd + " " + expr;
  2479. }
  2480.  
  2481.  
  2482. void GDBAgent::normalize_address(string& addr) const
  2483. {
  2484.     // In C, hexadecimal integers are specified by a leading "0x".
  2485.     // In Modula-2, hexadecimal integers are specified by a trailing "H".
  2486.     // In Chill, hexadecimal integers are specified by a leading "H'".
  2487.     addr.downcase();
  2488.     if (addr.contains("0", 0))
  2489.     addr = addr.after("0");
  2490.     if (addr.contains("x", 0))
  2491.     addr = addr.after("x");
  2492.     if (addr.contains("h'", 0))
  2493.     addr = addr.after("h'");
  2494.     if (addr.contains("h", -1))
  2495.     addr = addr.before(int(addr.length()) - 1);
  2496.  
  2497.     if (addr != "")
  2498.     {
  2499.     switch (program_language())
  2500.     {
  2501.     case LANGUAGE_C:
  2502.     case LANGUAGE_JAVA:
  2503.     case LANGUAGE_FORTRAN:
  2504.     case LANGUAGE_ADA:
  2505.     case LANGUAGE_PYTHON:
  2506.     case LANGUAGE_PERL:
  2507.     case LANGUAGE_OTHER:
  2508.         addr.prepend("0x");
  2509.         break;
  2510.  
  2511.     case LANGUAGE_CHILL:
  2512.         addr = "H'0" + upcase(addr);
  2513.         break;
  2514.  
  2515.     case LANGUAGE_PASCAL:
  2516.         addr = "0" + upcase(addr) + "H";
  2517.         break;
  2518.     }
  2519.     }
  2520. }
  2521.  
  2522. // Return disassemble command
  2523. string GDBAgent::disassemble_command(string start, string end) const
  2524. {
  2525.     if (type() != GDB)
  2526.     return "";
  2527.  
  2528.     normalize_address(start);
  2529.     string cmd = "disassemble " + start;
  2530.  
  2531.     if (end != "")
  2532.     {
  2533.     normalize_address(end);
  2534.     cmd += " " + end;
  2535.     }
  2536.     return cmd;
  2537. }
  2538.  
  2539.  
  2540. string GDBAgent::history_file() const
  2541. {
  2542.     switch (type())
  2543.     {
  2544.     case GDB:
  2545.     {
  2546.     char *g = getenv("GDBHISTFILE");
  2547.     if (g != 0)
  2548.         return g;
  2549.     else
  2550.         return "./.gdb_history";
  2551.     }
  2552.  
  2553.     case DBX:
  2554.     case JDB:
  2555.     case PYDB:
  2556.     case PERL:
  2557.     return "";        // Unknown
  2558.  
  2559.     case XDB:
  2560.     {
  2561.     char *g = getenv("XDBHIST");
  2562.     if (g != 0)
  2563.         return g;
  2564.     else
  2565.         return string(gethome()) + "/.xdbhist";
  2566.     }
  2567.     }
  2568.  
  2569.     return "";            // Unknown
  2570. }
  2571.  
  2572. // Return true iff A contains the word S
  2573. static bool contains_word(const string& a, const string& s)
  2574. {
  2575.     int index = -1;
  2576.     for (;;)
  2577.     {
  2578.     index = a.index(s, index + 1);
  2579.     if (index < 0)
  2580.         break;
  2581.  
  2582.     if (index > 0 && isalpha(a[index - 1]))
  2583.         continue;        // Letter before S
  2584.  
  2585.     int next = index + s.length();
  2586.     if (next < int(a.length()) && isalpha(a[next]))
  2587.         continue;        // Letter after S
  2588.  
  2589.     return true;        // Okay
  2590.     }
  2591.  
  2592.     return false;        // Not found
  2593. }
  2594.  
  2595. // Determine language from TEXT
  2596. ProgramLanguage GDBAgent::program_language(string text)
  2597. {
  2598.     text.downcase();
  2599.  
  2600.     if (type() == GDB && text.contains("language"))
  2601.     text = text.after("language");
  2602.  
  2603.     if (text.contains("\n"));
  2604.     text = text.before("\n");
  2605.  
  2606.     static struct {
  2607.     char *name;
  2608.     ProgramLanguage language;
  2609.     } language_table[] = {
  2610.     { "fortran", LANGUAGE_FORTRAN },
  2611.     { "f",       LANGUAGE_FORTRAN }, // F77, F90, F
  2612.     { "java",    LANGUAGE_JAVA },
  2613.     { "chill",   LANGUAGE_CHILL },
  2614.     { "pascal",  LANGUAGE_PASCAL },
  2615.     { "modula",  LANGUAGE_PASCAL },
  2616.     { "m",       LANGUAGE_PASCAL }, // M2, M3 or likewise
  2617.     { "ada",     LANGUAGE_ADA },
  2618.     { "python",  LANGUAGE_PYTHON },
  2619.     { "perl",    LANGUAGE_PERL },
  2620.     { "c",       LANGUAGE_C },
  2621.     { "c++",     LANGUAGE_C },
  2622.     { "auto",    LANGUAGE_OTHER }  // Keep current language
  2623.     };
  2624.  
  2625.     for (int i = 0; 
  2626.      i < int(sizeof(language_table) / sizeof(language_table[0])); i++)
  2627.     {
  2628.     if (contains_word(text, language_table[i].name))
  2629.     {
  2630.         ProgramLanguage new_language = language_table[i].language;
  2631.         if (new_language != LANGUAGE_OTHER)
  2632.         program_language(new_language);
  2633.  
  2634.         return program_language();
  2635.     }
  2636.     }
  2637.  
  2638.     // Unknown language - switch to default setting
  2639.     program_language(LANGUAGE_C);
  2640.     return program_language();
  2641. }
  2642.  
  2643.  
  2644. //-----------------------------------------------------------------------------
  2645. // Perl specials
  2646. //-----------------------------------------------------------------------------
  2647.  
  2648. void GDBAgent::split_perl_var(const string& var,
  2649.                   string& prefix,
  2650.                   string& package,
  2651.                   string& name)
  2652. {
  2653.     name = var.from(rxalpha);
  2654.     if (name == "")
  2655.     name = var.from("_");
  2656.     if (name == "")
  2657.     return;
  2658.     prefix = var.before(name);
  2659.  
  2660.     package = "";
  2661.     if (name.contains("::"))
  2662.     {
  2663.     package = name.before("::", -1);
  2664.     name = name.after(package + "::");
  2665.     }
  2666. }
  2667.  
  2668. // Bring VALUE into a form that might be recognized by DDD
  2669. void GDBAgent::munch_perl_scalar(string& value)
  2670. {
  2671.     strip_leading_space(value);
  2672.     if (value.contains("0  ", 0))
  2673.     value = value.after("0");
  2674.  
  2675.     strip_leading_space(value);
  2676.     if (value.contains(rxperlref, 0))
  2677.     value = value.before('\n');
  2678. }
  2679.  
  2680. // Bring VALUE into a form that might be recognized by DDD
  2681. void GDBAgent::munch_perl_array(string& value, bool hash)
  2682. {
  2683.     int n = value.freq('\n');
  2684.     string *lines = new string[n + 1];
  2685.     split(value, lines, n + 1, '\n');
  2686.  
  2687.     bool compact = false;
  2688.     bool first_elem = true;
  2689.     string new_value;
  2690.     bool arrow = true;
  2691.  
  2692.     for (int i = 0; i < n; i++)
  2693.     {
  2694.     string line = lines[i];
  2695.     if (!compact && line.contains(' ', 0))
  2696.         continue;        // Sub-element; ignore line
  2697.  
  2698.     strip_space(line);
  2699.  
  2700.     if (!compact && line.contains(rxint, 0))
  2701.     {
  2702.         // Strip index
  2703.         line = line.after(rxint);
  2704.  
  2705.         if (line.contains("..", 0))
  2706.         {
  2707.         // In compact representation, Perl omits individual
  2708.         // indexes, and puts a START..END index instead.
  2709.         compact = true;
  2710.         line = line.after(rxint);
  2711.         }
  2712.         strip_space(line);
  2713.     }
  2714.  
  2715.     if (!first_elem)
  2716.     {
  2717.         if (hash && arrow)
  2718.         new_value += " => ";
  2719.         else
  2720.         new_value += ", ";
  2721.         arrow = !arrow;
  2722.     }
  2723.  
  2724.     first_elem = false;
  2725.  
  2726.     new_value += line;
  2727.     }
  2728.  
  2729.     delete[] lines;
  2730.  
  2731.     if (!new_value.contains('(', 0))
  2732.     new_value = '(' + new_value + ')';
  2733.  
  2734.     value = new_value;
  2735. }
  2736.  
  2737. // Bring VALUE of VAR into a form understood by DDD
  2738. void GDBAgent::munch_value(string& value, const string& var) const
  2739. {
  2740.     while (value.contains(var + " = ", 0))
  2741.     value = value.after(" = ");
  2742.     strip_leading_space(value);
  2743.  
  2744.     if (gdb->type() != PERL || !value.contains(rxint, 0))
  2745.     return;
  2746.  
  2747.     // Special treatment
  2748.     if (var != "" && var[0] == '@')
  2749.     munch_perl_array(value, false);
  2750.     else if (var != "" && var[0] == '%')
  2751.     munch_perl_array(value, true);
  2752.     else
  2753.     munch_perl_scalar(value);
  2754. }
  2755.  
  2756.  
  2757.  
  2758. //-----------------------------------------------------------------------------
  2759. // Handle error messages
  2760. //-----------------------------------------------------------------------------
  2761.  
  2762. void GDBAgent::PanicHP(Agent *source, void *, void *call_data)
  2763. {
  2764.     string msg = (char *)call_data;
  2765.     string path = source->path();
  2766.     GDBAgent *gdb = ptr_cast(GDBAgent, source);
  2767.     if (gdb != 0)
  2768.     path = downcase(gdb->title());
  2769.     cerr << path << ": " << msg << "\n";
  2770. }
  2771.  
  2772. void GDBAgent::StrangeHP(Agent *source, void *client_data, void *call_data)
  2773. {
  2774.     string msg = (char *)call_data;
  2775.     msg.prepend("warning: ");
  2776.     PanicHP(source, client_data, (char *)msg);
  2777. }
  2778.