| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #include "zend.h" |
|
|
| #include "php.h" |
| #include "phpdbg.h" |
| #include "phpdbg_utils.h" |
| #include "ext/standard/php_string.h" |
|
|
| |
| #ifdef HAVE_SYS_FILE_H |
| # include <sys/file.h> |
| #endif |
|
|
| #ifdef HAVE_SYS_IOCTL_H |
| # include "sys/ioctl.h" |
| # ifndef GWINSZ_IN_SYS_IOCTL |
| # include <termios.h> |
| # endif |
| #endif |
|
|
| ZEND_EXTERN_MODULE_GLOBALS(phpdbg) |
|
|
| |
| static const phpdbg_color_t colors[] = { |
| PHPDBG_COLOR_D("none", "0;0"), |
|
|
| PHPDBG_COLOR_D("white", "0;64"), |
| PHPDBG_COLOR_D("white-bold", "1;64"), |
| PHPDBG_COLOR_D("white-underline", "4;64"), |
| PHPDBG_COLOR_D("red", "0;31"), |
| PHPDBG_COLOR_D("red-bold", "1;31"), |
| PHPDBG_COLOR_D("red-underline", "4;31"), |
| PHPDBG_COLOR_D("green", "0;32"), |
| PHPDBG_COLOR_D("green-bold", "1;32"), |
| PHPDBG_COLOR_D("green-underline", "4;32"), |
| PHPDBG_COLOR_D("yellow", "0;33"), |
| PHPDBG_COLOR_D("yellow-bold", "1;33"), |
| PHPDBG_COLOR_D("yellow-underline", "4;33"), |
| PHPDBG_COLOR_D("blue", "0;34"), |
| PHPDBG_COLOR_D("blue-bold", "1;34"), |
| PHPDBG_COLOR_D("blue-underline", "4;34"), |
| PHPDBG_COLOR_D("purple", "0;35"), |
| PHPDBG_COLOR_D("purple-bold", "1;35"), |
| PHPDBG_COLOR_D("purple-underline", "4;35"), |
| PHPDBG_COLOR_D("cyan", "0;36"), |
| PHPDBG_COLOR_D("cyan-bold", "1;36"), |
| PHPDBG_COLOR_D("cyan-underline", "4;36"), |
| PHPDBG_COLOR_D("black", "0;30"), |
| PHPDBG_COLOR_D("black-bold", "1;30"), |
| PHPDBG_COLOR_D("black-underline", "4;30"), |
| PHPDBG_COLOR_END |
| }; |
|
|
| |
| static const phpdbg_element_t elements[] = { |
| PHPDBG_ELEMENT_D("prompt", PHPDBG_COLOR_PROMPT), |
| PHPDBG_ELEMENT_D("error", PHPDBG_COLOR_ERROR), |
| PHPDBG_ELEMENT_D("notice", PHPDBG_COLOR_NOTICE), |
| PHPDBG_ELEMENT_END |
| }; |
|
|
| PHPDBG_API int phpdbg_is_numeric(const char *str) |
| { |
| if (!str) |
| return 0; |
|
|
| for (; *str; str++) { |
| if (isspace(*str) || *str == '-') { |
| continue; |
| } |
| return isdigit(*str); |
| } |
| return 0; |
| } |
|
|
| PHPDBG_API int phpdbg_is_empty(const char *str) |
| { |
| if (!str) |
| return 1; |
|
|
| for (; *str; str++) { |
| if (isspace(*str)) { |
| continue; |
| } |
| return 0; |
| } |
| return 1; |
| } |
|
|
| PHPDBG_API int phpdbg_is_addr(const char *str) |
| { |
| return str[0] && str[1] && memcmp(str, "0x", 2) == 0; |
| } |
|
|
| PHPDBG_API int phpdbg_is_class_method(const char *str, size_t len, char **class, char **method) |
| { |
| char *sep = NULL; |
|
|
| if (strstr(str, "#") != NULL) |
| return 0; |
|
|
| if (strstr(str, " ") != NULL) |
| return 0; |
|
|
| sep = strstr(str, "::"); |
|
|
| if (!sep || sep == str || sep+2 == str+len-1) { |
| return 0; |
| } |
|
|
| if (class != NULL) { |
|
|
| if (str[0] == '\\') { |
| str++; |
| len--; |
| } |
|
|
| *class = estrndup(str, sep - str); |
| (*class)[sep - str] = 0; |
| } |
|
|
| if (method != NULL) { |
| *method = estrndup(sep+2, str + len - (sep + 2)); |
| } |
|
|
| return 1; |
| } |
|
|
| PHPDBG_API char *phpdbg_resolve_path(const char *path) |
| { |
| char resolved_name[MAXPATHLEN]; |
|
|
| if (expand_filepath(path, resolved_name) == NULL) { |
| return NULL; |
| } |
|
|
| return strdup(resolved_name); |
| } |
|
|
| PHPDBG_API const char *phpdbg_current_file(void) |
| { |
| const char *file = zend_get_executed_filename(); |
|
|
| if (memcmp(file, "[no active file]", sizeof("[no active file]")) == 0) { |
| return PHPDBG_G(exec); |
| } |
|
|
| return file; |
| } |
|
|
| PHPDBG_API const zend_function *phpdbg_get_function(const char *fname, const char *cname) |
| { |
| zend_function *func = NULL; |
| zend_string *lfname = zend_string_init(fname, strlen(fname), 0); |
| zend_string *tmp = zend_string_tolower(lfname); |
| zend_string_release(lfname); |
| lfname = tmp; |
|
|
| if (cname) { |
| zend_class_entry *ce; |
| zend_string *lcname = zend_string_init(cname, strlen(cname), 0); |
| tmp = zend_string_tolower(lcname); |
| zend_string_release(lcname); |
| lcname = tmp; |
| ce = zend_lookup_class(lcname); |
|
|
| zend_string_release(lcname); |
|
|
| if (ce) { |
| func = zend_hash_find_ptr(&ce->function_table, lfname); |
| } |
| } else { |
| func = zend_hash_find_ptr(EG(function_table), lfname); |
| } |
|
|
| zend_string_release(lfname); |
| return func; |
| } |
|
|
| PHPDBG_API char *phpdbg_trim(const char *str, size_t len, size_t *new_len) |
| { |
| const char *p = str; |
| char *new = NULL; |
|
|
| while (isspace(*p)) { |
| ++p; |
| --len; |
| } |
|
|
| while (*p && isspace(*(p + len -1))) { |
| --len; |
| } |
|
|
| if (len == 0) { |
| new = estrndup("", sizeof("")); |
| *new_len = 0; |
| } else { |
| new = estrndup(p, len); |
| *(new + len) = '\0'; |
|
|
| if (new_len) { |
| *new_len = len; |
| } |
| } |
|
|
| return new; |
|
|
| } |
|
|
| PHPDBG_API const phpdbg_color_t *phpdbg_get_color(const char *name, size_t name_length) |
| { |
| const phpdbg_color_t *color = colors; |
|
|
| while (color && color->name) { |
| if (name_length == color->name_length && |
| memcmp(name, color->name, name_length) == SUCCESS) { |
| phpdbg_debug("phpdbg_get_color(%s, %lu): %s", name, name_length, color->code); |
| return color; |
| } |
| ++color; |
| } |
|
|
| phpdbg_debug("phpdbg_get_color(%s, %lu): failed", name, name_length); |
|
|
| return NULL; |
| } |
|
|
| PHPDBG_API void phpdbg_set_color(int element, const phpdbg_color_t *color) |
| { |
| PHPDBG_G(colors)[element] = color; |
| } |
|
|
| PHPDBG_API void phpdbg_set_color_ex(int element, const char *name, size_t name_length) |
| { |
| const phpdbg_color_t *color = phpdbg_get_color(name, name_length); |
|
|
| if (color) { |
| phpdbg_set_color(element, color); |
| } else PHPDBG_G(colors)[element] = colors; |
| } |
|
|
| PHPDBG_API const phpdbg_color_t* phpdbg_get_colors(void) |
| { |
| return colors; |
| } |
|
|
| PHPDBG_API int phpdbg_get_element(const char *name, size_t len) { |
| const phpdbg_element_t *element = elements; |
|
|
| while (element && element->name) { |
| if (len == element->name_length) { |
| if (strncasecmp(name, element->name, len) == SUCCESS) { |
| return element->id; |
| } |
| } |
| element++; |
| } |
|
|
| return PHPDBG_COLOR_INVALID; |
| } |
|
|
| PHPDBG_API void phpdbg_set_prompt(const char *prompt) |
| { |
| |
| if (PHPDBG_G(prompt)[1]) { |
| free(PHPDBG_G(prompt)[1]); |
| PHPDBG_G(prompt)[1] = NULL; |
| } |
| |
| if (PHPDBG_G(prompt)[0]) { |
| free(PHPDBG_G(prompt)[0]); |
| PHPDBG_G(prompt)[0] = NULL; |
| } |
|
|
| |
| PHPDBG_G(prompt)[0] = strdup(prompt); |
| } |
|
|
| PHPDBG_API const char *phpdbg_get_prompt(void) |
| { |
| |
| if (PHPDBG_G(prompt)[1]) { |
| return PHPDBG_G(prompt)[1]; |
| } |
|
|
| uint32_t pos = 0, |
| end = strlen(PHPDBG_G(prompt)[0]); |
| bool unicode_warned = false; |
|
|
| while (pos < end) { |
| if (PHPDBG_G(prompt)[0][pos] & 0x80) { |
| PHPDBG_G(prompt)[0][pos] = '?'; |
|
|
| if (!unicode_warned) { |
| zend_error(E_WARNING, |
| "prompt contains unsupported unicode characters"); |
| unicode_warned = true; |
| } |
| } |
| pos++; |
| } |
|
|
| |
| #ifndef HAVE_LIBEDIT |
| |
| if ((PHPDBG_G(flags) & PHPDBG_IS_COLOURED)) { |
| ZEND_IGNORE_VALUE(asprintf(&PHPDBG_G(prompt)[1], "\033[%sm%s\033[0m ", |
| PHPDBG_G(colors)[PHPDBG_COLOR_PROMPT]->code, |
| PHPDBG_G(prompt)[0])); |
| } else |
| #endif |
| { |
| ZEND_IGNORE_VALUE(asprintf(&PHPDBG_G(prompt)[1], "%s ", PHPDBG_G(prompt)[0])); |
| } |
|
|
| return PHPDBG_G(prompt)[1]; |
| } |
|
|
| int phpdbg_rebuild_symtable(void) { |
| if (!EG(current_execute_data) || !EG(current_execute_data)->func) { |
| phpdbg_error("No active op array!"); |
| return FAILURE; |
| } |
|
|
| if (!zend_rebuild_symbol_table()) { |
| phpdbg_error("No active symbol table!"); |
| return FAILURE; |
| } |
|
|
| return SUCCESS; |
| } |
|
|
| PHPDBG_API uint32_t phpdbg_get_terminal_width(void) |
| { |
| uint32_t columns; |
| #ifdef _WIN32 |
| CONSOLE_SCREEN_BUFFER_INFO csbi; |
|
|
| GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi); |
| columns = (uint32_t) csbi.srWindow.Right - csbi.srWindow.Left + 1; |
| #elif defined(HAVE_SYS_IOCTL_H) && defined(TIOCGWINSZ) |
| struct winsize w; |
|
|
| columns = (uint32_t) ioctl(fileno(stdout), TIOCGWINSZ, &w) == 0 ? w.ws_col : 80; |
| #else |
| columns = 80; |
| #endif |
| return columns; |
| } |
|
|
| PHPDBG_API uint32_t phpdbg_get_terminal_height(void) |
| { |
| uint32_t lines; |
| #ifdef _WIN32 |
| CONSOLE_SCREEN_BUFFER_INFO csbi; |
|
|
| if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi)) { |
| lines = (uint32_t) csbi.srWindow.Bottom - csbi.srWindow.Top + 1; |
| } else { |
| lines = 40; |
| } |
| #elif defined(HAVE_SYS_IOCTL_H) && defined(TIOCGWINSZ) |
| struct winsize w; |
|
|
| lines = (uint32_t) ioctl(fileno(stdout), TIOCGWINSZ, &w) == 0 ? w.ws_row : 40; |
| #else |
| lines = 40; |
| #endif |
| return lines; |
| } |
|
|
| PHPDBG_API void phpdbg_set_async_io(int fd) { |
| #if !defined(_WIN32) && defined(FASYNC) |
| int flags; |
| fcntl(STDIN_FILENO, F_SETOWN, getpid()); |
| flags = fcntl(STDIN_FILENO, F_GETFL); |
| fcntl(STDIN_FILENO, F_SETFL, flags | FASYNC); |
| #endif |
| } |
|
|
| int phpdbg_safe_class_lookup(const char *name, int name_length, zend_class_entry **ce) { |
| if (PHPDBG_G(flags) & PHPDBG_IN_SIGNAL_HANDLER) { |
| char *lc_name, *lc_free; |
| int lc_length; |
|
|
| if (name == NULL || !name_length) { |
| return FAILURE; |
| } |
|
|
| lc_free = lc_name = emalloc(name_length + 1); |
| zend_str_tolower_copy(lc_name, name, name_length); |
| lc_length = name_length + 1; |
|
|
| if (lc_name[0] == '\\') { |
| lc_name += 1; |
| lc_length -= 1; |
| } |
|
|
| phpdbg_try_access { |
| *ce = zend_hash_str_find_ptr(EG(class_table), lc_name, lc_length); |
| } phpdbg_catch_access { |
| phpdbg_error("Could not fetch class %.*s, invalid data source", name_length, name); |
| } phpdbg_end_try_access(); |
|
|
| efree(lc_free); |
| } else { |
| zend_string *str_name = zend_string_init(name, name_length, 0); |
| *ce = zend_lookup_class(str_name); |
| efree(str_name); |
| } |
|
|
| return *ce ? SUCCESS : FAILURE; |
| } |
|
|
| char *phpdbg_get_property_key(char *key) { |
| if (*key != 0) { |
| return key; |
| } |
| return strchr(key + 1, 0) + 1; |
| } |
|
|
| static int phpdbg_parse_variable_arg_wrapper(char *name, size_t len, char *keyname, size_t keylen, HashTable *parent, zval *zv, phpdbg_parse_var_func callback) { |
| return callback(name, len, keyname, keylen, parent, zv); |
| } |
|
|
| PHPDBG_API int phpdbg_parse_variable(char *input, size_t len, HashTable *parent, size_t i, phpdbg_parse_var_func callback, bool silent) { |
| return phpdbg_parse_variable_with_arg(input, len, parent, i, (phpdbg_parse_var_with_arg_func) phpdbg_parse_variable_arg_wrapper, NULL, silent, callback); |
| } |
|
|
| PHPDBG_API int phpdbg_parse_variable_with_arg(char *input, size_t len, HashTable *parent, size_t i, phpdbg_parse_var_with_arg_func callback, phpdbg_parse_var_with_arg_func step_cb, bool silent, void *arg) { |
| int ret = FAILURE; |
| bool new_index = 1; |
| char *last_index = NULL; |
| size_t index_len = 0; |
| zval *zv; |
|
|
| if (len < 2 || *input != '$') { |
| goto error; |
| } |
|
|
| while (i++ < len) { |
| if (i == len) { |
| new_index = 1; |
| } else { |
| switch (input[i]) { |
| case '[': |
| new_index = 1; |
| break; |
| case ']': |
| break; |
| case '>': |
| if (!last_index) { |
| goto error; |
| } |
| if (last_index[index_len - 1] == '-') { |
| new_index = 1; |
| index_len--; |
| } |
| break; |
|
|
| default: |
| if (new_index) { |
| last_index = input + i; |
| new_index = 0; |
| } |
| if (input[i - 1] == ']') { |
| goto error; |
| } |
| index_len++; |
| } |
| } |
|
|
| if (new_index && index_len == 0) { |
| zend_ulong numkey; |
| zend_string *strkey; |
| ZEND_HASH_FOREACH_KEY_VAL_IND(parent, numkey, strkey, zv) { |
| if (i == len || (i == len - 1 && input[len - 1] == ']')) { |
| char *key, *propkey; |
| size_t namelen, keylen; |
| char *name; |
| char *keyname = estrndup(last_index, index_len); |
| if (strkey) { |
| key = ZSTR_VAL(strkey); |
| keylen = ZSTR_LEN(strkey); |
| } else { |
| keylen = spprintf(&key, 0, ZEND_ULONG_FMT, numkey); |
| } |
| propkey = phpdbg_get_property_key(key); |
| namelen = i + keylen + 2; |
| name = emalloc(namelen); |
| namelen = snprintf(name, namelen, "%.*s%.*s%s", (int) i, input, (int) (keylen - (propkey - key)), propkey, input[len - 1] == ']'?"]":""); |
| if (!strkey) { |
| efree(key); |
| } |
|
|
| ret = callback(name, namelen, keyname, index_len, parent, zv, arg) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE; |
| } else retry_ref: if (Z_TYPE_P(zv) == IS_OBJECT) { |
| if (step_cb) { |
| char *name = estrndup(input, i); |
| char *keyname = estrndup(last_index, index_len); |
|
|
| ret = step_cb(name, i, keyname, index_len, parent, zv, arg) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE; |
| } |
|
|
| phpdbg_parse_variable_with_arg(input, len, Z_OBJPROP_P(zv), i, callback, step_cb, silent, arg); |
| } else if (Z_TYPE_P(zv) == IS_ARRAY) { |
| if (step_cb) { |
| char *name = estrndup(input, i); |
| char *keyname = estrndup(last_index, index_len); |
|
|
| ret = step_cb(name, i, keyname, index_len, parent, zv, arg) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE; |
| } |
|
|
| phpdbg_parse_variable_with_arg(input, len, Z_ARRVAL_P(zv), i, callback, step_cb, silent, arg); |
| } else if (Z_ISREF_P(zv)) { |
| if (step_cb) { |
| char *name = estrndup(input, i); |
| char *keyname = estrndup(last_index, index_len); |
|
|
| ret = step_cb(name, i, keyname, index_len, parent, zv, arg) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE; |
| } |
|
|
| ZVAL_DEREF(zv); |
| goto retry_ref; |
| } else { |
| |
| } |
| } ZEND_HASH_FOREACH_END(); |
| return ret; |
| } else if (new_index) { |
| char last_chr = last_index[index_len]; |
| last_index[index_len] = 0; |
| if (!(zv = zend_symtable_str_find(parent, last_index, index_len))) { |
| if (!silent) { |
| phpdbg_error("%.*s is undefined", (int) (input[i] == ']' ? i + 1 : i), input); |
| } |
| return FAILURE; |
| } |
| while (Z_TYPE_P(zv) == IS_INDIRECT) { |
| zv = Z_INDIRECT_P(zv); |
| } |
|
|
| last_index[index_len] = last_chr; |
| if (i == len) { |
| char *name = estrndup(input, i); |
| char *keyname = estrndup(last_index, index_len); |
|
|
| ret = callback(name, i, keyname, index_len, parent, zv, arg) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE; |
| } else retry_ref_end: if (Z_TYPE_P(zv) == IS_OBJECT) { |
| if (step_cb) { |
| char *name = estrndup(input, i); |
| char *keyname = estrndup(last_index, index_len); |
|
|
| ret = step_cb(name, i, keyname, index_len, parent, zv, arg) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE; |
| } |
|
|
| parent = Z_OBJPROP_P(zv); |
| } else if (Z_TYPE_P(zv) == IS_ARRAY) { |
| if (step_cb) { |
| char *name = estrndup(input, i); |
| char *keyname = estrndup(last_index, index_len); |
|
|
| ret = step_cb(name, i, keyname, index_len, parent, zv, arg) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE; |
| } |
|
|
| parent = Z_ARRVAL_P(zv); |
| } else if (Z_ISREF_P(zv)) { |
| if (step_cb) { |
| char *name = estrndup(input, i); |
| char *keyname = estrndup(last_index, index_len); |
|
|
| ret = step_cb(name, i, keyname, index_len, parent, zv, arg) == SUCCESS || ret == SUCCESS?SUCCESS:FAILURE; |
| } |
|
|
| ZVAL_DEREF(zv); |
| goto retry_ref_end; |
| } else { |
| phpdbg_error("%.*s is nor an array nor an object", (int) (input[i] == '>' ? i - 1 : i), input); |
| return FAILURE; |
| } |
| index_len = 0; |
| } |
| } |
|
|
| return ret; |
| error: |
| phpdbg_error("Malformed input"); |
| return FAILURE; |
| } |
|
|
| int phpdbg_is_auto_global(char *name, int len) { |
| return zend_is_auto_global_str(name, len); |
| } |
|
|
| PHPDBG_API bool phpdbg_check_caught_ex(zend_execute_data *execute_data, zend_object *exception) { |
| const zend_op *op; |
| zend_op *cur; |
| uint32_t op_num, i; |
| zend_op_array *op_array = &execute_data->func->op_array; |
|
|
| if (execute_data->opline >= EG(exception_op) && execute_data->opline < EG(exception_op) + 3 && EG(opline_before_exception)) { |
| op = EG(opline_before_exception); |
| } else { |
| op = execute_data->opline; |
| } |
|
|
| op_num = op - op_array->opcodes; |
|
|
| for (i = 0; i < op_array->last_try_catch && op_array->try_catch_array[i].try_op <= op_num; i++) { |
| uint32_t catch = op_array->try_catch_array[i].catch_op, finally = op_array->try_catch_array[i].finally_op; |
| if (op_num <= catch || op_num <= finally) { |
| if (finally) { |
| return 1; |
| } |
|
|
| cur = &op_array->opcodes[catch]; |
| while (1) { |
| zend_class_entry *ce; |
|
|
| if (!(ce = CACHED_PTR(cur->extended_value & ~ZEND_LAST_CATCH))) { |
| ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(cur, cur->op1)), Z_STR_P(RT_CONSTANT(cur, cur->op1) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); |
| CACHE_PTR(cur->extended_value & ~ZEND_LAST_CATCH, ce); |
| } |
|
|
| if (ce == exception->ce || (ce && instanceof_function(exception->ce, ce))) { |
| return 1; |
| } |
|
|
| if (cur->extended_value & ZEND_LAST_CATCH) { |
| return 0; |
| } |
|
|
| cur = OP_JMP_ADDR(cur, cur->op2); |
| } |
|
|
| return 0; |
| } |
| } |
|
|
| return op->opcode == ZEND_CATCH; |
| } |
|
|
| char *phpdbg_short_zval_print(zval *zv, int maxlen) |
| { |
| char *decode = NULL; |
|
|
| switch (Z_TYPE_P(zv)) { |
| case IS_UNDEF: |
| decode = estrdup(""); |
| break; |
| case IS_NULL: |
| decode = estrdup("null"); |
| break; |
| case IS_FALSE: |
| decode = estrdup("false"); |
| break; |
| case IS_TRUE: |
| decode = estrdup("true"); |
| break; |
| case IS_LONG: |
| spprintf(&decode, 0, ZEND_LONG_FMT, Z_LVAL_P(zv)); |
| break; |
| case IS_DOUBLE: |
| spprintf(&decode, 0, "%.*G", 14, Z_DVAL_P(zv)); |
|
|
| |
| if (zend_finite(Z_DVAL_P(zv)) && !strchr(decode, '.')) { |
| size_t len = strlen(decode); |
| char *decode2 = emalloc(len + strlen(".0") + 1); |
| memcpy(decode2, decode, len); |
| decode2[len] = '.'; |
| decode2[len+1] = '0'; |
| decode2[len+2] = '\0'; |
| efree(decode); |
| decode = decode2; |
| } |
| break; |
| case IS_STRING: { |
| int i; |
| zend_string *str = php_addcslashes(Z_STR_P(zv), "\\\"\n\t\0", 5); |
| for (i = 0; i < ZSTR_LEN(str); i++) { |
| if (ZSTR_VAL(str)[i] < 32) { |
| ZSTR_VAL(str)[i] = ' '; |
| } |
| } |
| spprintf(&decode, 0, "\"%.*s\"%c", |
| ZSTR_LEN(str) <= maxlen - 2 ? (int) ZSTR_LEN(str) : (maxlen - 3), |
| ZSTR_VAL(str), ZSTR_LEN(str) <= maxlen - 2 ? 0 : '+'); |
| zend_string_release(str); |
| } break; |
| case IS_RESOURCE: |
| spprintf(&decode, 0, "Rsrc #" ZEND_LONG_FMT, Z_RES_HANDLE_P(zv)); |
| break; |
| case IS_ARRAY: |
| spprintf(&decode, 0, "array(%d)", zend_hash_num_elements(Z_ARR_P(zv))); |
| break; |
| case IS_OBJECT: { |
| zend_string *str = Z_OBJCE_P(zv)->name; |
| spprintf(&decode, 0, "%.*s%c", |
| ZSTR_LEN(str) <= maxlen ? (int) ZSTR_LEN(str) : maxlen - 1, |
| ZSTR_VAL(str), ZSTR_LEN(str) <= maxlen ? 0 : '+'); |
| break; |
| } |
| case IS_CONSTANT_AST: { |
| zend_ast *ast = Z_ASTVAL_P(zv); |
|
|
| if (ast->kind == ZEND_AST_CONSTANT |
| || ast->kind == ZEND_AST_CONSTANT_CLASS |
| || ast->kind == ZEND_AST_CLASS_CONST) { |
| decode = estrdup("<constant>"); |
| } else { |
| decode = estrdup("<ast>"); |
| } |
| break; |
| } |
| default: |
| spprintf(&decode, 0, "unknown type: %d", Z_TYPE_P(zv)); |
| break; |
| } |
|
|
| return decode; |
| } |
|
|
