diff options
| -rw-r--r-- | sapi/phpdbg/phpdbg_bp.c | 312 | ||||
| -rw-r--r-- | sapi/phpdbg/phpdbg_bp.h | 2 | ||||
| -rw-r--r-- | sapi/phpdbg/phpdbg_info.c | 107 | ||||
| -rw-r--r-- | sapi/phpdbg/phpdbg_list.c | 38 | ||||
| -rw-r--r-- | sapi/phpdbg/phpdbg_opcode.c | 17 | ||||
| -rw-r--r-- | sapi/phpdbg/phpdbg_utils.c | 16 |
6 files changed, 236 insertions, 256 deletions
diff --git a/sapi/phpdbg/phpdbg_bp.c b/sapi/phpdbg/phpdbg_bp.c index 511d1db57d..cb8abb0851 100644 --- a/sapi/phpdbg/phpdbg_bp.c +++ b/sapi/phpdbg/phpdbg_bp.c @@ -43,8 +43,7 @@ static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execut */ static inline void _phpdbg_break_mapping(int id, HashTable *table TSRMLS_DC) { - zend_hash_index_update( - &PHPDBG_G(bp)[PHPDBG_BREAK_MAP], (id), (void**) &table, sizeof(void*), NULL); + zend_hash_index_update_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], id, table); } #define PHPDBG_BREAK_MAPPING(id, table) _phpdbg_break_mapping(id, table TSRMLS_CC) @@ -58,29 +57,29 @@ static inline void _phpdbg_break_mapping(int id, HashTable *table TSRMLS_DC) b.hits = 0; \ } while(0) -static void phpdbg_file_breaks_dtor(void *data) /* {{{ */ +static void phpdbg_file_breaks_dtor(zval *data) /* {{{ */ { - phpdbg_breakfile_t *bp = (phpdbg_breakfile_t*) data; + phpdbg_breakfile_t *bp = (phpdbg_breakfile_t*)Z_PTR_P(data); efree((char*)bp->filename); } /* }}} */ -static void phpdbg_class_breaks_dtor(void *data) /* {{{ */ +static void phpdbg_class_breaks_dtor(zval *data) /* {{{ */ { - phpdbg_breakmethod_t *bp = (phpdbg_breakmethod_t*) data; + phpdbg_breakmethod_t *bp = (phpdbg_breakmethod_t*)Z_PTR_P(data); efree((char*)bp->class_name); efree((char*)bp->func_name); } /* }}} */ -static void phpdbg_opline_class_breaks_dtor(void *data) /* {{{ */ +static void phpdbg_opline_class_breaks_dtor(zval *data) /* {{{ */ { - zend_hash_destroy((HashTable *)data); + zend_hash_destroy((HashTable *)Z_ARR_P(data)); } /* }}} */ -static void phpdbg_opline_breaks_dtor(void *data) /* {{{ */ +static void phpdbg_opline_breaks_dtor(zval *data) /* {{{ */ { - phpdbg_breakopline_t *bp = (phpdbg_breakopline_t *) data; + phpdbg_breakopline_t *bp = (phpdbg_breakopline_t *)Z_PTR_P(data); if (bp->class_name) { efree((char*)bp->class_name); @@ -94,16 +93,16 @@ PHPDBG_API void phpdbg_reset_breakpoints(TSRMLS_D) /* {{{ */ { if (zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP])) { HashPosition position[2]; - HashTable **table = NULL; + HashTable *table; for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0]); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], (void**)&table, &position[0]) == SUCCESS; + (table = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0])) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0])) { phpdbg_breakbase_t *brake; - for (zend_hash_internal_pointer_reset_ex((*table), &position[1]); - zend_hash_get_current_data_ex((*table), (void**)&brake, &position[1]) == SUCCESS; - zend_hash_move_forward_ex((*table), &position[1])) { + for (zend_hash_internal_pointer_reset_ex(table, &position[1]); + (brake = zend_hash_get_current_data_ptr_ex(table, &position[1])) != NULL; + zend_hash_move_forward_ex(table, &position[1])) { brake->hits = 0; } } @@ -113,8 +112,8 @@ PHPDBG_API void phpdbg_reset_breakpoints(TSRMLS_D) /* {{{ */ PHPDBG_API void phpdbg_export_breakpoints(FILE *handle TSRMLS_DC) /* {{{ */ { HashPosition position[2]; - HashTable **table = NULL; - zend_ulong id = 0L; + HashTable *table; + zend_ulong id; if (zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP])) { phpdbg_notice( @@ -122,15 +121,15 @@ PHPDBG_API void phpdbg_export_breakpoints(FILE *handle TSRMLS_DC) /* {{{ */ zend_hash_num_elements(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP])); /* this only looks like magic, it isn't */ for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0]); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], (void**)&table, &position[0]) == SUCCESS; + (table = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0])) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], &position[0])) { phpdbg_breakbase_t *brake; - zend_hash_get_current_key_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], NULL, NULL, &id, 0, &position[0]); + zend_hash_get_current_key_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], NULL, &id, 0, &position[0]); - for (zend_hash_internal_pointer_reset_ex((*table), &position[1]); - zend_hash_get_current_data_ex((*table), (void**)&brake, &position[1]) == SUCCESS; - zend_hash_move_forward_ex((*table), &position[1])) { + for (zend_hash_internal_pointer_reset_ex(table, &position[1]); + (brake = zend_hash_get_current_data_ptr_ex(table, &position[1])) != NULL; + zend_hash_move_forward_ex(table, &position[1])) { if (brake->id == id) { switch (brake->type) { case PHPDBG_BREAK_FILE: { @@ -229,15 +228,12 @@ PHPDBG_API void phpdbg_set_breakpoint_file(const char *path, long line_num TSRML phpdbg_breakfile_t new_break; size_t path_len = strlen(path); - if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], - path, path_len, (void**)&broken) == FAILURE) { + if ((broken = zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], path, path_len)) == NULL) { HashTable breaks; zend_hash_init(&breaks, 8, NULL, phpdbg_file_breaks_dtor, 0); - zend_hash_update(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], - path, path_len, &breaks, sizeof(HashTable), - (void**)&broken); + broken = zend_hash_str_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], path, path_len, &breaks, sizeof(HashTable)); } if (!zend_hash_index_exists(broken, line_num)) { @@ -247,8 +243,7 @@ PHPDBG_API void phpdbg_set_breakpoint_file(const char *path, long line_num TSRML new_break.filename = estrndup(path, path_len); new_break.line = line_num; - zend_hash_index_update( - broken, line_num, (void**)&new_break, sizeof(phpdbg_breakfile_t), NULL); + zend_hash_str_index_update_mem(broken, line_num, &new_break, sizeof(phpdbg_breakfile_t)); phpdbg_notice("Breakpoint #%d added at %s:%ld", new_break.id, new_break.filename, new_break.line); @@ -268,7 +263,7 @@ PHPDBG_API void phpdbg_set_breakpoint_file(const char *path, long line_num TSRML PHPDBG_API void phpdbg_set_breakpoint_symbol(const char *name, size_t name_len TSRMLS_DC) /* {{{ */ { - if (!zend_hash_exists(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], name, name_len)) { + if (!zend_hash_str_exists(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], name, name_len)) { phpdbg_breaksymbol_t new_break; PHPDBG_G(flags) |= PHPDBG_HAS_SYM_BP; @@ -276,8 +271,8 @@ PHPDBG_API void phpdbg_set_breakpoint_symbol(const char *name, size_t name_len T PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_SYM); new_break.symbol = estrndup(name, name_len); - zend_hash_update(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], new_break.symbol, - name_len, &new_break, sizeof(phpdbg_breaksymbol_t), NULL); + zend_hash_str_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], new_break.symbol, name_len, + &new_break, sizeof(phpdbg_breaksymbol_t)); phpdbg_notice("Breakpoint #%d added at %s", new_break.id, new_break.symbol); @@ -295,16 +290,15 @@ PHPDBG_API void phpdbg_set_breakpoint_method(const char *class_name, const char size_t func_len = strlen(func_name); char *lcname = zend_str_tolower_dup(func_name, func_len); - if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], class_name, - class_len, (void**)&class_table) != SUCCESS) { + if ((class_table = zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], class_name, class_len)) == NULL) { zend_hash_init(&class_breaks, 8, NULL, phpdbg_class_breaks_dtor, 0); - zend_hash_update( + class_table = zend_hash_str_update_mem( &PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], class_name, class_len, - (void**)&class_breaks, sizeof(HashTable), (void**)&class_table); + &class_breaks, sizeof(HashTable)); } - if (!zend_hash_exists(class_table, lcname, func_len)) { + if (!zend_hash_str_exists(class_table, lcname, func_len)) { phpdbg_breakmethod_t new_break; PHPDBG_G(flags) |= PHPDBG_HAS_METHOD_BP; @@ -315,8 +309,7 @@ PHPDBG_API void phpdbg_set_breakpoint_method(const char *class_name, const char new_break.func_name = estrndup(func_name, func_len); new_break.func_len = func_len; - zend_hash_update(class_table, lcname, func_len, - &new_break, sizeof(phpdbg_breakmethod_t), NULL); + zend_hash_str_update_mem(class_table, lcname, func_len, &new_break, sizeof(phpdbg_breakmethod_t)); phpdbg_notice("Breakpoint #%d added at %s::%s", new_break.id, class_name, func_name); @@ -341,8 +334,7 @@ PHPDBG_API void phpdbg_set_breakpoint_opline(zend_ulong opline TSRMLS_DC) /* {{{ new_break.opline = opline; new_break.base = NULL; - zend_hash_index_update(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], opline, - &new_break, sizeof(phpdbg_breakline_t), NULL); + zend_hash_index_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], opline, &new_break, sizeof(phpdbg_breakline_t)); phpdbg_notice("Breakpoint #%d added at %#lx", new_break.id, new_break.opline); @@ -383,7 +375,7 @@ PHPDBG_API int phpdbg_resolve_op_array_break(phpdbg_breakopline_t *brake, zend_o PHPDBG_G(flags) |= PHPDBG_HAS_OPLINE_BP; - zend_hash_index_update(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], opline_break.opline, &opline_break, sizeof(phpdbg_breakline_t), NULL); + zend_hash_index_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], opline_break.opline, &opline_break, sizeof(phpdbg_breakline_t)); return SUCCESS; } /* }}} */ @@ -396,26 +388,26 @@ PHPDBG_API void phpdbg_resolve_op_array_breaks(zend_op_array *op_array TSRMLS_DC phpdbg_breakopline_t *brake; if (op_array->scope != NULL && - zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], op_array->scope->name, op_array->scope->name_length, (void **)&func_table) == FAILURE) { + (func_table = zend_hash_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], op_array->scope->name)) == NULL) { return; } if (op_array->function_name == NULL) { - if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], op_array->filename, strlen(op_array->filename), (void **)&oplines_table) == FAILURE) { + if ((oplines_table = zend_hash_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], op_array->filename)) == NULL) { return; } - } else if (zend_hash_find(func_table, op_array->function_name?op_array->function_name:"", op_array->function_name?strlen(op_array->function_name):0, (void **)&oplines_table) == FAILURE) { + } else if ((oplines_table = zend_hash_find_ptr(func_table, op_array->function_name?op_array->function_name:STR_EMPTY_ALLOC())) == NULL) { return; } for (zend_hash_internal_pointer_reset_ex(oplines_table, &position); - zend_hash_get_current_data_ex(oplines_table, (void**) &brake, &position) == SUCCESS; + (brake = zend_hash_get_current_data_ptr_ex(oplines_table, &position)) != NULL; zend_hash_move_forward_ex(oplines_table, &position)) { if (phpdbg_resolve_op_array_break(brake, op_array TSRMLS_CC) == SUCCESS) { phpdbg_breakline_t *opline_break; zend_hash_internal_pointer_end(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]); - zend_hash_get_current_data(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], (void **)&opline_break); + opline_break = zend_hash_get_current_data_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE]); phpdbg_notice("Breakpoint #%d resolved at %s%s%s#%ld (opline %#lx)", brake->id, @@ -446,7 +438,7 @@ PHPDBG_API int phpdbg_resolve_opline_break(phpdbg_breakopline_t *new_break TSRML } else { zend_execute_data *execute_data = EG(current_execute_data); do { - if (execute_data->op_array->function_name == NULL && execute_data->op_array->scope == NULL && !memcmp(execute_data->op_array->filename, new_break->class_name, new_break->class_len)) { + if (execute_data->op_array->function_name == NULL && execute_data->op_array->scope == NULL && !memcmp(execute_data->op_array->filename->val, new_break->class_name, new_break->class_len)) { if (phpdbg_resolve_op_array_break(new_break, execute_data->op_array TSRMLS_CC) == SUCCESS) { return SUCCESS; } else { @@ -459,14 +451,14 @@ PHPDBG_API int phpdbg_resolve_opline_break(phpdbg_breakopline_t *new_break TSRML } if (new_break->class_name != NULL) { - zend_class_entry **ce; - if (zend_hash_find(EG(class_table), zend_str_tolower_dup(new_break->class_name, new_break->class_len), new_break->class_len + 1, (void **)&ce) == FAILURE) { + zend_class_entry *ce; + if ((ce = zend_hash_str_find_ptr(EG(class_table), zend_str_tolower_dup(new_break->class_name, new_break->class_len), new_break->class_len)) == NULL) { return FAILURE; } - func_table = &(*ce)->function_table; + func_table = &ce->function_table; } - if (zend_hash_find(func_table, zend_str_tolower_dup(new_break->func_name, new_break->func_len), new_break->func_len + 1, (void **)&func) == FAILURE) { + if ((func = zend_hash_str_find_ptr(func_table, zend_str_tolower_dup(new_break->func_name, new_break->func_len), new_break->func_len)) == NULL) { if (new_break->class_name != NULL && new_break->func_name != NULL) { phpdbg_error("Method %s doesn't exist in class %s", new_break->func_name, new_break->class_name); return 2; @@ -517,22 +509,22 @@ PHPDBG_API void phpdbg_set_breakpoint_method_opline(const char *class, const cha return; } - if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], new_break.class_name, new_break.class_len, (void **)&class_table) == FAILURE) { + if ((class_table = zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], new_break.class_name, new_break.class_len)) == NULL) { zend_hash_init(&class_breaks, 8, NULL, phpdbg_opline_class_breaks_dtor, 0); - zend_hash_update( + class_table = zend_hash_str_update_mem( &PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], new_break.class_name, new_break.class_len, - (void **)&class_breaks, sizeof(HashTable), (void **)&class_table); + &class_breaks, sizeof(HashTable)); } - if (zend_hash_find(class_table, new_break.func_name, new_break.func_len, (void **)&method_table) == FAILURE) { + if ((method_table = zend_hash_str_find_ptr(class_table, new_break.func_name, new_break.func_len)) == NULL) { zend_hash_init(&method_breaks, 8, NULL, phpdbg_opline_breaks_dtor, 0); - zend_hash_update( + method_table = zend_hash_str_update_mem( class_table, new_break.func_name, new_break.func_len, - (void **)&method_breaks, sizeof(HashTable), (void **)&method_table); + &method_breaks, sizeof(HashTable)); } if (zend_hash_index_exists(method_table, opline)) { @@ -547,8 +539,9 @@ PHPDBG_API void phpdbg_set_breakpoint_method_opline(const char *class, const cha PHPDBG_BREAK_MAPPING(new_break.id, method_table); - zend_hash_index_update(method_table, opline, &new_break, sizeof(phpdbg_breakopline_t), NULL); + zend_hash_index_update_mem(method_table, opline, &new_break, sizeof(phpdbg_breakopline_t)); } +/* }}} */ PHPDBG_API void phpdbg_set_breakpoint_function_opline(const char *function, zend_ulong opline TSRMLS_DC) /* {{{ */ { @@ -576,13 +569,13 @@ PHPDBG_API void phpdbg_set_breakpoint_function_opline(const char *function, zend return; } - if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], new_break.func_name, new_break.func_len, (void **)&func_table) == FAILURE) { + if ((func_table = zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], new_break.func_name, new_break.func_len)) == NULL) { zend_hash_init(&func_breaks, 8, NULL, phpdbg_opline_breaks_dtor, 0); - zend_hash_update( + func_table = zend_hash_str_update_mem( &PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], new_break.func_name, new_break.func_len, - (void **)&func_breaks, sizeof(HashTable), (void **)&func_table); + &func_breaks, sizeof(HashTable)); } if (zend_hash_index_exists(func_table, opline)) { @@ -596,8 +589,9 @@ PHPDBG_API void phpdbg_set_breakpoint_function_opline(const char *function, zend PHPDBG_G(flags) |= PHPDBG_HAS_FUNCTION_OPLINE_BP; - zend_hash_index_update(func_table, opline, &new_break, sizeof(phpdbg_breakopline_t), NULL); + zend_hash_index_update_mem(func_table, opline, &new_break, sizeof(phpdbg_breakopline_t)); } +/* }}} */ PHPDBG_API void phpdbg_set_breakpoint_file_opline(const char *file, zend_ulong opline TSRMLS_DC) /* {{{ */ { @@ -625,13 +619,13 @@ PHPDBG_API void phpdbg_set_breakpoint_file_opline(const char *file, zend_ulong o return; } - if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], new_break.class_name, new_break.class_len, (void **)&file_table) == FAILURE) { + if ((file_table = zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], new_break.class_name, new_break.class_len)) == NULL) { zend_hash_init(&file_breaks, 8, NULL, phpdbg_opline_breaks_dtor, 0); - zend_hash_update( + file_table = zend_hash_str_update_mem( &PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], new_break.class_name, new_break.class_len, - (void **)&file_breaks, sizeof(HashTable), (void **)&file_table); + &file_breaks, sizeof(HashTable)); } if (zend_hash_index_exists(file_table, opline)) { @@ -645,8 +639,9 @@ PHPDBG_API void phpdbg_set_breakpoint_file_opline(const char *file, zend_ulong o PHPDBG_G(flags) |= PHPDBG_HAS_FILE_OPLINE_BP; - zend_hash_index_update(file_table, opline, &new_break, sizeof(phpdbg_breakopline_t), NULL); + zend_hash_index_update_mem(file_table, opline, &new_break, sizeof(phpdbg_breakopline_t)); } +/* }}} */ PHPDBG_API void phpdbg_set_breakpoint_opcode(const char *name, size_t name_len TSRMLS_DC) /* {{{ */ { @@ -663,8 +658,7 @@ PHPDBG_API void phpdbg_set_breakpoint_opcode(const char *name, size_t name_len T new_break.hash = hash; new_break.name = estrndup(name, name_len); - zend_hash_index_update(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], hash, - &new_break, sizeof(phpdbg_breakop_t), NULL); + zend_hash_index_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], hash, &new_break, sizeof(phpdbg_breakop_t)); PHPDBG_G(flags) |= PHPDBG_HAS_OPCODE_BP; @@ -682,8 +676,8 @@ PHPDBG_API void phpdbg_set_breakpoint_opline_ex(phpdbg_opline_ptr_t opline TSRML PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_OPLINE); new_break.opline = (zend_ulong) opline; - zend_hash_index_update(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], - (zend_ulong) opline, &new_break, sizeof(phpdbg_breakline_t), NULL); + zend_hash_index_update_mem(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], + (zend_ulong) opline, &new_break, sizeof(phpdbg_breakline_t)); phpdbg_notice("Breakpoint #%d added at %#lx", new_break.id, new_break.opline); @@ -696,6 +690,7 @@ static inline void phpdbg_create_conditional_break(phpdbg_breakcond_t *brake, co phpdbg_breakcond_t new_break; zend_uint cops = CG(compiler_options); zval pv; + zend_string *str; PHPDBG_BREAK_INIT(new_break, PHPDBG_BREAK_COND); new_break.hash = hash; @@ -715,13 +710,12 @@ static inline void phpdbg_create_conditional_break(phpdbg_breakcond_t *brake, co new_break.code = estrndup(expr, expr_len); new_break.code_len = expr_len; - Z_STRLEN(pv) = expr_len + sizeof("return ;") - 1; - Z_STRVAL(pv) = emalloc(Z_STRLEN(pv) + 1); + str = STR_ALLOC(expr_len + sizeof("return ;") - 1, 0); + ZVAL_STR(&pv, str); memcpy(Z_STRVAL(pv), "return ", sizeof("return ") - 1); memcpy(Z_STRVAL(pv) + sizeof("return ") - 1, expr, expr_len); Z_STRVAL(pv)[Z_STRLEN(pv) - 1] = ';'; Z_STRVAL(pv)[Z_STRLEN(pv)] = '\0'; - Z_TYPE(pv) = IS_STRING; new_break.ops = zend_compile_string( &pv, "Conditional Breakpoint Code" TSRMLS_CC); @@ -729,9 +723,8 @@ static inline void phpdbg_create_conditional_break(phpdbg_breakcond_t *brake, co zval_dtor(&pv); if (new_break.ops) { - zend_hash_index_update( - &PHPDBG_G(bp)[PHPDBG_BREAK_COND], hash, &new_break, - sizeof(phpdbg_breakcond_t), (void**)&brake); + brake = zend_hash_index_update_mem( + &PHPDBG_G(bp)[PHPDBG_BREAK_COND], hash, &new_break, sizeof(phpdbg_breakcond_t)); phpdbg_notice("Conditional breakpoint #%d added %s/%p", brake->id, brake->code, brake->ops); @@ -816,14 +809,12 @@ static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_file(zend_op_array *op_ { HashTable *breaks; phpdbg_breakbase_t *brake; - size_t name_len = strlen(op_array->filename); - if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], op_array->filename, - name_len, (void**)&breaks) == FAILURE) { + if ((breaks = zend_hash_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], op_array->filename)) == NULL) { return NULL; } - if (zend_hash_index_find(breaks, (*EG(opline_ptr))->lineno, (void**)&brake) == SUCCESS) { + if ((brake = zend_hash_index_find_ptr(breaks, (*EG(opline_ptr))->lineno)) != NULL) { return brake; } @@ -832,7 +823,7 @@ static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_file(zend_op_array *op_ static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_symbol(zend_function *fbc TSRMLS_DC) /* {{{ */ { - const char *fname; + zend_string *fname; zend_op_array *ops; phpdbg_breakbase_t *brake; @@ -850,11 +841,13 @@ static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_symbol(zend_function *f fname = ops->function_name; if (!fname) { - fname = "main"; - } - - if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], fname, strlen(fname), (void**)&brake) == SUCCESS) { - return brake; + if ((brake = zend_hash_str_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], "main", sizeof("main") - 1)) != NULL) { + return brake; + } + } else { + if ((brake = zend_hash_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], fname)) != NULL) { + return brake; + } } return NULL; @@ -865,15 +858,11 @@ static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_method(zend_op_array *o HashTable *class_table; phpdbg_breakbase_t *brake; - if (zend_hash_find(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], ops->scope->name, - ops->scope->name_length, (void**)&class_table) == SUCCESS) { - char *lcname = zend_str_tolower_dup(ops->function_name, strlen(ops->function_name)); - size_t lcname_len = strlen(lcname); + if ((class_table = zend_hash_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], ops->scope->name)) != NULL) { + char *lcname = zend_str_tolower_dup(ops->function_name->val, ops->function_name->len); + size_t lcname_len = ops->function_name->len; - if (zend_hash_find( - class_table, - lcname, - lcname_len, (void**)&brake) == SUCCESS) { + if ((brake = zend_hash_str_find_ptr(class_table, lcname, lcname_len)) != NULL) { efree(lcname); return brake; } @@ -888,8 +877,7 @@ static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_opline(phpdbg_opline_pt { phpdbg_breakline_t *brake; - if (zend_hash_index_find(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], - (zend_ulong) opline, (void**)&brake) == SUCCESS) { + if ((brake = zend_hash_index_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], (zend_ulong) opline)) != NULL) { return (brake->base?(phpdbg_breakbase_t *)brake->base:(phpdbg_breakbase_t *)brake); } @@ -905,8 +893,7 @@ static inline phpdbg_breakbase_t *phpdbg_find_breakpoint_opcode(zend_uchar opcod return NULL; } - if (zend_hash_index_find(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], - zend_hash_func(opname, strlen(opname)), (void**)&brake) == SUCCESS) { + if ((brake = zend_hash_index_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], zend_hash_func(opname, strlen(opname)))) != NULL) { return brake; } return NULL; @@ -924,16 +911,16 @@ static inline zend_bool phpdbg_find_breakpoint_param(phpdbg_param_t *param, zend if (function->type != ZEND_USER_FUNCTION) { return 0; } - { - const char *str = NULL; - size_t len = 0L; zend_op_array *ops = (zend_op_array*)function; - str = ops->function_name ? ops->function_name : "main"; - len = strlen(str); - - if (len == param->len && memcmp(param->str, str, len) == SUCCESS) { - return param->type == STR_PARAM || execute_data->opline - ops->opcodes == param->num; + if (ops->function_name) { + if (ops->function_name->len == param->len && !memcmp(param->str, ops->function_name->val, ops->function_name->len)) { + return param->type == STR_PARAM || execute_data->opline - ops->opcodes == param->num; + } + } else { + if (ops->function_name->len == param->len && !memcmp(param->str, "main", sizeof("main") - 1)) { + return param->type == STR_PARAM || execute_data->opline - ops->opcodes == param->num; + } } } } break; @@ -944,8 +931,7 @@ static inline zend_bool phpdbg_find_breakpoint_param(phpdbg_param_t *param, zend size_t lengths[2] = {strlen(param->file.name), strlen(str)}; if (lengths[0] == lengths[1]) { - return (memcmp( - param->file.name, str, lengths[0]) == SUCCESS); + return (!memcmp(param->file.name, str, lengths[0])); } } } break; @@ -960,12 +946,12 @@ static inline zend_bool phpdbg_find_breakpoint_param(phpdbg_param_t *param, zend zend_op_array *ops = (zend_op_array*) function; if (ops->scope) { - size_t lengths[2] = {strlen(param->method.class), ops->scope->name_length}; - if (lengths[0] == lengths[1] && memcmp(param->method.class, ops->scope->name, lengths[0]) == SUCCESS) { + size_t lengths[2] = {strlen(param->method.class), ops->scope->name->len}; + if (lengths[0] == lengths[1] && memcmp(param->method.class, ops->scope->name->val, lengths[0]) == SUCCESS) { lengths[0] = strlen(param->method.name); - lengths[1] = strlen(ops->function_name); + lengths[1] = ops->function_name->len; - if (lengths[0] == lengths[1] && memcmp(param->method.name, ops->function_name, lengths[0]) == SUCCESS) { + if (lengths[0] == lengths[1] && memcmp(param->method.name, ops->function_name->val, lengths[0]) == SUCCESS) { return param->type == METHOD_PARAM || (execute_data->opline - ops->opcodes) == param->num; } } @@ -991,11 +977,10 @@ static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execut int breakpoint = FAILURE; for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], &position); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], (void*)&bp, &position) == SUCCESS; + (bp = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], &position)) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], &position)) { - zval *retval = NULL; + zval retval; int orig_interactive = CG(interactive); - zval **orig_retval = EG(return_value_ptr_ptr); zend_op_array *orig_ops = EG(active_op_array); zend_op **orig_opline = EG(opline_ptr); @@ -1009,9 +994,6 @@ static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execut } } - ALLOC_INIT_ZVAL(retval); - - EG(return_value_ptr_ptr) = &retval; EG(active_op_array) = bp->ops; EG(no_extensions) = 1; @@ -1023,9 +1005,9 @@ static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execut zend_try { PHPDBG_G(flags) |= PHPDBG_IN_COND_BP; - zend_execute(EG(active_op_array) TSRMLS_CC); + zend_execute(EG(active_op_array), &retval TSRMLS_CC); #if PHP_VERSION_ID >= 50700 - if (zend_is_true(retval TSRMLS_CC)) { + if (zend_is_true(&retval TSRMLS_CC)) { #else if (zend_is_true(retval)) { #endif @@ -1035,7 +1017,6 @@ static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execut CG(interactive) = orig_interactive; EG(no_extensions)=1; - EG(return_value_ptr_ptr) = orig_retval; EG(active_op_array) = orig_ops; EG(opline_ptr) = orig_opline; PHPDBG_G(flags) &= ~PHPDBG_IN_COND_BP; @@ -1043,8 +1024,7 @@ static inline phpdbg_breakbase_t *phpdbg_find_conditional_breakpoint(zend_execut CG(interactive) = orig_interactive; - EG(no_extensions)=1; - EG(return_value_ptr_ptr) = orig_retval; + EG(no_extensions) = 1; EG(active_op_array) = orig_ops; EG(opline_ptr) = orig_opline; PHPDBG_G(flags) &= ~PHPDBG_IN_COND_BP; @@ -1110,13 +1090,12 @@ result: PHPDBG_API void phpdbg_delete_breakpoint(zend_ulong num TSRMLS_DC) /* {{{ */ { - HashTable **table; + HashTable *table; HashPosition position; phpdbg_breakbase_t *brake; if ((brake = phpdbg_find_breakbase_ex(num, &table, &position TSRMLS_CC))) { - char *key; - zend_uint klen; + zend_string *key; zend_ulong idx; int type = brake->type; char *name = NULL; @@ -1125,7 +1104,7 @@ PHPDBG_API void phpdbg_delete_breakpoint(zend_ulong num TSRMLS_DC) /* {{{ */ switch (type) { case PHPDBG_BREAK_FILE: case PHPDBG_BREAK_METHOD: - if (zend_hash_num_elements((*table)) == 1) { + if (zend_hash_num_elements(table) == 1) { name = estrdup(brake->name); name_len = strlen(name); if (zend_hash_num_elements(&PHPDBG_G(bp)[type]) == 1) { @@ -1135,7 +1114,7 @@ PHPDBG_API void phpdbg_delete_breakpoint(zend_ulong num TSRMLS_DC) /* {{{ */ break; default: { - if (zend_hash_num_elements((*table)) == 1) { + if (zend_hash_num_elements(table) == 1) { PHPDBG_G(flags) &= ~(1<<(brake->type+1)); } } @@ -1151,22 +1130,21 @@ PHPDBG_API void phpdbg_delete_breakpoint(zend_ulong num TSRMLS_DC) /* {{{ */ zend_hash_index_del(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], ((phpdbg_breakopline_t*)brake)->opline); } - switch (zend_hash_get_current_key_ex( - (*table), &key, &klen, &idx, 0, &position)) { + switch (zend_hash_get_current_key_ex(table, &key, &idx, 0, &position)) { case HASH_KEY_IS_STRING: - zend_hash_del((*table), key, klen); + zend_hash_del(table, key); break; default: - zend_hash_index_del((*table), idx); + zend_hash_index_del(table, idx); } switch (type) { case PHPDBG_BREAK_FILE: case PHPDBG_BREAK_METHOD: if (name) { - zend_hash_del(&PHPDBG_G(bp)[type], name, name_len); + zend_hash_str_del(&PHPDBG_G(bp)[type], name, name_len); efree(name); } break; @@ -1349,20 +1327,20 @@ PHPDBG_API void phpdbg_disable_breakpoints(TSRMLS_D) { /* {{{ */ PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakbase(zend_ulong id TSRMLS_DC) /* {{{ */ { - HashTable **table; + HashTable *table; HashPosition position; return phpdbg_find_breakbase_ex(id, &table, &position TSRMLS_CC); } /* }}} */ -PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakbase_ex(zend_ulong id, HashTable ***table, HashPosition *position TSRMLS_DC) /* {{{ */ +PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakbase_ex(zend_ulong id, HashTable **table, HashPosition *position TSRMLS_DC) /* {{{ */ { - if (zend_hash_index_find(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], id, (void**)table) == SUCCESS) { + if ((*table = zend_hash_index_find_ptr(&PHPDBG_G(bp)[PHPDBG_BREAK_MAP], id)) != NULL) { phpdbg_breakbase_t *brake; - for (zend_hash_internal_pointer_reset_ex((**table), position); - zend_hash_get_current_data_ex((**table), (void**)&brake, position) == SUCCESS; - zend_hash_move_forward_ex((**table), position)) { + for (zend_hash_internal_pointer_reset_ex((*table), position); + (brake = zend_hash_get_current_data_ptr_ex((*table), position)) != NULL; + zend_hash_move_forward_ex((*table), position)) { if (brake->id == id) { return brake; @@ -1382,7 +1360,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */ phpdbg_writeln(SEPARATE); phpdbg_writeln("Function Breakpoints:"); for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], &position); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], (void**) &brake, &position) == SUCCESS; + (brake = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], &position)) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_SYM], &position)) { phpdbg_writeln("#%d\t\t%s%s", brake->id, brake->symbol, @@ -1393,22 +1371,21 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */ case PHPDBG_BREAK_METHOD: if ((PHPDBG_G(flags) & PHPDBG_HAS_METHOD_BP)) { HashPosition position[2]; HashTable *class_table; - char *class_name = NULL; - zend_uint class_len = 0; + zend_string *class_name; zend_ulong class_idx = 0L; phpdbg_writeln(SEPARATE); phpdbg_writeln("Method Breakpoints:"); for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], &position[0]); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], (void**) &class_table, &position[0]) == SUCCESS; + (class_table = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], &position[0])) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], &position[0])) { if (zend_hash_get_current_key_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD], - &class_name, &class_len, &class_idx, 0, &position[0]) == HASH_KEY_IS_STRING) { + &class_name, &class_idx, 0, &position[0]) == HASH_KEY_IS_STRING) { phpdbg_breakmethod_t *brake; for (zend_hash_internal_pointer_reset_ex(class_table, &position[1]); - zend_hash_get_current_data_ex(class_table, (void**)&brake, &position[1]) == SUCCESS; + (brake = zend_hash_get_current_data_ptr_ex(class_table, &position[1])) != NULL; zend_hash_move_forward_ex(class_table, &position[1])) { phpdbg_writeln("#%d\t\t%s::%s%s", brake->id, brake->class_name, brake->func_name, @@ -1426,12 +1403,12 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */ phpdbg_writeln(SEPARATE); phpdbg_writeln("File Breakpoints:"); for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], &position[0]); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], (void**) &points, &position[0]) == SUCCESS; + (points = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], &position[0])) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE], &position[0])) { phpdbg_breakfile_t *brake; for (zend_hash_internal_pointer_reset_ex(points, &position[1]); - zend_hash_get_current_data_ex(points, (void**)&brake, &position[1]) == SUCCESS; + (brake = zend_hash_get_current_data_ptr_ex(points, &position[1])) != NULL; zend_hash_move_forward_ex(points, &position[1])) { phpdbg_writeln("#%d\t\t%s:%lu%s", brake->id, brake->filename, brake->line, @@ -1448,7 +1425,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */ phpdbg_writeln(SEPARATE); phpdbg_writeln("Opline Breakpoints:"); for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], &position); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], (void**) &brake, &position) == SUCCESS; + (brake = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], &position)) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPLINE], &position)) { switch (brake->type) { case PHPDBG_BREAK_METHOD_OPLINE: @@ -1472,30 +1449,29 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */ case PHPDBG_BREAK_METHOD_OPLINE: if ((PHPDBG_G(flags) & PHPDBG_HAS_METHOD_OPLINE_BP)) { HashPosition position[3]; HashTable *class_table, *method_table; - char *class_name = NULL, *method_name = NULL; - zend_uint class_len = 0, method_len = 0; + zend_string *class_name, *method_name; zend_ulong class_idx = 0L, method_idx = 0L; phpdbg_writeln(SEPARATE); phpdbg_writeln("Method opline Breakpoints:"); for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], &position[0]); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], (void**) &class_table, &position[0]) == SUCCESS; + (class_table = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], &position[0])) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], &position[0])) { if (zend_hash_get_current_key_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_METHOD_OPLINE], - &class_name, &class_len, &class_idx, 0, &position[0]) == HASH_KEY_IS_STRING) { + &class_name, &class_idx, 0, &position[0]) == HASH_KEY_IS_STRING) { for (zend_hash_internal_pointer_reset_ex(class_table, &position[1]); - zend_hash_get_current_data_ex(class_table, (void**) &method_table, &position[1]) == SUCCESS; + (method_table = zend_hash_get_current_data_ptr_ex(class_table, &position[1])) != NULL; zend_hash_move_forward_ex(class_table, &position[1])) { if (zend_hash_get_current_key_ex(class_table, - &method_name, &method_len, &method_idx, 0, &position[0]) == HASH_KEY_IS_STRING) { + &method_name, &method_idx, 0, &position[0]) == HASH_KEY_IS_STRING) { phpdbg_breakopline_t *brake; for (zend_hash_internal_pointer_reset_ex(method_table, &position[2]); - zend_hash_get_current_data_ex(method_table, (void**)&brake, &position[2]) == SUCCESS; + (brake = zend_hash_get_current_data_ptr_ex(method_table, &position[2])) != NULL; zend_hash_move_forward_ex(method_table, &position[2])) { phpdbg_writeln("#%d\t\t%s::%s opline %ld%s", brake->id, brake->class_name, brake->func_name, brake->opline_num, @@ -1511,23 +1487,22 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */ case PHPDBG_BREAK_FUNCTION_OPLINE: if ((PHPDBG_G(flags) & PHPDBG_HAS_FUNCTION_OPLINE_BP)) { HashPosition position[2]; HashTable *function_table; - char *function_name = NULL; - zend_uint function_len = 0; + zend_string *function_name; zend_ulong function_idx = 0L; phpdbg_writeln(SEPARATE); phpdbg_writeln("Function opline Breakpoints:"); for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], &position[0]); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], (void**) &function_table, &position[0]) == SUCCESS; + (function_table = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], &position[0])) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], &position[0])) { if (zend_hash_get_current_key_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FUNCTION_OPLINE], - &function_name, &function_len, &function_idx, 0, &position[0]) == HASH_KEY_IS_STRING) { + &function_name, &function_idx, 0, &position[0]) == HASH_KEY_IS_STRING) { phpdbg_breakopline_t *brake; for (zend_hash_internal_pointer_reset_ex(function_table, &position[1]); - zend_hash_get_current_data_ex(function_table, (void**)&brake, &position[1]) == SUCCESS; + (brake = zend_hash_get_current_data_ptr_ex(function_table, &position[1])) != NULL; zend_hash_move_forward_ex(function_table, &position[1])) { phpdbg_writeln("#%d\t\t%s opline %ld%s", brake->id, brake->func_name, brake->opline_num, @@ -1541,23 +1516,22 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */ case PHPDBG_BREAK_FILE_OPLINE: if ((PHPDBG_G(flags) & PHPDBG_HAS_FILE_OPLINE_BP)) { HashPosition position[2]; HashTable *file_table; - char *file_name = NULL; - zend_uint file_len = 0; - zend_ulong file_idx = 0L; + zend_string *file_name; + zend_ulong file_idx; phpdbg_writeln(SEPARATE); phpdbg_writeln("File opline Breakpoints:"); for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], &position[0]); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], (void**) &file_table, &position[0]) == SUCCESS; + (file_table = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], &position[0])) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], &position[0])) { if (zend_hash_get_current_key_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_FILE_OPLINE], - &file_name, &file_len, &file_idx, 0, &position[0]) == HASH_KEY_IS_STRING) { + &file_name, &file_idx, 0, &position[0]) == HASH_KEY_IS_STRING) { phpdbg_breakopline_t *brake; for (zend_hash_internal_pointer_reset_ex(file_table, &position[1]); - zend_hash_get_current_data_ex(file_table, (void**)&brake, &position[1]) == SUCCESS; + (brake = zend_hash_get_current_data_ptr_ex(file_table, &position[1])) != NULL; zend_hash_move_forward_ex(file_table, &position[1])) { phpdbg_writeln("#%d\t\t%s opline %ld%s", brake->id, brake->class_name, brake->opline_num, @@ -1574,7 +1548,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */ phpdbg_writeln(SEPARATE); phpdbg_writeln("Conditional Breakpoints:"); for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], &position); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], (void**) &brake, &position) == SUCCESS; + (brake = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], &position)) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_COND], &position)) { if (brake->paramed) { switch (brake->param.type) { @@ -1650,7 +1624,7 @@ PHPDBG_API void phpdbg_print_breakpoints(zend_ulong type TSRMLS_DC) /* {{{ */ phpdbg_writeln(SEPARATE); phpdbg_writeln("Opcode Breakpoints:"); for (zend_hash_internal_pointer_reset_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], &position); - zend_hash_get_current_data_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], (void**) &brake, &position) == SUCCESS; + (brake = zend_hash_get_current_data_ptr_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], &position)) != NULL; zend_hash_move_forward_ex(&PHPDBG_G(bp)[PHPDBG_BREAK_OPCODE], &position)) { phpdbg_writeln("#%d\t\t%s%s", brake->id, brake->name, diff --git a/sapi/phpdbg/phpdbg_bp.h b/sapi/phpdbg/phpdbg_bp.h index b1a9ddf474..9356380cf7 100644 --- a/sapi/phpdbg/phpdbg_bp.h +++ b/sapi/phpdbg/phpdbg_bp.h @@ -138,7 +138,7 @@ PHPDBG_API void phpdbg_disable_breakpoints(TSRMLS_D); /* }}} */ /* {{{ Breakbase API */ PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakbase(zend_ulong id TSRMLS_DC); -PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakbase_ex(zend_ulong id, HashTable ***table, HashPosition *position TSRMLS_DC); /* }}} */ +PHPDBG_API phpdbg_breakbase_t *phpdbg_find_breakbase_ex(zend_ulong id, HashTable **table, HashPosition *position TSRMLS_DC); /* }}} */ /* {{{ Breakpoint Exportation API */ PHPDBG_API void phpdbg_export_breakpoints(FILE *handle TSRMLS_DC); /* }}} */ diff --git a/sapi/phpdbg/phpdbg_info.c b/sapi/phpdbg/phpdbg_info.c index 0f4233bf30..281cfc406a 100644 --- a/sapi/phpdbg/phpdbg_info.c +++ b/sapi/phpdbg/phpdbg_info.c @@ -44,15 +44,14 @@ PHPDBG_INFO(break) /* {{{ */ PHPDBG_INFO(files) /* {{{ */ { HashPosition pos; - char *fname; + zend_string *fname; phpdbg_notice("Included files: %d", zend_hash_num_elements(&EG(included_files))); zend_hash_internal_pointer_reset_ex(&EG(included_files), &pos); - while (zend_hash_get_current_key_ex(&EG(included_files), &fname, - NULL, NULL, 0, &pos) == HASH_KEY_IS_STRING) { - phpdbg_writeln("File: %s", fname); + while (zend_hash_get_current_key_ex(&EG(included_files), &fname, NULL, 0, &pos) == HASH_KEY_IS_STRING) { + phpdbg_writeln("File: %s", fname->val); zend_hash_move_forward_ex(&EG(included_files), &pos); } @@ -74,8 +73,8 @@ PHPDBG_INFO(vars) /* {{{ */ { HashTable vars; HashPosition pos; - char *var; - zval **data; + zend_string *var; + zval *data; if (!EG(active_op_array)) { phpdbg_error("No active op array!"); @@ -94,12 +93,10 @@ PHPDBG_INFO(vars) /* {{{ */ zend_hash_init(&vars, 8, NULL, NULL, 0); zend_hash_internal_pointer_reset_ex(EG(active_symbol_table), &pos); - while (zend_hash_get_current_key_ex(EG(active_symbol_table), &var, - NULL, NULL, 0, &pos) == HASH_KEY_IS_STRING) { - zend_hash_get_current_data_ex(EG(active_symbol_table), (void **)&data, &pos); - if (*var != '_') { - zend_hash_update( - &vars, var, strlen(var)+1, (void**)data, sizeof(zval*), NULL); + while (zend_hash_get_current_key_ex(EG(active_symbol_table), &var, NULL, 0, &pos) == HASH_KEY_IS_STRING) { + data = zend_hash_get_current_data_ex(EG(active_symbol_table), &pos); + if (*(var->val) != '_') { + zend_hash_update(&vars, var, data); } zend_hash_move_forward_ex(EG(active_symbol_table), &pos); } @@ -110,15 +107,15 @@ PHPDBG_INFO(vars) /* {{{ */ if (ops->function_name) { if (ops->scope) { phpdbg_notice( - "Variables in %s::%s() (%d)", ops->scope->name, ops->function_name, zend_hash_num_elements(&vars)); + "Variables in %s::%s() (%d)", ops->scope->name->val, ops->function_name->val, zend_hash_num_elements(&vars)); } else { phpdbg_notice( - "Variables in %s() (%d)", ops->function_name, zend_hash_num_elements(&vars)); + "Variables in %s() (%d)", ops->function_name->val, zend_hash_num_elements(&vars)); } } else { if (ops->filename) { phpdbg_notice( - "Variables in %s (%d)", ops->filename, zend_hash_num_elements(&vars)); + "Variables in %s (%d)", ops->filename->val, zend_hash_num_elements(&vars)); } else { phpdbg_notice( "Variables @ %p (%d)", ops, zend_hash_num_elements(&vars)); @@ -129,19 +126,19 @@ PHPDBG_INFO(vars) /* {{{ */ if (zend_hash_num_elements(&vars)) { phpdbg_writeln("Address\t\tRefs\tType\t\tVariable"); for (zend_hash_internal_pointer_reset_ex(&vars, &pos); - zend_hash_get_current_data_ex(&vars, (void**) &data, &pos) == SUCCESS; + (data = zend_hash_get_current_data_ex(&vars, &pos)) != NULL; zend_hash_move_forward_ex(&vars, &pos)) { - char *var; + zend_string *var; - zend_hash_get_current_key_ex(&vars, &var, NULL, NULL, 0, &pos); + zend_hash_get_current_key_ex(&vars, &var, NULL, 0, &pos); - if (*data) { + if (data) { phpdbg_write( "%p\t%d\t", - *data, - Z_REFCOUNT_PP(data)); + data, + Z_REFCOUNT_P(data)); - switch (Z_TYPE_PP(data)) { + switch (Z_TYPE_P(data)) { case IS_STRING: phpdbg_write("(string)\t"); break; case IS_LONG: phpdbg_write("(integer)\t"); break; case IS_DOUBLE: phpdbg_write("(float)\t"); break; @@ -151,12 +148,13 @@ PHPDBG_INFO(vars) /* {{{ */ case IS_NULL: phpdbg_write("(null)\t"); break; } - if (Z_TYPE_PP(data) == IS_RESOURCE) { + if (Z_TYPE_P(data) == IS_RESOURCE) { int type; phpdbg_writeln( - "%s$%s", Z_ISREF_PP(data) ? "&": "", var); - if (zend_list_find(Z_RESVAL_PP(data), &type)) { + "%s$%s", Z_ISREF_P(data) ? "&": "", var->val); + /*!!! FIXME + if (zend_list_find(Z_RESVAL_P(data), &type)) { phpdbg_write( "|-------(typeof)------> (%s)", zend_rsrc_list_get_rsrc_type(type TSRMLS_CC)); @@ -164,20 +162,21 @@ PHPDBG_INFO(vars) /* {{{ */ phpdbg_write( "|-------(typeof)------> (unknown)"); } + */ phpdbg_writeln(EMPTY); - } else if (Z_TYPE_PP(data) == IS_OBJECT) { + } else if (Z_TYPE_P(data) == IS_OBJECT) { phpdbg_writeln( - "%s$%s", Z_ISREF_PP(data) ? "&": "", var); + "%s$%s", Z_ISREF_P(data) ? "&": "", var->val); phpdbg_write( - "|-----(instanceof)----> (%s)", Z_OBJCE_PP(data)->name); + "|-----(instanceof)----> (%s)", Z_OBJCE_P(data)->name->val); phpdbg_writeln(EMPTY); } else { phpdbg_write( - "%s$%s", Z_ISREF_PP(data) ? "&": "", var); + "%s$%s", Z_ISREF_P(data) ? "&": "", var->val); } } else { phpdbg_write( - "n/a\tn/a\tn/a\t$%s", var); + "n/a\tn/a\tn/a\t$%s", var->val); } phpdbg_writeln(EMPTY); } @@ -249,35 +248,34 @@ PHPDBG_INFO(memory) /* {{{ */ return SUCCESS; } /* }}} */ -static inline void phpdbg_print_class_name(zend_class_entry **ce TSRMLS_DC) /* {{{ */ +static inline void phpdbg_print_class_name(zend_class_entry *ce TSRMLS_DC) /* {{{ */ { phpdbg_write( "%s %s %s (%d)", - ((*ce)->type == ZEND_USER_CLASS) ? + (ce->type == ZEND_USER_CLASS) ? "User" : "Internal", - ((*ce)->ce_flags & ZEND_ACC_INTERFACE) ? + (ce->ce_flags & ZEND_ACC_INTERFACE) ? "Interface" : - ((*ce)->ce_flags & ZEND_ACC_ABSTRACT) ? + (ce->ce_flags & ZEND_ACC_ABSTRACT) ? "Abstract Class" : "Class", - (*ce)->name, zend_hash_num_elements(&(*ce)->function_table)); + ce->name->val, zend_hash_num_elements(&ce->function_table)); } /* }}} */ PHPDBG_INFO(classes) /* {{{ */ { HashPosition position; - zend_class_entry **ce; + zend_class_entry *ce; HashTable classes; zend_hash_init(&classes, 8, NULL, NULL, 0); for (zend_hash_internal_pointer_reset_ex(EG(class_table), &position); - zend_hash_get_current_data_ex(EG(class_table), (void**)&ce, &position) == SUCCESS; + (ce = zend_hash_get_current_data_ptr_ex(EG(class_table), &position)) != NULL; zend_hash_move_forward_ex(EG(class_table), &position)) { - if ((*ce)->type == ZEND_USER_CLASS) { - zend_hash_next_index_insert( - &classes, ce, sizeof(ce), NULL); + if (ce->type == ZEND_USER_CLASS) { + zend_hash_next_index_insert_mem(&classes, ce, sizeof(ce)); } } @@ -285,26 +283,26 @@ PHPDBG_INFO(classes) /* {{{ */ zend_hash_num_elements(&classes)); for (zend_hash_internal_pointer_reset_ex(&classes, &position); - zend_hash_get_current_data_ex(&classes, (void**)&ce, &position) == SUCCESS; + (ce = zend_hash_get_current_data_ptr_ex(&classes, &position)) != NULL; zend_hash_move_forward_ex(&classes, &position)) { phpdbg_print_class_name(ce TSRMLS_CC); phpdbg_writeln(EMPTY); - if ((*ce)->parent) { - zend_class_entry *pce = (*ce)->parent; + if (ce->parent) { + zend_class_entry *pce = ce->parent; do { phpdbg_write("|-------- "); - phpdbg_print_class_name(&pce TSRMLS_CC); + phpdbg_print_class_name(pce TSRMLS_CC); phpdbg_writeln(EMPTY); } while ((pce = pce->parent)); } - if ((*ce)->info.user.filename) { + if (ce->info.user.filename) { phpdbg_writeln( "|---- in %s on line %u", - (*ce)->info.user.filename, - (*ce)->info.user.line_start); + ce->info.user.filename->val, + ce->info.user.line_start); } else { phpdbg_writeln("|---- no source code"); } @@ -319,18 +317,17 @@ PHPDBG_INFO(classes) /* {{{ */ PHPDBG_INFO(funcs) /* {{{ */ { HashPosition position; - zend_function *zf, **pzf; + zend_function *zf, *pzf; HashTable functions; zend_hash_init(&functions, 8, NULL, NULL, 0); for (zend_hash_internal_pointer_reset_ex(EG(function_table), &position); - zend_hash_get_current_data_ex(EG(function_table), (void**)&zf, &position) == SUCCESS; + (zf = zend_hash_get_current_data_ptr_ex(EG(function_table), &position)) != NULL; zend_hash_move_forward_ex(EG(function_table), &position)) { if (zf->type == ZEND_USER_FUNCTION) { - zend_hash_next_index_insert( - &functions, (void**) &zf, sizeof(zend_function), NULL); + zend_hash_next_index_insert_mem(&functions, zf, sizeof(zend_function)); } } @@ -338,14 +335,14 @@ PHPDBG_INFO(funcs) /* {{{ */ zend_hash_num_elements(&functions)); for (zend_hash_internal_pointer_reset_ex(&functions, &position); - zend_hash_get_current_data_ex(&functions, (void**)&pzf, &position) == SUCCESS; + (pzf = zend_hash_get_current_data_ptr_ex(&functions, &position)) != NULL; zend_hash_move_forward_ex(&functions, &position)) { - zend_op_array *op_array = &((*pzf)->op_array); + zend_op_array *op_array = &pzf->op_array; phpdbg_writeln( "|-------- %s in %s on line %d", - op_array->function_name ? op_array->function_name : "{main}", - op_array->filename ? op_array->filename : "(no source code)", + op_array->function_name ? op_array->function_name->val : "{main}", + op_array->filename ? op_array->filename->val : "(no source code)", op_array->line_start); } diff --git a/sapi/phpdbg/phpdbg_list.c b/sapi/phpdbg/phpdbg_list.c index eb1091550b..4ef3db98ea 100644 --- a/sapi/phpdbg/phpdbg_list.c +++ b/sapi/phpdbg/phpdbg_list.c @@ -75,13 +75,16 @@ PHPDBG_LIST(method) /* {{{ */ { switch (param->type) { case METHOD_PARAM: { - zend_class_entry **ce; + zend_class_entry *ce; + zval name; - if (zend_lookup_class(param->method.class, strlen(param->method.class), &ce TSRMLS_CC) == SUCCESS) { + ZVAL_STRINGL(&name, param->method.class, strlen(param->method.class)); + if ((ce = zend_lookup_class(Z_STR(name) TSRMLS_CC)) != NULL) { zend_function *function; char *lcname = zend_str_tolower_dup(param->method.name, strlen(param->method.name)); - if (zend_hash_find(&(*ce)->function_table, lcname, strlen(lcname)+1, (void**) &function) == SUCCESS) { + zval_ptr_dtor(&name); + if ((function = zend_hash_str_find_ptr(&ce->function_table, lcname, strlen(lcname))) != NULL) { phpdbg_list_function(function TSRMLS_CC); } else { phpdbg_error("Could not find %s::%s", param->method.class, param->method.name); @@ -89,6 +92,7 @@ PHPDBG_LIST(method) /* {{{ */ efree(lcname); } else { + zval_ptr_dtor(&name); phpdbg_error("Could not find the class %s", param->method.class); } } break; @@ -103,23 +107,27 @@ PHPDBG_LIST(class) /* {{{ */ { switch (param->type) { case STR_PARAM: { - zend_class_entry **ce; - - if (zend_lookup_class(param->str, param->len, &ce TSRMLS_CC) == SUCCESS) { - if ((*ce)->type == ZEND_USER_CLASS) { - if ((*ce)->info.user.filename) { + zend_class_entry *ce; + zval name; + + ZVAL_STRINGL(&name, param->str, param->len); + if ((ce = zend_lookup_class(Z_STR(name) TSRMLS_CC)) != NULL) { + zval_ptr_dtor(&name); + if (ce->type == ZEND_USER_CLASS) { + if (ce->info.user.filename) { phpdbg_list_file( - (*ce)->info.user.filename, - (*ce)->info.user.line_end - (*ce)->info.user.line_start + 1, - (*ce)->info.user.line_start, 0 TSRMLS_CC + ce->info.user.filename->val, + ce->info.user.line_end - ce->info.user.line_start + 1, + ce->info.user.line_start, 0 TSRMLS_CC ); } else { - phpdbg_error("The source of the requested class (%s) cannot be found", (*ce)->name); + phpdbg_error("The source of the requested class (%s) cannot be found", ce->name->val); } } else { - phpdbg_error("The class requested (%s) is not user defined", (*ce)->name); + phpdbg_error("The class requested (%s) is not user defined", ce->name->val); } } else { + zval_ptr_dtor(&name); phpdbg_error("The requested class (%s) could not be found", param->str); } } break; @@ -236,7 +244,7 @@ void phpdbg_list_function(const zend_function *fbc TSRMLS_DC) /* {{{ */ ops = (zend_op_array*)fbc; - phpdbg_list_file(ops->filename, + phpdbg_list_file(ops->filename->val, ops->line_end - ops->line_start + 1, ops->line_start, 0 TSRMLS_CC); } /* }}} */ @@ -268,7 +276,7 @@ void phpdbg_list_function_byname(const char *str, size_t len TSRMLS_DC) /* {{{ * /* use lowercase names, case insensitive */ func_name = zend_str_tolower_dup(func_name, func_name_len); - if (zend_hash_find(func_table, func_name, func_name_len+1, (void**)&fbc) == SUCCESS) { + if ((fbc = zend_hash_str_find_ptr(func_table, func_name, func_name_len)) != NULL) { phpdbg_list_function(fbc TSRMLS_CC); } else { phpdbg_error("Function %s not found", func_name); diff --git a/sapi/phpdbg/phpdbg_opcode.c b/sapi/phpdbg/phpdbg_opcode.c index 50073eb22b..17c5fbdec5 100644 --- a/sapi/phpdbg/phpdbg_opcode.c +++ b/sapi/phpdbg/phpdbg_opcode.c @@ -46,20 +46,19 @@ static inline char *phpdbg_decode_op(zend_op_array *ops, znode_op *op, zend_uint switch (type &~ EXT_TYPE_UNUSED) { case IS_CV: - asprintf(&decode, "$%s", ops->vars[op->var].name); + asprintf(&decode, "$%s", ops->vars[op->var]->val); break; case IS_VAR: case IS_TMP_VAR: { zend_ulong id = 0, *pid = NULL; if (vars != NULL) { - if (zend_hash_index_find(vars, (zend_ulong) ops->vars - op->var, (void**) &pid) != SUCCESS) { + if ((pid = zend_hash_index_find_ptr(vars, (zend_ulong) ops->vars - op->var)) == NULL) { id = zend_hash_num_elements(vars); - zend_hash_index_update( - vars, (zend_ulong) ops->vars - op->var, - (void**) &id, - sizeof(zend_ulong), NULL); - } else id = *pid; + zend_hash_index_update_mem(vars, (zend_ulong)ops->vars - op->var, &id, sizeof(zend_ulong)); + } else { + id = *pid; + } } asprintf(&decode, "@%lu", id); } break; @@ -158,7 +157,7 @@ void phpdbg_print_opline_ex(zend_execute_data *execute_data, HashTable *vars, ze opline, phpdbg_decode_opcode(opline->opcode), decode, - execute_data->op_array->filename ? execute_data->op_array->filename : "unknown"); + execute_data->op_array->filename ? execute_data->op_array->filename->val : "unknown"); } if (!ignore_flags && PHPDBG_G(oplog)) { @@ -167,7 +166,7 @@ void phpdbg_print_opline_ex(zend_execute_data *execute_data, HashTable *vars, ze opline, phpdbg_decode_opcode(opline->opcode), decode, - execute_data->op_array->filename ? execute_data->op_array->filename : "unknown"); + execute_data->op_array->filename ? execute_data->op_array->filename->val : "unknown"); } if (decode) { diff --git a/sapi/phpdbg/phpdbg_utils.c b/sapi/phpdbg/phpdbg_utils.c index 1effcfccaf..7548c240b9 100644 --- a/sapi/phpdbg/phpdbg_utils.c +++ b/sapi/phpdbg/phpdbg_utils.c @@ -161,20 +161,22 @@ PHPDBG_API const zend_function *phpdbg_get_function(const char *fname, const cha char *lcname = zend_str_tolower_dup(fname, fname_len); if (cname) { - zend_class_entry **ce; + zval name; + zend_class_entry *ce; size_t cname_len = strlen(cname); char *lc_cname = zend_str_tolower_dup(cname, cname_len); - int ret = zend_lookup_class(lc_cname, cname_len, &ce TSRMLS_CC); + + ZVAL_STRINGL(&name, lc_cname, cname_len); + ce = zend_lookup_class(Z_STR(name) TSRMLS_CC); efree(lc_cname); + zval_ptr_dtor(&name); - if (ret == SUCCESS) { - zend_hash_find(&(*ce)->function_table, lcname, fname_len+1, - (void**)&func); + if (ce != NULL) { + func = zend_hash_str_find_ptr(&ce->function_table, lcname, fname_len); } } else { - zend_hash_find(EG(function_table), lcname, fname_len+1, - (void**)&func); + func = zend_hash_str_find_ptr(EG(function_table), lcname, fname_len); } efree(lcname); |