| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #include "phpdbg.h" |
| #include "phpdbg_help.h" |
| #include "phpdbg_prompt.h" |
| #include "zend.h" |
|
|
| ZEND_EXTERN_MODULE_GLOBALS(phpdbg) |
|
|
| |
| #define PHPDBG_COMMAND_HELP_D(name, tip, alias, action) \ |
| {PHPDBG_STRL(#name), tip, sizeof(tip)-1, alias, action, &phpdbg_prompt_commands[16], 0, NULL, (bool) 0} |
|
|
| const phpdbg_command_t phpdbg_help_commands[] = { |
| PHPDBG_COMMAND_HELP_D(aliases, "show alias list", 'a', phpdbg_do_help_aliases), |
| PHPDBG_COMMAND_HELP_D(options, "command line options", 0, NULL), |
| PHPDBG_COMMAND_HELP_D(overview, "help overview", 0, NULL), |
| PHPDBG_COMMAND_HELP_D(phpdbginit, "phpdbginit file format", 0, NULL), |
| PHPDBG_COMMAND_HELP_D(syntax, "syntax overview", 0, NULL), |
| PHPDBG_END_COMMAND |
| }; |
|
|
| |
| static void pretty_print(const char *text) |
| { |
| char *new, *q; |
|
|
| const char *prompt_escape = phpdbg_get_prompt(); |
| size_t prompt_escape_len = strlen(prompt_escape); |
| size_t prompt_len = strlen(PHPDBG_G(prompt)[0]); |
|
|
| const char *bold_on_escape = PHPDBG_G(flags) & PHPDBG_IS_COLOURED ? "\033[1m" : ""; |
| const char *bold_off_escape = PHPDBG_G(flags) & PHPDBG_IS_COLOURED ? "\033[0m" : ""; |
| size_t bold_escape_len = strlen(bold_on_escape); |
|
|
| uint32_t term_width = phpdbg_get_terminal_width(); |
| uint32_t size = 0; |
|
|
| int in_bold = 0; |
|
|
| char *last_new_blank = NULL; |
| uint32_t last_blank_count = 0; |
| uint32_t line_count = 0; |
|
|
| |
| const char *p; |
| for (p = text; *p; p++) { |
| if (UNEXPECTED(p[0] == '*') && p[1] == '*') { |
| size += bold_escape_len - 2; |
| p++; |
| } else if (UNEXPECTED(p[0] == '$') && p[1] == 'P') { |
| size += prompt_escape_len - 2; |
| p++; |
| } else if (UNEXPECTED(p[0] == '\\')) { |
| p++; |
| } |
| } |
| size += (p-text)+1; |
|
|
| new = emalloc(size); |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| for (p = text, q = new; *p; p++) { |
| if (UNEXPECTED(*p == ' ')) { |
| last_new_blank = q; |
| last_blank_count = line_count++; |
| *q++ = ' '; |
| } else if (UNEXPECTED(*p == '\n')) { |
| last_new_blank = NULL; |
| *q++ = *p; |
| last_blank_count = 0; |
| line_count = 0; |
| } else if (UNEXPECTED(p[0] == '*') && p[1] == '*') { |
| if (bold_escape_len) { |
| in_bold = !in_bold; |
| q = zend_mempcpy(q, in_bold ? bold_on_escape : bold_off_escape, bold_escape_len); |
| |
| } |
| p++; |
| } else if (UNEXPECTED(p[0] == '$') && p[1] == 'P') { |
| q = zend_mempcpy(q, prompt_escape, prompt_escape_len); |
| line_count += prompt_len; |
| p++; |
| } else if (UNEXPECTED(p[0] == '\\')) { |
| p++; |
| *q++ = *p; |
| line_count++; |
| } else { |
| *q++ = *p; |
| line_count++; |
| } |
|
|
| if (UNEXPECTED(line_count>=term_width) && last_new_blank) { |
| *last_new_blank = '\n'; |
| last_new_blank = NULL; |
| line_count -= last_blank_count; |
| last_blank_count = 0; |
| } |
| } |
| *q++ = '\0'; |
|
|
| if ((q-new)>size) { |
| phpdbg_error("Output overrun of %" PRIu32 " bytes", (uint32_t) ((q - new) - size)); |
| } |
|
|
| phpdbg_out("%s\n", new); |
| efree(new); |
| } |
|
|
| |
| void summary_print(phpdbg_command_t const * const cmd) |
| { |
| char *summary; |
| spprintf(&summary, 0, "Command: **%s** Alias: **%c** **%s**\n", cmd->name, cmd->alias, cmd->tip); |
| pretty_print(summary); |
| efree(summary); |
| } |
|
|
| |
| static const char *get_help(const char * const key) |
| { |
| const phpdbg_help_text_t *p; |
|
|
| |
| |
| |
|
|
| for (p = phpdbg_help_text; p->key; p++) { |
| if (!strcmp(p->key, key)) { |
| return p->text; |
| } |
| } |
| return ""; |
| } |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| static int get_command( |
| const char *key, size_t len, |
| phpdbg_command_t const **command, |
| phpdbg_command_t const * commands |
| ) |
| { |
| const phpdbg_command_t *c; |
| unsigned int num_matches = 0; |
|
|
| if (len == 1) { |
| for (c=commands; c->name; c++) { |
| if (c->alias == key[0]) { |
| num_matches++; |
| if ( num_matches == 1 && command) { |
| *command = c; |
| } |
| } |
| } |
| } else { |
| for (c=commands; c->name; c++) { |
| if (!strncmp(c->name, key, len)) { |
| ++num_matches; |
| if ( num_matches == 1 && command) { |
| *command = c; |
| } |
| } |
| } |
| } |
|
|
| return num_matches; |
|
|
| } |
|
|
| void phpdbg_do_help_cmd(const char *type) { |
| const char *help; |
|
|
| if (!type) { |
| pretty_print(get_help("overview!")); |
| return; |
| } |
|
|
| help = get_help(type); |
|
|
| if (!help || memcmp(help, "", sizeof("")) == SUCCESS) { |
| pretty_print(get_help("overview!")); |
| pretty_print( |
| "\nrequested help page could not be found"); |
| return; |
| } |
|
|
| pretty_print(help); |
| } |
|
|
| PHPDBG_COMMAND(help) |
| { |
| phpdbg_command_t const *cmd; |
| int n; |
|
|
| if (!param || param->type == EMPTY_PARAM) { |
| pretty_print(get_help("overview!")); |
| return SUCCESS; |
| } |
|
|
| if (param && param->type == STR_PARAM) { |
| n = get_command(param->str, param->len, &cmd, phpdbg_prompt_commands); |
|
|
| if (n==1) { |
| summary_print(cmd); |
| pretty_print(get_help(cmd->name)); |
| return SUCCESS; |
|
|
| } else if (n>1) { |
| if (param->len > 1) { |
| for (cmd=phpdbg_prompt_commands; cmd->name; cmd++) { |
| if (!strncmp(cmd->name, param->str, param->len)) { |
| summary_print(cmd); |
| } |
| } |
| pretty_print(get_help("duplicate!")); |
| return SUCCESS; |
| } else { |
| phpdbg_error("Internal help error, non-unique alias \"%c\"", param->str[0]); |
| return FAILURE; |
| } |
|
|
| } else { |
| n = get_command( param->str, param->len, &cmd, phpdbg_help_commands); |
|
|
| if (n>0) { |
| if (cmd->alias == 'a') { |
| return cmd->handler(param); |
| } else { |
| pretty_print(get_help(cmd->name)); |
| return SUCCESS; |
| } |
| } else { |
| phpdbg_error("No help topic found for %s", param->str); |
| } |
| } |
| } |
|
|
| return FAILURE; |
|
|
| } |
|
|
| PHPDBG_HELP(aliases) |
| { |
| const phpdbg_command_t *c, *c_sub; |
| int len; |
|
|
| |
| phpdbg_writeln("Below are the aliased, short versions of all supported commands"); |
|
|
| for(c = phpdbg_prompt_commands; c->name; c++) { |
| if (c->alias && c->alias != 'h') { |
| phpdbg_writeln(" %c %-20s %s", c->alias, c->name, c->tip); |
| if (c->subs) { |
| len = 20 - 1 - c->name_len; |
| for(c_sub = c->subs; c_sub->alias; c_sub++) { |
| if (c_sub->alias) { |
| phpdbg_writeln(" %c %c %s %-*s %s", |
| c->alias, c_sub->alias, c->name, len, c_sub->name, c_sub->tip); |
| } |
| } |
| } |
| } |
| } |
|
|
| |
| get_command("h", 1, &c, phpdbg_prompt_commands); |
| phpdbg_writeln(" %c %-20s %s\n", c->alias, c->name, c->tip); |
|
|
| len = 20 - 1 - c->name_len; |
| for(c_sub = c->subs; c_sub->alias; c_sub++) { |
| if (c_sub->alias) { |
| phpdbg_writeln(" %c %c %s %-*s %s", |
| c->alias, c_sub->alias, c->name, len, c_sub->name, c_sub->tip); |
| } |
| } |
|
|
| pretty_print(get_help("aliases!")); |
| return SUCCESS; |
| } |
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| #define CR "\n" |
| const phpdbg_help_text_t phpdbg_help_text[] = { |
|
|
| |
| {"overview!", CR |
| "**phpdbg** is a lightweight, powerful and easy to use debugging platform for PHP" CR |
| "It supports the following commands:" CR CR |
|
|
| "**Information**" CR |
| " **list** list PHP source" CR |
| " **info** displays information on the debug session" CR |
| " **print** show opcodes" CR |
| " **frame** select a stack frame and print a stack frame summary" CR |
| " **generator** show active generators or select a generator frame" CR |
| " **back** shows the current backtrace" CR |
| " **help** provide help on a topic" CR CR |
|
|
| "**Starting and Stopping Execution**" CR |
| " **exec** set execution context" CR |
| " **stdin** set executing script from stdin" CR |
| " **run** attempt execution" CR |
| " **step** continue execution until other line is reached" CR |
| " **continue** continue execution" CR |
| " **until** continue execution up to the given location" CR |
| " **next** continue execution up to the given location and halt on the first line after it" CR |
| " **finish** continue up to end of the current execution frame" CR |
| " **leave** continue up to end of the current execution frame and halt after the calling instruction" CR |
| " **break** set a breakpoint at the specified target" CR |
| " **watch** set a watchpoint on $variable" CR |
| " **clear** clear one or all breakpoints" CR |
| " **clean** clean the execution environment" CR CR |
|
|
| "**Miscellaneous**" CR |
| " **set** set the phpdbg configuration" CR |
| " **source** execute a phpdbginit script" CR |
| " **register** register a phpdbginit function as a command alias" CR |
| " **sh** shell a command" CR |
| " **ev** evaluate some code" CR |
| " **quit** exit phpdbg" CR CR |
|
|
| "Type **help <command>** or (**help alias**) to get detailed help on any of the above commands, " |
| "for example **help list** or **h l**. Note that help will also match partial commands if unique " |
| "(and list out options if not unique), so **help exp** will give help on the **export** command, " |
| "but **help ex** will list the summary for **exec** and **export**." CR CR |
|
|
| "Type **help aliases** to show a full alias list, including any registered phpdbginit functions" CR |
| "Type **help syntax** for a general introduction to the command syntax." CR |
| "Type **help options** for a list of phpdbg command line options." CR |
| "Type **help phpdbginit** to show how to customize the debugger environment." |
| }, |
| {"options", CR |
| "Below are the command line options supported by phpdbg" CR CR |
| |
| "**Command Line Options and Flags**" CR |
| " **Option** **Example Argument** **Description**" CR |
| " **-c** **-c**/my/php.ini Set php.ini file to load" CR |
| " **-d** **-d**memory_limit=4G Set a php.ini directive" CR |
| " **-n** Disable default php.ini" CR |
| " **-q** Suppress welcome banner" CR |
| " **-v** Enable oplog output" CR |
| " **-b** Disable colour" CR |
| " **-i** **-i**my.init Set .phpdbginit file" CR |
| " **-I** Ignore default .phpdbginit" CR |
| " **-r** Run execution context" CR |
| " **-rr** Run execution context and quit after execution (not respecting breakpoints)" CR |
| " **-e** Generate extended information for debugger/profiler" CR |
| " **-E** Enable step through eval, careful!" CR |
| " **-s** **-s=**, **-s**=foo Read code to execute from stdin with an optional delimiter" CR |
| " **-S** **-S**cli Override SAPI name, careful!" CR |
| " **-p** **-p**, **-p=func**, **-p* ** Output opcodes and quit" CR |
| " **-z** **-z**extlib Load Zend extension" CR |
| " **-h** Print the help overview" CR |
| " **-V** Print version number" CR |
| " **--** **--** arg1 arg2 Use to delimit phpdbg arguments and php $argv; append any $argv " |
| "argument after it" CR CR |
|
|
| "**Reading from stdin**" CR CR |
|
|
| "The **-s** option allows inputting a script to execute directly from stdin. The given delimiter " |
| "(\"foo\" in the example) needs to be specified at the end of the input on its own line, followed by " |
| "a line break. If **-rr** has been specified, it is allowed to omit the delimiter (**-s=**) and " |
| "it will read until EOF. See also the help entry for the **stdin** command." CR CR |
|
|
| "**Opcode output**" CR CR |
|
|
| "Outputting opcodes requires that a file path is passed as last argument. Modes of execution:" CR |
| "**-p** Outputs the main execution context" CR |
| "**-p* **Outputs all opcodes in the whole file (including classes and functions)" CR |
| "**-p=function_name** Outputs opcodes of a given function in the file" CR |
| "**-p=class_name::** Outputs opcodes of all the methods of a given class" CR |
| "**-p=class_name::method** Outputs opcodes of a given method" |
| }, |
|
|
| {"phpdbginit", CR |
| "Phpdbg uses an debugger script file to initialize the debugger context. By default, phpdbg looks " |
| "for the file named **.phpdbginit** in the current working directory. This location can be " |
| "overridden on the command line using the **-i** switch (see **help options** for a more " |
| "details)." CR CR |
|
|
| "Debugger scripts can also be executed using the **source** command." CR CR |
|
|
| "A script file can contain a sequence of valid debugger commands, comments and embedded PHP " |
| "code. " CR CR |
|
|
| "Comment lines are prefixed by the **#** character. Note that comments are only allowed in script " |
| "files and not in interactive sessions." CR CR |
|
|
| "PHP code is delimited by the start and end escape tags **<:** and **:>**. PHP code can be used " |
| "to define application context for a debugging session and also to extend the debugger by defining " |
| "and **register** PHP functions as new commands." CR CR |
|
|
| "Also note that executing a **clear** command will cause the current **phpdbginit** to be reparsed " |
| "/ reloaded." |
| }, |
|
|
| {"syntax", CR |
| "Commands start with a keyword, and some (**break**, " |
| "**info**, **set**, **print** and **list**) may include a subcommand keyword. All keywords are " |
| "lower case but also have a single letter alias that may be used as an alternative to typing in the" |
| "keyword in full. Note some aliases are uppercase, and that keywords cannot be abbreviated other " |
| "than by substitution by the alias." CR CR |
|
|
| "Some commands take an argument. Arguments are typed according to their format:" CR |
| " * **omitted**" CR |
| " * **address** **0x** followed by a hex string" CR |
| " * **number** an optionally signed number" CR |
| " * **method** a valid **Class::methodName** expression" CR |
| " * **func#op** a valid **Function name** follow by # and an integer" CR |
| " * **method#op** a valid **Class::methodName** follow by # and an integer" CR |
| " * **string** a general string" CR |
| " * **function** a valid **Function name**" CR |
| " * **file:line** a valid **filename** follow by : and an integer" CR CR |
|
|
| "In some cases the type of the argument enables the second keyword to be omitted." CR CR |
|
|
| "Type **help** for an overview of all commands and type **help <command>** to get detailed help " |
| "on any specific command." CR CR |
|
|
| "**Valid Examples**" CR CR |
|
|
| " $P quit" CR |
| " $P q" CR |
| " Quit the debugger" CR CR |
|
|
| " $P ev $total[2]" CR |
| " Evaluate and print the variable $total[2] in the current stack frame" CR |
| " " CR |
| " $P break 200" CR |
| " $P b my_source.php:200" CR |
| " Break at line 200 in the current source and in file **my_source.php**. " CR CR |
|
|
| " $P b @ ClassX::get_args if $arg[0] == \"fred\"" CR |
| " $P b ~ 3" CR |
| " Break at ClassX::get_args() if $arg[0] == \"fred\" and delete breakpoint 3" CR CR |
|
|
| "**Examples of invalid commands**" CR |
|
|
| " $P #This is a comment" CR |
| " Comments introduced by the **#** character are only allowed in **phpdbginit** script files." |
| }, |
|
|
| |
| {"aliases!", CR |
| "Note that aliases can be used for either command or sub-command keywords or both, so **info b** " |
| "is a synonym for **info break** and **l func** for **list func**, etc." CR CR |
|
|
| "Note that help will also accept any alias as a parameter and provide help on that command, for example **h p** will provide help on the print command." |
| }, |
|
|
| {"duplicate!", CR |
| "Parameter is not unique. For detailed help select help on one of the above commands." |
| }, |
|
|
| |
| {"back", |
| "Provide a formatted backtrace using the standard debug_backtrace() functionality. An optional " |
| "unsigned integer argument specifying the maximum number of frames to be traced; if omitted then " |
| "a complete backtrace is given." CR CR |
|
|
| "**Examples**" CR CR |
| " $P back 5" CR |
| " $P t " CR |
| " " CR |
| "A backtrace can be executed at any time during execution." |
| }, |
|
|
| {"break", |
| "Breakpoints can be set at a range of targets within the execution environment. Execution will " |
| "be paused if the program flow hits a breakpoint. The break target can be one of the following " |
| "types:" CR CR |
|
|
| " **Target** **Alias** **Purpose**" CR |
| " **at** **@** specify breakpoint by location and condition" CR |
| " **del** **~** delete breakpoint by breakpoint identifier number" CR CR |
|
|
| "**Break at** takes two arguments. The first is any valid target. The second " |
| "is a valid PHP expression which will trigger the break in " |
| "execution, if evaluated as true in a boolean context at the specified target." CR CR |
|
|
| "Note that breakpoints can also be disabled and re-enabled by the **set break** command." CR CR |
|
|
| "**Examples**" CR CR |
| " $P break test.php:100" CR |
| " $P b test.php:100" CR |
| " Break execution at line 100 of test.php" CR CR |
|
|
| " $P break 200" CR |
| " $P b 200" CR |
| " Break execution at line 200 of the currently PHP script file" CR CR |
|
|
| " $P break \\\\mynamespace\\\\my_function" CR |
| " $P b \\\\mynamespace\\\\my_function" CR |
| " Break execution on entry to \\\\mynamespace\\\\my_function" CR CR |
|
|
| " $P break classX::method" CR |
| " $P b classX::method" CR |
| " Break execution on entry to classX::method" CR CR |
|
|
| " $P break 0x7ff68f570e08" CR |
| " $P b 0x7ff68f570e08" CR |
| " Break at the opline at the address 0x7ff68f570e08" CR CR |
|
|
| " $P break my_function#14" CR |
| " $P b my_function#14" CR |
| " Break at the opline #14 of the function my_function" CR CR |
|
|
| " $P break \\\\my\\\\class::method#2" CR |
| " $P b \\\\my\\\\class::method#2" CR |
| " Break at the opline #2 of the method \\\\my\\\\class::method" CR CR |
|
|
| " $P break test.php:#3" CR |
| " $P b test.php:#3" CR |
| " Break at opline #3 in test.php" CR CR |
|
|
| " $P break if $cnt > 10" CR |
| " $P b if $cnt > 10" CR |
| " Break when the condition ($cnt > 10) evaluates to true" CR CR |
|
|
| " $P break at phpdbg::isGreat if $opt == 'S'" CR |
| " $P break @ phpdbg::isGreat if $opt == 'S'" CR |
| " Break at any opcode in phpdbg::isGreat when the condition ($opt == 'S') is true" CR CR |
|
|
| " $P break at test.php:20 if !isset($x)" CR |
| " Break at every opcode on line 20 of test.php when the condition evaluates to true" CR CR |
|
|
| " $P break ZEND_ADD" CR |
| " $P b ZEND_ADD" CR |
| " Break on any occurrence of the opcode ZEND_ADD" CR CR |
|
|
| " $P break del 2" CR |
| " $P b ~ 2" CR |
| " Remove breakpoint 2" CR CR |
|
|
| "Note: Conditional breaks are costly in terms of runtime overhead. Use them only when required " |
| "as they significantly slow execution." CR CR |
|
|
| "Note: An address is only valid for the current compilation." |
| }, |
|
|
| {"clean", |
| "Classes, constants or functions can only be declared once in PHP. You may experience errors " |
| "during a debug session if you attempt to recompile a PHP source. The clean command clears " |
| "the Zend runtime tables which holds the sets of compiled classes, constants and functions, " |
| "releasing any associated storage back into the storage pool. This enables recompilation to " |
| "take place." CR CR |
|
|
| "Note that you cannot selectively trim any of these resource pools. You can only do a complete " |
| "clean." |
| }, |
|
|
| {"clear", |
| "Clearing breakpoints means you can once again run code without interruption." CR CR |
|
|
| "Note: use break delete N to clear a specific breakpoint." CR CR |
|
|
| "Note: if all breakpoints are cleared, then the PHP script will run until normal completion." |
| }, |
|
|
| {"ev", |
| "The **ev** command takes a string expression which it evaluates and then displays. It " |
| "evaluates in the context of the lowest (that is the executing) frame, unless this has first " |
| "been explicitly changed by issuing a **frame** command. " CR CR |
|
|
| "**Examples**" CR CR |
| " $P ev $variable" CR |
| " Will print_r($variable) on the console, if it is defined" CR CR |
|
|
| " $P ev $variable = \"Hello phpdbg :)\"" CR |
| " Will set $variable in the current scope" CR CR |
|
|
| "Note that **ev** allows any valid PHP expression including assignments, function calls and " |
| "other write statements. This enables you to change the environment during execution, so care " |
| "is needed here. You can even call PHP functions which have breakpoints defined. " CR CR |
|
|
| "Note: **ev** will always show the result, so do not prefix the code with **return**" |
| }, |
|
|
| {"exec", |
| "The **exec** command sets the execution context, that is the script to be executed. The " |
| "execution context must be defined either by executing the **exec** command or by using the " |
| "**-e** command line option." CR CR |
|
|
| "Note that the **exec** command also can be used to replace a previously defined execution " |
| "context." CR CR |
|
|
| "**Examples**" CR CR |
|
|
| " $P exec /tmp/script.php" CR |
| " $P e /tmp/script.php" CR |
| " Set the execution context to **/tmp/script.php**" |
| }, |
|
|
| {"stdin", |
| "The **stdin** command takes a string serving as delimiter. It will then read all the input from " |
| "stdin until encountering the given delimiter on a standalone line. It can also be passed at " |
| "startup using the **-s=** command line option (the delimiter then is optional if **-rr** is " |
| "also passed - in that case it will just read until EOF)." CR |
| "This input will be then compiled as PHP code and set as execution context." CR CR |
|
|
| "**Example**" CR CR |
|
|
| " $P stdin foo" CR |
| " <?php" CR |
| " echo \"Hello, world!\\n\";" CR |
| " foo" |
| }, |
|
|
| |
| {"finish", |
| "The **finish** command causes control to be passed back to the vm, continuing execution. Any " |
| "breakpoints that are encountered within the current stack frame will be skipped. Execution " |
| "will then continue until the next breakpoint after leaving the stack frame or until " |
| "completion of the script" CR CR |
|
|
| "Note when **step**ping is enabled, any opcode steps within the current stack frame are also " |
| "skipped. "CR CR |
|
|
| "Note **finish** will trigger a \"not executing\" error if not executing." |
| }, |
|
|
| {"frame", |
| "The **frame** takes an optional integer argument. If omitted, then the current frame is displayed. " |
| "If specified, then the current scope is set to the corresponding frame listed in a **back** trace. " |
| "This can be used to allowing access to the variables in a higher stack frame than that currently being executed." CR CR |
|
|
| "**Examples**" CR CR |
| " $P frame 2" CR |
| " $P ev $count" CR |
| " Go to frame 2 and print out variable **$count** in that frame" CR CR |
|
|
| "Note that this frame scope is discarded when execution continues, with the execution frame " |
| "then reset to the lowest executing frame." |
| }, |
|
|
| {"generator", |
| "The **generator** command takes an optional integer argument. If omitted, then a list of the " |
| "currently active generators is displayed. If specified then the current scope is set to the frame " |
| "of the generator with the corresponding object handle. This can be used to inspect any generators " |
| "not in the current **back** trace." CR CR |
|
|
| "**Examples**" CR CR |
| " $P generator" CR |
| " List of generators, with the #id being the object handle, e.g.:" CR |
| " #3: my_generator(argument=\"value\") at test.php:5" CR |
| " $P g 3" CR |
| " $P ev $i" CR |
| " Go to frame of generator with object handle 3 and print out variable **$i** in that frame" CR CR |
|
|
| "Note that this frame scope is discarded when execution continues, with the execution frame " |
| "then reset to the lowest executing frame." |
| }, |
|
|
| {"info", |
| "**info** commands provide quick access to various types of information about the PHP environment" CR |
| "By default general information about environment and PHP build is shown." CR |
| "Specific info commands are show below:" CR CR |
|
|
| " **Target** **Alias** **Purpose**" CR |
| " **break** **b** show current breakpoints" CR |
| " **files** **F** show included files" CR |
| " **classes** **c** show loaded classes" CR |
| " **funcs** **f** show loaded functions" CR |
| " **error** **e** show last error" CR |
| " **constants** **d** show user-defined constants" CR |
| " **vars** **v** show active variables" CR |
| " **globals** **g** show superglobal variables" CR |
| " **literal** **l** show active literal constants" CR |
| " **memory** **m** show memory manager stats" |
| }, |
|
|
| |
| {"leave", |
| "The **leave** command causes control to be passed back to the vm, continuing execution. Any " |
| "breakpoints that are encountered within the current stack frame will be skipped. In effect a " |
| "temporary breakpoint is associated with any return opcode, so that a break in execution occurs " |
| "before leaving the current stack frame. This allows inspection / modification of any frame " |
| "variables including the return value before it is returned" CR CR |
|
|
| "**Examples**" CR CR |
|
|
| " $P leave" CR |
| " $P L" CR CR |
|
|
| "Note when **step**ping is enabled, any opcode steps within the current stack frame are also " |
| "skipped. "CR CR |
|
|
| "Note **leave** will trigger a \"not executing\" error if not executing." |
| }, |
|
|
| {"list", |
| "The list command displays source code for the given argument. The target type is specified by " |
| "a second subcommand keyword:" CR CR |
|
|
| " **Type** **Alias** **Purpose**" CR |
| " **lines** **l** List N lines from the current execution point" CR |
| " **func** **f** List the complete source for a specified function" CR |
| " **method** **m** List the complete source for a specified class::method" CR |
| " **class** **c** List the complete source for a specified class" CR CR |
|
|
| "Note that the context of **lines**, **func** and **method** can be determined by parsing the " |
| "argument, so these subcommands are optional. However, you must specify the **class** keyword " |
| "to list off a class." CR CR |
|
|
| "**Examples**" CR CR |
| " $P list 2" CR |
| " $P l l 2" CR |
| " List the next 2 lines from the current file" CR CR |
|
|
| " $P list my_function" CR |
| " $P l f my_function" CR |
| " List the source of the function **my_function**" CR CR |
|
|
| |
| " $P list func .mine" CR |
| " $P l f .mine" CR |
| " List the source of the method **mine** from the active class in scope" CR CR |
|
|
| " $P list m my::method" CR |
| " $P l my::method" CR |
| " List the source of **my::method**" CR CR |
|
|
| " $P list c myClass" CR |
| " $P l c myClass" CR |
| " List the source of **myClass**" CR CR |
|
|
| "Note that functions and classes can only be listed if the corresponding classes and functions " |
| "table in the Zend executor has a corresponding entry. You can use the compile command to " |
| "populate these tables for a given execution context." |
| }, |
|
|
| {"continue", |
| "Continue with execution after hitting a break or watchpoint" CR CR |
|
|
| "**Examples**" CR CR |
| " $P continue" CR |
| " $P c" CR |
| " Continue executing until the next break or watchpoint" CR CR |
|
|
| "Note **continue** will trigger a \"not running\" error if not executing." |
| }, |
|
|
| {"print", |
| "By default, print will show the opcodes of the current execution context." CR |
| "Other printing commands give access to instruction information." CR |
| "Specific printers loaded are show below:" CR CR |
|
|
| " **Type** **Alias** **Purpose**" CR |
| " **exec** **e** print out the instructions in the execution context" CR |
| " **opline** **o** print out the instruction in the current opline" CR |
| " **class** **c** print out the instructions in the specified class" CR |
| " **method** **m** print out the instructions in the specified method" CR |
| " **func** **f** print out the instructions in the specified function" CR |
| " **stack** **s** print out the instructions in the current stack" CR CR |
|
|
| "In case passed argument does not match a specific printing command, it will treat it as function or method name and print its opcodes" CR CR |
|
|
| "**Examples**" CR CR |
| " $P print class \\\\my\\\\class" CR |
| " $P p c \\\\my\\\\class" CR |
| " Print the instructions for the methods in \\\\my\\\\class" CR CR |
|
|
| " $P print method \\\\my\\\\class::method" CR |
| " $P p m \\\\my\\\\class::method" CR |
| " Print the instructions for \\\\my\\\\class::method" CR CR |
|
|
| " $P print func .getSomething" CR |
| " $P p f .getSomething" CR |
| |
| " Print the instructions for ::getSomething in the active scope" CR CR |
|
|
| " $P print func my_function" CR |
| " $P p f my_function" CR |
| " Print the instructions for the global function my_function" CR CR |
|
|
| " $P print opline" CR |
| " $P p o" CR |
| " Print the instruction for the current opline" CR CR |
|
|
| " $P print exec" CR |
| " $P p e" CR |
| " Print the instructions for the execution context" CR CR |
|
|
| " $P print stack" CR |
| " $P p s" CR |
| " Print the instructions for the current stack" |
| }, |
|
|
| {"register", |
| |
| "Register any global function for use as a command in phpdbg console" CR CR |
|
|
| "**Examples**" CR CR |
| " $P register scandir" CR |
| " $P R scandir" CR |
| " Will register the scandir function for use in phpdbg" CR CR |
|
|
| "Note: arguments passed as strings, return (if present) print_r'd on console" |
| }, |
|
|
| {"run", |
| "Enter the vm, starting execution. Execution will then continue until the next breakpoint " |
| "or completion of the script. Add parameters you want to use as $argv. Add a trailing " |
| "**< filename** for reading STDIN from a file." CR CR |
|
|
| "**Examples**" CR CR |
|
|
| " $P run" CR |
| " $P r" CR |
| " Will cause execution of the context, if it is set" CR CR |
| " $P r test < foo.txt" CR |
| " Will execute with $argv[1] == \"test\" and read from the foo.txt file for STDIN" CR CR |
|
|
| "Note that the execution context must be set. If not previously compiled, then the script will " |
| "be compiled before execution." |
| }, |
|
|
| {"set", |
| "The **set** command is used to configure how phpdbg looks and behaves. Specific set commands " |
| "are as follows:" CR CR |
|
|
| " **Type** **Alias** **Purpose**" CR |
| " **prompt** **p** set the prompt" CR |
| " **color** **c** set color <element> <color>" CR |
| " **colors** **C** set colors [<on|off>]" CR |
| " **break** **b** set break **id** <on|off>" CR |
| " **breaks** **B** set breaks [<on|off>]" CR |
| " **quiet** **q** set quiet [<on|off>]" CR |
| " **stepping** **s** set stepping [<opcode|line>]" CR |
| " **refcount** **r** set refcount [<on|off>] " CR CR |
|
|
| "Valid colors are **none**, **white**, **red**, **green**, **yellow**, **blue**, **purple**, " |
| "**cyan** and **black**. All colours except **none** can be followed by an optional " |
| "**-bold** or **-underline** qualifier." CR CR |
|
|
| "Color elements can be one of **prompt**, **notice**, or **error**." CR CR |
|
|
| "**Examples**" CR CR |
| " $P S C on" CR |
| " Set colors on" CR CR |
|
|
| " $P set p >" CR |
| " $P set color prompt white-bold" CR |
| " Set the prompt to a bold >" CR CR |
|
|
| " $P S c error red-bold" CR |
| " Use red bold for errors" CR CR |
|
|
| " $P S refcount on" CR |
| " Enable refcount display when hitting watchpoints" CR CR |
|
|
| " $P S b 4 off" CR |
| " Temporarily disable breakpoint 4. This can be subsequently re-enabled by a **S b 4 on**." CR |
| |
| }, |
|
|
| {"sh", |
| "Direct access to shell commands saves having to switch windows/consoles" CR CR |
|
|
| "**Examples**" CR CR |
| " $P sh ls /usr/src/php-src" CR |
| " Will execute ls /usr/src/php-src, displaying the output in the console" |
| |
| }, |
|
|
| {"source", |
| "Sourcing a **phpdbginit** script during your debugging session might save some time." CR CR |
|
|
| "**Examples**" CR CR |
|
|
| " $P source /my/init" CR |
| " $P < /my/init" CR |
| " Will execute the phpdbginit file at /my/init" CR CR |
| }, |
|
|
| {"export", |
| "Exporting breakpoints allows you to share, and or save your current debugging session" CR CR |
|
|
| "**Examples**" CR CR |
|
|
| " $P export /my/exports" CR |
| " $P > /my/exports" CR |
| " Will export all breakpoints to /my/exports" CR CR |
| }, |
|
|
| {"step", |
| "Execute opcodes until next line" CR CR |
|
|
| "**Examples**" CR CR |
|
|
| " $P s" CR |
| " Will continue and break again in the next encountered line" CR CR |
| }, |
| {"next", |
| "The **next** command causes control to be passed back to the vm, continuing execution. Any " |
| "breakpoints that are encountered before the next source line will be skipped. Execution will" |
| "be stopped when that line is left." CR CR |
|
|
| "Note when **step**ping is enabled, any opcode steps within the current line are also skipped. "CR CR |
|
|
| "Note that if the next line is **not** executed then **all** subsequent breakpoints will be " |
| "skipped. " CR CR |
|
|
| "Note **next** will trigger a \"not executing\" error if not executing." |
|
|
| }, |
| {"until", |
| "The **until** command causes control to be passed back to the vm, continuing execution. Any " |
| "breakpoints that are encountered before the next source line will be skipped. Execution " |
| "will then continue until the next breakpoint or completion of the script" CR CR |
|
|
| "Note when **step**ping is enabled, any opcode steps within the current line are also skipped. "CR CR |
|
|
| "Note that if the next line is **not** executed then **all** subsequent breakpoints will be " |
| "skipped. " CR CR |
|
|
| "Note **until** will trigger a \"not executing\" error if not executing." |
|
|
| }, |
| {"watch", |
| "Sets watchpoints on variables as long as they are defined" CR |
| "Passing no parameter to **watch**, lists all actually active watchpoints" CR CR |
|
|
| "**Format for $variable**" CR CR |
| " **$var** Variable $var" CR |
| " **$var[]** All array elements of $var" CR |
| " **$var->** All properties of $var" CR |
| " **$var->a** Property $var->a" CR |
| " **$var[b]** Array element with key b in array $var" CR CR |
|
|
| "Subcommands of **watch**:" CR CR |
|
|
| " **Type** **Alias** **Purpose**" CR |
| " **array** **a** Sets watchpoint on array/object to observe if an entry is added or removed" CR |
| " **recursive** **r** Watches variable recursively and automatically adds watchpoints if some entry is added to an array/object" CR |
| " **delete** **d** Removes watchpoint" CR CR |
|
|
| "Note when **recursive** watchpoints are removed, watchpoints on all the children are removed too" CR CR |
|
|
| "**Examples**" CR CR |
| " $P watch" CR |
| " List currently active watchpoints" CR CR |
|
|
| " $P watch $array" CR |
| " $P w $array" CR |
| " Set watchpoint on $array" CR CR |
|
|
| " $P watch recursive $obj->" CR |
| " $P w r $obj->" CR |
| " Set recursive watchpoint on $obj->" CR CR |
|
|
| " $P watch delete $obj->a" CR |
| " $P w d $obj->a" CR |
| " Remove watchpoint $obj->a" CR CR |
|
|
| "Technical note: If using this feature with a debugger, you will get many segmentation faults, each time when a memory page containing a watched address is hit." CR |
| " You then you can continue, phpdbg will remove the write protection, so that the program can continue." CR |
| " If phpdbg could not handle that segfault, the same segfault is triggered again and this time phpdbg will abort." |
| }, |
| {NULL, NULL } |
| }; |
|
|
