C++ DebuggerClient::helpCmds方法代码示例

void CmdOut::help(DebuggerClient &client) {
  client.helpTitle("Out Command");
  client.helpCmds(
    "[o]ut {count=1}", "steps out function calls",
    nullptr
  );
  client.helpBody(
    "Use this command at break to step out function calls. Specify a "
    "count to step out more than one level of function calls."
  );
}

void CmdContinue::help(DebuggerClient &client) {
  client.helpTitle("Continue Command");
  client.helpCmds(
    "[c]ontinue {count=1}", "continues program execution",
    nullptr
  );
  client.helpBody(
    "Use this command at break to resume program execution. Specify a "
    "count to repeat the same command many times."
  );
}

// The text to display when the debugger client processes "help quit".
void CmdQuit::help(DebuggerClient &client) {
  TRACE(2, "CmdQuit::help\n");
  client.helpTitle("Quit Command");
  client.helpCmds(
    "[q]uit", "quits this program",
    nullptr
  );
  client.helpBody(
    "After you type this command, you will not see me anymore."
  );
}

void CmdNext::help(DebuggerClient& client) {
  client.helpTitle("Next Command");
  client.helpCmds(
    "[n]ext {count=1}", "steps over lines of code",
    nullptr
  );
  client.helpBody(
    "Use this command at break to step over lines of code. Specify a "
    "count to step over more than one line of code."
  );
}

void CmdStep::help(DebuggerClient &client) {
  client.helpTitle("Step Command");
  client.helpCmds(
    "[s]tep {count=1}", "steps into lines of code",
    nullptr
  );
  client.helpBody(
    "Use this command at break to step into lines of code. Specify a "
    "count to step more than once."
  );
}

void CmdMachine::help(DebuggerClient &client) {
  client.helpTitle("Machine Command");
  client.helpCmds(
    "[m]achine [c]onnect {host}",         "debugging remote server natively",
    "[m]achine [c]onnect {host}:{port}",  "debugging remote server natively",
    "[m]achine [r]pc {host}",             "debugging remote server with RPC",
    "[m]achine [r]pc {host}:{port}",      "debugging remote server with RPC",
    "[m]achine [d]isconnect",             "disconnect, debugging local script",
    "[m]achine [l]ist",                   "list all sandboxes",
    "[m]achine [a]ttach {index}",         "attach to a sandbox",
    "[m]achine [a]ttach {sandbox}",       "attach to my sandbox by name",
    "[m]achine [a]ttach {user} {sandbox}",
    "attach to a sandbox by user and name",
    "[m]achine [a]ttach [f]orce {index|sandbox|user sandbox}",
    "force attach to a sandbox (see below)",
    nullptr
  );
  client.helpBody(
    "Use this command to switch between different machines or "
    "sandboxes.\n"
    "\n"
    "If command prompt says \"hphpd\", all evaluation of PHP code happens "
    "locally within the debugger. This is the mode when debugger is started "
    "without a remote server name. No user libraries are pre-loaded in this "
    "mode.\n"
    "\n"
    "When connecting to a remote server, it will automatically attach "
    "to \"default\" sandbox under current user. If \"default\" sandbox "
    "does not exist, it will attach to a random sandbox under current "
    "user. In sandbox mode, a file specified in server's configuration "
    "of \"Eval.Debugger.StartupDocument\" is pre-loaded.\n"
    "\n"
    "If there is no sandbox available, it will create a \"dummy\" "
    "sandbox and attach to it.\n"
    "\n"
    "When your sandbox is not available, please hit it at least once "
    "from your browser. Then run '[m]achine [l]ist' command again.\n"
    "\n"
    "If another debugger client is already attached to your sandbox you can "
    "use the '[f]orce' option to '[m]achine [a]ttach'. This will disconnect "
    "the other client and force your client to connect.\n"
    "\n"
    "If a HipHop server has RPC port open, one can also debug the server in "
    "a very special RPC mode. In this mode, one can type in PHP scripts to "
    "run, but all functions will be executed on server through RPC. Because "
    "states are still maintained locally and only functions are executed "
    "remotely, it may not work with functions or scripts that depend on "
    "global variables or low-level raw resource pointers. As a simple rule, "
    "stateless functions will work just fine. This is true to objects and "
    "method calls as well, except classes will have to be loaded on client "
    "side by '=include(\"file-containing-the-class.php\")'."
  );
}

void CmdFrame::help(DebuggerClient &client) {
  client.helpTitle("Frame Command");
  client.helpCmds(
    "[f]rame {index}",  "jumps to one particular frame",
    nullptr
  );
  client.helpBody(
    "Use '[w]here' command to find out the frame number. Use 'f 0' to jump "
    "back to the most recent frame or the innermost frame. Use 'f 999' or "
    "some big number to jump to the outermost frame."
  );
}

void CmdDown::help(DebuggerClient &client) {
  client.helpTitle("Down Command");
  client.helpCmds(
    "[d]own {num=1}", "moves to inner frames (callees) on stacktrace",
    nullptr
  );
  client.helpBody(
    "Use this command to walk down on stacktrace to find out inner callees of "
    "current frame. By default it moves down by one level. Specify a number "
    "to move down several levels a time."
  );
}

void CmdWhere::help(DebuggerClient &client) {
  client.helpTitle("Where Command");
  client.helpCmds(
    "[w]here",           "displays current stacktrace",
    "[w]here {num}",     "displays number of innermost frames",
    "[w]here -{num}",    "displays number of outermost frames",
    nullptr
  );
  client.helpBody(
    "Use '[u]p {num}' or '[d]own {num}' to walk up or down the stacktrace. "
    "Use '[f]rame {index}' to jump to one particular frame. At any frame, "
    "use '[v]ariable' command to display all local variables."
  );
}

void CmdGlobal::help(DebuggerClient &client) {
  client.helpTitle("Global Command");
  client.helpCmds(
    "[g]lobal",           "lists all global variables",
    "[g]lobal {text}",    "full-text search global variables",
    nullptr
  );
  client.helpBody(
    "This will print names and values of all global variables, if {text} is "
    "not speified. Otherwise, it will print global variables that contain the "
    "text in their names or values. The search is case-insensitive and "
    "string-based."
  );
}

void CmdZend::help(DebuggerClient &client) {
  client.helpTitle("Zend Command");
  client.helpCmds(
    "[z]end", "running the most recent code snippet in Zend PHP",
    nullptr
  );
  client.helpBody(
    "This is mainly for comparing results from PHP vs. HipHop. After you type "
    "in some PHP code, it will be evaluated immediately in HipHop. Then you "
    "can type '[z]end' command to re-run the same script with your "
    "system-default PHP. Please note that only the most recent block of code "
    "you manually typed in is evaluated, not any earlier ones, nor the ones "
    "from a PHP file."
  );
}

void CmdExtension::help(DebuggerClient &client) {
  client.helpTitle("Extension Command");
  client.helpCmds(
    "x [t]ension",                 "lists all extensions",
    "x [t]ension {name}",          "shows summary info of the extension",
    "x [t]ension {name} dump",     "shows detailed info of the extension",
    "x [t]ension {name} {verb} {args} ...",   "executes an action",
    nullptr
  );
  client.helpBody(
    "In PHP, a lot of library functions are implemented as \"extensions\". "
    "This command allows extensions to support debugger by providing their "
    "version numbers, current status and cached data and by providing "
    "additional verbs to update runtime states for debugging purposes."
  );
}

void CmdInstrument::help(DebuggerClient &client) {
  client.helpTitle("Instrument Command");
  // TODO: more functionalities
  client.helpCmds("inst here <file> [desc]",
                   "inject <file> to here",
                   "inst <func>() <file> [desc]",
                   "inject <file> to the entry point of <func>",
                   "inst [l]ist",
                   "list injections",
                   "inst [c]lear",
                   "clear all injections",
                   nullptr);
  client.helpBody(
    "Use this command to instrument the program"
  );
}

void CmdRun::help(DebuggerClient &client) {
  client.helpTitle("Run Command");
  client.helpCmds(
    "[r]un",                             "restarts program",
    "[r]un {file} {arg1} {arg2} ...",    "starts a new program",
    nullptr
  );
  client.helpBody(
    "Aborts current execution and restarts program with specified arguments. "
    "If no arguments are specified, it will reuse the PHP file and old "
    "arguments. If arguments are to be changed, please include file name, "
    "even if it is the same, as the first one.\n"
    "\n"
    "In server mode, this command will simply abort current page handling "
    "without restarting anything."
  );
}

void CmdInternalTesting::help(DebuggerClient &client) {
  TRACE(2, "CmdInternalTesting::help\n");
  client.helpTitle("Internal Testing Command");
  client.helpCmds(
    "badcmdtypesend", "Send a bad command type to the proxy",
    "badcmdtypereceive", "Receive a bad command type from the proxy",
    "shortcmdsend", "Send less data that the proxy expects",
    "shortcmdreceive", "Receive less data than the client expects",
    "segfaultClient", "Segfault on the client",
    "segfaultServer", "Segfault on the server",
    nullptr
  );
  client.helpBody(
    "This command is only for internal testing of the debugger, both client "
    "and server. If you're using this command and you're not trying to test "
    "the debugger, then you're making a really big mistake."
  );
}