static void zend_closure_call_magic(INTERNAL_FUNCTION_PARAMETERS) /* {{{ */ { zend_fcall_info fci; zend_fcall_info_cache fcc; zval params[2]; memset(&fci, 0, sizeof(zend_fcall_info)); memset(&fci, 0, sizeof(zend_fcall_info_cache)); fci.size = sizeof(zend_fcall_info); fci.retval = return_value; fcc.initialized = 1; fcc.function_handler = (zend_function *) EX(func)->common.arg_info; fci.params = params; fci.param_count = 2; ZVAL_STR(&fci.params[0], EX(func)->common.function_name); array_init(&fci.params[1]); zend_copy_parameters_array(ZEND_NUM_ARGS(), &fci.params[1]); fci.object = Z_OBJ(EX(This)); fcc.object = Z_OBJ(EX(This)); fcc.calling_scope = zend_get_executed_scope(); zend_call_function(&fci, &fcc); zval_ptr_dtor(&fci.params[0]); zval_ptr_dtor(&fci.params[1]); }
static ZEND_NAMED_FUNCTION(zend_closure_call_magic) /* {{{ */ { zend_fcall_info fci; zend_fcall_info_cache fcc; zval params[2]; memset(&fci, 0, sizeof(zend_fcall_info)); memset(&fcc, 0, sizeof(zend_fcall_info_cache)); fci.size = sizeof(zend_fcall_info); fci.retval = return_value; fcc.function_handler = (zend_function *) EX(func)->common.arg_info; fci.params = params; fci.param_count = 2; ZVAL_STR(&fci.params[0], EX(func)->common.function_name); if (ZEND_NUM_ARGS()) { array_init_size(&fci.params[1], ZEND_NUM_ARGS()); zend_copy_parameters_array(ZEND_NUM_ARGS(), &fci.params[1]); } else { ZVAL_EMPTY_ARRAY(&fci.params[1]); } fci.object = Z_OBJ(EX(This)); fcc.object = Z_OBJ(EX(This)); zend_call_function(&fci, &fcc); zval_ptr_dtor(&fci.params[0]); zval_ptr_dtor(&fci.params[1]); }
static PHP_METHOD(Operand, getName) { php_inspector_operand_t *operand = php_inspector_operand_this(); if (operand->type & IS_CV) { php_inspector_opline_t *opline = php_inspector_opline_fetch_from(Z_OBJ(operand->opline)); php_inspector_scope_t *scope = php_inspector_scope_fetch_from(Z_OBJ(opline->scope)); RETURN_STR(zend_string_copy(scope->ops->vars[EX_VAR_TO_NUM(operand->op->var)])); } }
ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished_execution) /* {{{ */ { if (Z_TYPE(generator->value) != IS_UNDEF) { zval_ptr_dtor(&generator->value); ZVAL_UNDEF(&generator->value); } if (Z_TYPE(generator->key) != IS_UNDEF) { zval_ptr_dtor(&generator->key); ZVAL_UNDEF(&generator->key); } if (generator->execute_data) { zend_execute_data *execute_data = generator->execute_data; zend_op_array *op_array = &execute_data->func->op_array; if (!execute_data->symbol_table) { zend_free_compiled_variables(execute_data); } else { zend_clean_and_cache_symbol_table(execute_data->symbol_table); } if (Z_OBJ(execute_data->This)) { OBJ_RELEASE(Z_OBJ(execute_data->This)); } /* A fatal error / die occurred during the generator execution. Trying to clean * up the stack may not be safe in this case. */ if (CG(unclean_shutdown)) { generator->execute_data = NULL; return; } zend_vm_stack_free_extra_args(generator->execute_data); /* Some cleanups are only necessary if the generator was closued * before it could finish execution (reach a return statement). */ if (!finished_execution) { zend_generator_cleanup_unfinished_execution(generator); } /* Free a clone of closure */ if (op_array->fn_flags & ZEND_ACC_CLOSURE) { destroy_op_array(op_array); efree_size(op_array, sizeof(zend_op_array)); } efree(generator->stack); generator->execute_data = NULL; } }
static void zend_generator_cleanup_unfinished_execution(zend_generator *generator) /* {{{ */ { zend_execute_data *execute_data = generator->execute_data; zend_op_array *op_array = &execute_data->func->op_array; if (generator->send_target) { if (Z_REFCOUNTED_P(generator->send_target)) Z_DELREF_P(generator->send_target); generator->send_target = NULL; } /* Manually free loop variables, as execution couldn't reach their * SWITCH_FREE / FREE opcodes. */ { /* -1 required because we want the last run opcode, not the * next to-be-run one. */ uint32_t op_num = execute_data->opline - op_array->opcodes - 1; int i; for (i = 0; i < op_array->last_brk_cont; ++i) { zend_brk_cont_element *brk_cont = op_array->brk_cont_array + i; if (brk_cont->start < 0) { continue; } else if ((uint32_t)brk_cont->start > op_num) { break; } else if (brk_cont->brk >= 0 && (uint32_t)brk_cont->brk > op_num) { zend_op *brk_opline = op_array->opcodes + brk_cont->brk; if (brk_opline->opcode == ZEND_FREE) { zval *var = EX_VAR(brk_opline->op1.var); zval_ptr_dtor_nogc(var); } else if (brk_opline->opcode == ZEND_FE_FREE) { zval *var = EX_VAR(brk_opline->op1.var); if (Z_TYPE_P(var) != IS_ARRAY && Z_FE_ITER_P(var) != (uint32_t)-1) { zend_hash_iterator_del(Z_FE_ITER_P(var)); } zval_ptr_dtor_nogc(var); } } } } /* If yield was used as a function argument there may be active * method calls those objects need to be freed */ while (execute_data->call) { if (Z_OBJ(execute_data->call->This)) { OBJ_RELEASE(Z_OBJ(execute_data->call->This)); } execute_data->call = execute_data->call->prev_execute_data; } }
static PHP_METHOD(Operand, getNumber) { php_inspector_operand_t *operand = php_inspector_operand_this(); php_inspector_opline_t *opline = php_inspector_opline_fetch_from(Z_OBJ(operand->opline)); php_inspector_scope_t *scope = php_inspector_scope_fetch_from(Z_OBJ(opline->scope)); switch(opline->opline->opcode) { case ZEND_JMP: case ZEND_FAST_CALL: case ZEND_DECLARE_ANON_CLASS: case ZEND_DECLARE_ANON_INHERITED_CLASS: if (operand->which == PHP_INSPECTOR_OPLINE_OP1) { ZEND_PASS_TWO_UNDO_JMP_TARGET(scope->ops, opline->opline, *operand->op); ZVAL_LONG(return_value, operand->op->num); ZEND_PASS_TWO_UPDATE_JMP_TARGET(scope->ops, opline->opline, *operand->op); break; } case ZEND_JMPZNZ: case ZEND_JMPZ: case ZEND_JMPNZ: case ZEND_JMPZ_EX: case ZEND_JMP_SET: case ZEND_COALESCE: case ZEND_NEW: case ZEND_FE_RESET_R: case ZEND_FE_RESET_RW: case ZEND_ASSERT_CHECK: if (operand->which == PHP_INSPECTOR_OPLINE_OP2) { ZEND_PASS_TWO_UNDO_JMP_TARGET(scope->ops, opline->opline, *operand->op); ZVAL_LONG(return_value, operand->op->num); ZEND_PASS_TWO_UPDATE_JMP_TARGET(scope->ops, opline->opline, *operand->op); break; } default: { if (operand->type & IS_CONST) { ZEND_PASS_TWO_UNDO_CONSTANT(scope->ops, *operand->op); ZVAL_LONG(return_value, operand->op->num); ZEND_PASS_TWO_UPDATE_CONSTANT(scope->ops, *operand->op); } else if (operand->type & IS_TMP_VAR|IS_VAR) { ZVAL_LONG(return_value, EX_VAR_TO_NUM(operand->op->num - scope->ops->last_var)); } else if (operand->type & IS_CV) { ZVAL_LONG(return_value, EX_VAR_TO_NUM(operand->op->num)); } } } }
static PHP_METHOD(Operand, getValue) { php_inspector_operand_t *operand = php_inspector_operand_this(); if (operand->type & IS_CONST) { php_inspector_opline_t *opline = php_inspector_opline_fetch_from(Z_OBJ(operand->opline)); php_inspector_scope_t *scope = php_inspector_scope_fetch_from(Z_OBJ(opline->scope)); ZEND_PASS_TWO_UNDO_CONSTANT(scope->ops, *operand->op); ZVAL_COPY(return_value, &scope->ops->literals[operand->op->num]); ZEND_PASS_TWO_UPDATE_CONSTANT(scope->ops, *operand->op); } }
void stream_client_do_connect_nonblocking( skyray_stream_client_t *self, zend_object *protocol_obj, zend_string *host, zend_long port, zval *return_value) { skyray_reactor_t *reactor = skyray_reactor_from_obj(Z_OBJ_P(self->reactor)); zval zstream; object_init_ex(&zstream, skyray_ce_Stream); skyray_stream_t * stream = skyray_stream_from_obj(Z_OBJ(zstream)); skyray_stream_init_nonblocking(stream, SR_TCP, reactor, protocol_obj); struct sockaddr_in addr; uv_ip4_addr(host->val, port, &addr); uv_connect_t *req = (uv_connect_t*)emalloc(sizeof(uv_connect_t)); req->type = UV_TCP; req->data = stream; uv_tcp_connect(req, &stream->tcp, (struct sockaddr*)&addr, on_connected); ZVAL_COPY(return_value, &zstream); }
static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type, int skip_top_traces) /* {{{ */ { zval obj; zend_object *object; zval trace; zend_class_entry *base_ce; zend_string *filename; Z_OBJ(obj) = object = zend_objects_new(class_type); Z_OBJ_HT(obj) = &default_exception_handlers; object_properties_init(object, class_type); if (EG(current_execute_data)) { zend_fetch_debug_backtrace(&trace, skip_top_traces, 0, 0); } else { array_init(&trace); } Z_SET_REFCOUNT(trace, 0); base_ce = i_get_exception_base(&obj); if (EXPECTED(class_type != zend_ce_parse_error || !(filename = zend_get_compiled_filename()))) { zend_update_property_string(base_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename()); zend_update_property_long(base_ce, &obj, "line", sizeof("line")-1, zend_get_executed_lineno()); } else { zend_update_property_str(base_ce, &obj, "file", sizeof("file")-1, filename); zend_update_property_long(base_ce, &obj, "line", sizeof("line")-1, zend_get_compiled_lineno()); } zend_update_property(base_ce, &obj, "trace", sizeof("trace")-1, &trace); return object; }
skyray_process_watcher_t * skyray_process_watcher_new(skyray_reactor_t *reactor, zval *zprocess, zval *handler) { zval object; skyray_process_watcher_t *intern; skyray_process_t *process = skyray_process_from_obj(Z_OBJ_P(zprocess)); if (process->watcher) { zend_throw_exception_ex(skyray_ce_InvalidParamException, 0, "The process is already under watching, unable to watch again"); return NULL; } object_init_ex(&object, skyray_ce_ProcessWatcher); zend_update_property(skyray_ce_ProcessWatcherHandler, handler, ZEND_STRL("watcher"), &object); intern = skyray_process_watcher_from_obj(Z_OBJ(object)); intern->process = process; intern->handler = Z_OBJ_P(handler); zval_add_ref(handler); zval_add_ref(zprocess); process->watcher = intern; if (skyray_sigchld_count < 0) { uv_signal_init(&reactor->loop, &skyray_sigchld); skyray_sigchld_count = 0; } if (skyray_sigchld_count == 0) { uv_signal_start(&skyray_sigchld, signal_cb, SIGCHLD); } skyray_sigchld_count ++; return intern; }
/* {{{ */ static PHP_METHOD(Operand, isJumpTarget) { php_inspector_operand_t *operand = php_inspector_operand_this(); php_inspector_opline_t *opline = php_inspector_opline_fetch_from(Z_OBJ(operand->opline)); switch(opline->opline->opcode) { case ZEND_JMP: case ZEND_FAST_CALL: case ZEND_DECLARE_ANON_CLASS: case ZEND_DECLARE_ANON_INHERITED_CLASS: if (operand->which == PHP_INSPECTOR_OPLINE_OP1) { RETURN_TRUE; } break; case ZEND_JMPZNZ: case ZEND_JMPZ: case ZEND_JMPNZ: case ZEND_JMPZ_EX: case ZEND_JMP_SET: case ZEND_COALESCE: case ZEND_NEW: case ZEND_FE_RESET_R: case ZEND_FE_RESET_RW: case ZEND_ASSERT_CHECK: if (operand->which == PHP_INSPECTOR_OPLINE_OP2) { RETURN_TRUE; } break; } RETURN_FALSE; }
static zend_object *zend_closure_clone(zval *zobject) /* {{{ */ { zend_closure *closure = (zend_closure *)Z_OBJ_P(zobject); zval result; zend_create_closure(&result, &closure->func, closure->func.common.scope, &closure->this_ptr); return Z_OBJ(result); }
/* {{{ proto void ResourceBundle::__construct( string $locale [, string $bundlename [, bool $fallback = true ]] ) * ResourceBundle object constructor */ PHP_METHOD( ResourceBundle, __construct ) { zval orig_this = *getThis(); return_value = getThis(); resourcebundle_ctor(INTERNAL_FUNCTION_PARAM_PASSTHRU); if (Z_TYPE_P(return_value) == IS_OBJECT && Z_OBJ_P(return_value) == NULL) { zend_object_store_ctor_failed(Z_OBJ(orig_this)); ZEND_CTOR_MAKE_NULL(); } }
U_CFUNC PHP_METHOD(IntlRuleBasedBreakIterator, __construct) { zval orig_this = *getThis(); return_value = getThis(); _php_intlrbbi_constructor_body(INTERNAL_FUNCTION_PARAM_PASSTHRU); if (Z_TYPE_P(return_value) == IS_OBJECT && Z_OBJ_P(return_value) == NULL) { zend_object_store_ctor_failed(Z_OBJ(orig_this)); zval_dtor(&orig_this); ZEND_CTOR_MAKE_NULL(); } }
zend_object * pion_exception_new(zend_class_entry * exception_ce, const char * message, long code) { zval ex; // A(ex); object_init_ex(&ex, exception_ce); // zend_objects_new(); if (message) { zend_update_property_string(exception_ce, &ex, "message", sizeof("message")-1, message); } if (code) { zend_update_property_long(exception_ce, &ex, "code", sizeof("code")-1, code); } return Z_OBJ(ex); }
/* {{{ proto void NumberFormatter::__construct( string $locale, int style[, string $pattern ] ) * NumberFormatter object constructor. */ PHP_METHOD( NumberFormatter, __construct ) { zval orig_this = *getThis(); return_value = getThis(); numfmt_ctor(INTERNAL_FUNCTION_PARAM_PASSTHRU); if (Z_TYPE_P(return_value) == IS_OBJECT && Z_OBJ_P(return_value) == NULL) { zend_object_store_ctor_failed(Z_OBJ(orig_this) TSRMLS_CC); zval_dtor(&orig_this); ZEND_CTOR_MAKE_NULL(); } }
/* {{{ proto void IntlDateFormatter::__construct(string $locale, long date_type, long time_type[, string $timezone_str, long $calendar, string $pattern]) * IntlDateFormatter object constructor. */ U_CFUNC PHP_METHOD( IntlDateFormatter, __construct ) { zval orig_this = *getThis(); /* return_value param is being changed, therefore we will always return * NULL here */ return_value = getThis(); datefmt_ctor(INTERNAL_FUNCTION_PARAM_PASSTHRU); if (Z_TYPE_P(return_value) == IS_OBJECT && Z_OBJ_P(return_value) == NULL) { zend_object_store_ctor_failed(Z_OBJ(orig_this)); ZEND_CTOR_MAKE_NULL(); } }
int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zend_object **obj_ptr) /* {{{ */ { zend_closure *closure = (zend_closure *)Z_OBJ_P(obj); *fptr_ptr = &closure->func; *ce_ptr = closure->called_scope; if (Z_TYPE(closure->this_ptr) != IS_UNDEF) { *obj_ptr = Z_OBJ(closure->this_ptr); } else { *obj_ptr = NULL; } return SUCCESS; }
U_CFUNC PHP_METHOD(IntlGregorianCalendar, __construct) { zval orig_this = *getThis(); intl_error_reset(NULL TSRMLS_CC); return_value = getThis(); //changes this to IS_NULL (without first destroying) if there's an error _php_intlgregcal_constructor_body(INTERNAL_FUNCTION_PARAM_PASSTHRU); if (Z_TYPE_P(return_value) == IS_OBJECT && Z_OBJ_P(return_value) == NULL) { zend_object_store_ctor_failed(Z_OBJ(orig_this) TSRMLS_CC); zval_dtor(&orig_this); ZEND_CTOR_MAKE_NULL(); } }
/* {{{ */ static inline int php_memoize_leave_helper(zend_execute_data *execute_data) { zend_execute_data *call = EX(call); uint32_t info = ZEND_CALL_INFO(call); if (info & ZEND_CALL_RELEASE_THIS) { OBJ_RELEASE(Z_OBJ(call->This)); } else if (info & ZEND_CALL_CLOSURE) { OBJ_RELEASE((zend_object*)call->func->op_array.prototype); } EX(call) = call->prev_execute_data; zend_vm_stack_free_args(call); zend_vm_stack_free_call_frame(call); EX(opline) = EX(opline) + 1; return ZEND_USER_OPCODE_LEAVE; } /* }}} */
/* {{{ xml_call_handler() */ static void xml_call_handler(xml_parser *parser, zval *handler, zend_function *function_ptr, int argc, zval *argv, zval *retval) { int i; ZVAL_UNDEF(retval); if (parser && handler && !EG(exception)) { int result; zend_fcall_info fci; fci.size = sizeof(fci); fci.function_table = EG(function_table); ZVAL_COPY_VALUE(&fci.function_name, handler); fci.symbol_table = NULL; fci.object = Z_OBJ(parser->object); fci.retval = retval; fci.param_count = argc; fci.params = argv; fci.no_separation = 0; /*fci.function_handler_cache = &function_ptr;*/ result = zend_call_function(&fci, NULL); if (result == FAILURE) { zval *method; zval *obj; if (Z_TYPE_P(handler) == IS_STRING) { php_error_docref(NULL, E_WARNING, "Unable to call handler %s()", Z_STRVAL_P(handler)); } else if ((obj = zend_hash_index_find(Z_ARRVAL_P(handler), 0)) != NULL && (method = zend_hash_index_find(Z_ARRVAL_P(handler), 1)) != NULL && Z_TYPE_P(obj) == IS_OBJECT && Z_TYPE_P(method) == IS_STRING) { php_error_docref(NULL, E_WARNING, "Unable to call handler %s::%s()", Z_OBJCE_P(obj)->name->val, Z_STRVAL_P(method)); } else php_error_docref(NULL, E_WARNING, "Unable to call handler"); } } for (i = 0; i < argc; i++) { zval_ptr_dtor(&argv[i]); } }
static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type, int skip_top_traces) /* {{{ */ { zval obj, tmp; zend_object *object; zval trace; zend_class_entry *base_ce; zend_string *filename; Z_OBJ(obj) = object = zend_objects_new(class_type); Z_OBJ_HT(obj) = &default_exception_handlers; object_properties_init(object, class_type); if (EG(current_execute_data)) { zend_fetch_debug_backtrace(&trace, skip_top_traces, 0, 0); } else { array_init(&trace); } Z_SET_REFCOUNT(trace, 0); base_ce = i_get_exception_base(&obj); if (EXPECTED((class_type != zend_ce_parse_error && class_type != zend_ce_compile_error) || !(filename = zend_get_compiled_filename()))) { ZVAL_STRING(&tmp, zend_get_executed_filename()); zend_update_property_ex(base_ce, &obj, ZSTR_KNOWN(ZEND_STR_FILE), &tmp); zval_ptr_dtor(&tmp); ZVAL_LONG(&tmp, zend_get_executed_lineno()); zend_update_property_ex(base_ce, &obj, ZSTR_KNOWN(ZEND_STR_LINE), &tmp); } else { ZVAL_STR(&tmp, filename); zend_update_property_ex(base_ce, &obj, ZSTR_KNOWN(ZEND_STR_FILE), &tmp); ZVAL_LONG(&tmp, zend_get_compiled_lineno()); zend_update_property_ex(base_ce, &obj, ZSTR_KNOWN(ZEND_STR_LINE), &tmp); } zend_update_property_ex(base_ce, &obj, ZSTR_KNOWN(ZEND_STR_TRACE), &trace); return object; }
ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_jit_leave_nested_func_helper(uint32_t call_info EXECUTE_DATA_DC) { zend_execute_data *old_execute_data; if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) { zend_clean_and_cache_symbol_table(EX(symbol_table)); } EG(current_execute_data) = EX(prev_execute_data); if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) { OBJ_RELEASE(Z_OBJ(execute_data->This)); } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) { OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func))); } zend_vm_stack_free_extra_args_ex(call_info, execute_data); old_execute_data = execute_data; execute_data = EX(prev_execute_data); zend_vm_stack_free_call_frame_ex(call_info, old_execute_data); if (UNEXPECTED(EG(exception) != NULL)) { const zend_op *old_opline = EX(opline); zend_throw_exception_internal(NULL); if (old_opline->result_type != IS_UNDEF) { zval_ptr_dtor(EX_VAR(old_opline->result.var)); } #ifndef HAVE_GCC_GLOBAL_REGS return 2; // ZEND_VM_LEAVE #endif } else { EX(opline)++; #ifdef HAVE_GCC_GLOBAL_REGS opline = EX(opline); #else return 2; // ZEND_VM_LEAVE #endif } }
/* {{{ Cassandra\Date::toDateTime() */ PHP_METHOD(Date, toDateTime) { cassandra_date *self; zval *ztime = NULL; cassandra_time* time_obj = NULL; php5to7_zval datetime; php_date_obj *datetime_obj = NULL; char *str; int str_len; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &ztime) == FAILURE) { return; } if (ztime != NULL) { time_obj = PHP_CASSANDRA_GET_TIME(ztime); } self = PHP_CASSANDRA_GET_DATE(getThis()); PHP5TO7_ZVAL_MAYBE_MAKE(datetime); php_date_instantiate(php_date_get_date_ce(), PHP5TO7_ZVAL_MAYBE_P(datetime) TSRMLS_CC); #if PHP_MAJOR_VERSION >= 7 datetime_obj = php_date_obj_from_obj(Z_OBJ(datetime)); #else datetime_obj = zend_object_store_get_object(datetime TSRMLS_CC); #endif str_len = spprintf(&str, 0, "%lld", cass_date_time_to_epoch(self->date, time_obj != NULL ? time_obj->time : 0)); php_date_initialize(datetime_obj, str, str_len, "U", NULL, 0 TSRMLS_CC); efree(str); RETVAL_ZVAL(PHP5TO7_ZVAL_MAYBE_P(datetime), 0, 1); }
int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zend_object **obj_ptr) /* {{{ */ { zend_closure *closure; if (Z_TYPE_P(obj) != IS_OBJECT) { return FAILURE; } closure = (zend_closure *)Z_OBJ_P(obj); *fptr_ptr = &closure->func; if (Z_TYPE(closure->this_ptr) != IS_UNDEF) { if (obj_ptr) { *obj_ptr = Z_OBJ(closure->this_ptr); } *ce_ptr = Z_OBJCE(closure->this_ptr); } else { if (obj_ptr) { *obj_ptr = NULL; } *ce_ptr = closure->func.common.scope; } return SUCCESS; }
U_CFUNC PHP_FUNCTION(intlcal_from_date_time) { zval *zv_arg, zv_tmp, *zv_datetime = NULL, zv_timestamp; php_date_obj *datetime; char *locale_str = NULL; int locale_str_len; TimeZone *timeZone; UErrorCode status = U_ZERO_ERROR; Calendar *cal; intl_error_reset(NULL TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|s!", &zv_arg, &locale_str, &locale_str_len) == FAILURE) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intlcal_from_date_time: bad arguments", 0 TSRMLS_CC); RETURN_NULL(); } if (!(Z_TYPE_P(zv_arg) == IS_OBJECT && instanceof_function( Z_OBJCE_P(zv_arg), php_date_get_date_ce() TSRMLS_CC))) { object_init_ex(&zv_tmp, php_date_get_date_ce()); zend_call_method_with_1_params(&zv_tmp, NULL, NULL, "__construct", NULL, zv_arg); if (EG(exception)) { zend_object_store_ctor_failed(Z_OBJ(zv_tmp) TSRMLS_CC); goto error; } zv_datetime = &zv_tmp; } else { zv_datetime = zv_arg; } datetime = Z_PHPDATE_P(zv_datetime); if (!datetime->time) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intlcal_from_date_time: DateTime object is unconstructed", 0 TSRMLS_CC); goto error; } zend_call_method_with_0_params(zv_datetime, php_date_get_date_ce(), NULL, "gettimestamp", &zv_timestamp); if (Z_TYPE(zv_timestamp) != IS_LONG) { intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "intlcal_from_date_time: bad DateTime; call to " "DateTime::getTimestamp() failed", 0 TSRMLS_CC); zval_ptr_dtor(&zv_timestamp); goto error; } if (!datetime->time->is_localtime) { timeZone = TimeZone::getGMT()->clone(); } else { timeZone = timezone_convert_datetimezone(datetime->time->zone_type, datetime, 1, NULL, "intlcal_from_date_time" TSRMLS_CC); if (timeZone == NULL) { goto error; } } if (!locale_str) { locale_str = const_cast<char*>(intl_locale_get_default(TSRMLS_C)); } cal = Calendar::createInstance(timeZone, Locale::createFromName(locale_str), status); if (cal == NULL) { delete timeZone; intl_error_set(NULL, status, "intlcal_from_date_time: " "error creating ICU Calendar object", 0 TSRMLS_CC); goto error; } cal->setTime(((UDate)Z_LVAL(zv_timestamp)) * 1000., status); if (U_FAILURE(status)) { /* time zone was adopted by cal; should not be deleted here */ delete cal; intl_error_set(NULL, status, "intlcal_from_date_time: " "error creating ICU Calendar::setTime()", 0 TSRMLS_CC); goto error; } calendar_object_create(return_value, cal TSRMLS_CC); error: if (zv_datetime && zv_datetime != zv_arg) { zval_ptr_dtor(zv_datetime); } }
int zephir_call_func_aparams_fast(zval *return_value_ptr, zephir_fcall_cache_entry **cache_entry, zend_uint param_count, zval *params[]) { uint32_t i; zend_class_entry *calling_scope = NULL; zend_execute_data *call, dummy_execute_data; zval retval_local; zval *retval_ptr = return_value_ptr ? return_value_ptr : &retval_local; zend_class_entry *orig_scope; zend_function *func; if (return_value_ptr) { zval_ptr_dtor(return_value_ptr); ZVAL_UNDEF(return_value_ptr); } else { ZVAL_UNDEF(&retval_local); } if (!EG(active)) { return FAILURE; /* executor is already inactive */ } if (EG(exception)) { return FAILURE; /* we would result in an instable executor otherwise */ } orig_scope = EG(scope); /* Initialize execute_data */ if (!EG(current_execute_data)) { /* This only happens when we're called outside any execute()'s * It shouldn't be strictly necessary to NULL execute_data out, * but it may make bugs easier to spot */ memset(&dummy_execute_data, 0, sizeof(zend_execute_data)); EG(current_execute_data) = &dummy_execute_data; } else if (EG(current_execute_data)->func && ZEND_USER_CODE(EG(current_execute_data)->func->common.type) && EG(current_execute_data)->opline->opcode != ZEND_DO_FCALL && EG(current_execute_data)->opline->opcode != ZEND_DO_ICALL && EG(current_execute_data)->opline->opcode != ZEND_DO_UCALL && EG(current_execute_data)->opline->opcode != ZEND_DO_FCALL_BY_NAME) { /* Insert fake frame in case of include or magic calls */ dummy_execute_data = *EG(current_execute_data); dummy_execute_data.prev_execute_data = EG(current_execute_data); dummy_execute_data.call = NULL; dummy_execute_data.opline = NULL; dummy_execute_data.func = NULL; EG(current_execute_data) = &dummy_execute_data; } #ifndef ZEPHIR_RELEASE func = (*cache_entry)->f; ++(*cache_entry)->times; #else func = *cache_entry; #endif calling_scope = NULL; call = zend_vm_stack_push_call_frame(ZEND_CALL_TOP_FUNCTION, func, param_count, NULL, NULL); for (i = 0; i < param_count; i++) { zval *param; zval *arg = params[i]; if (ARG_SHOULD_BE_SENT_BY_REF(func, i + 1)) { if (!Z_ISREF_P(arg)) { /*if (!ARG_MAY_BE_SENT_BY_REF(func, i + 1)) { if (i) { // hack to clean up the stack ZEND_CALL_NUM_ARGS(call) = i; zend_vm_stack_free_args(call); } zend_vm_stack_free_call_frame(call); zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given", i+1, func->common.scope ? ZSTR_VAL(func->common.scope->name) : "", func->common.scope ? "::" : "", ZSTR_VAL(func->common.function_name)); if (EG(current_execute_data) == &dummy_execute_data) { EG(current_execute_data) = dummy_execute_data.prev_execute_data; } return FAILURE; }*/ ZVAL_NEW_REF(arg, arg); } Z_ADDREF_P(arg); } else { if (Z_ISREF_P(arg) && !(func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) { /* don't separate references for __call */ arg = Z_REFVAL_P(arg); } if (Z_OPT_REFCOUNTED_P(arg)) { Z_ADDREF_P(arg); } } param = ZEND_CALL_ARG(call, i+1); ZVAL_COPY_VALUE(param, arg); } EG(scope) = calling_scope; Z_OBJ(call->This) = NULL; if (func->type == ZEND_USER_FUNCTION) { int call_via_handler = (func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) != 0; EG(scope) = func->common.scope; call->symbol_table = NULL; if (UNEXPECTED(func->op_array.fn_flags & ZEND_ACC_CLOSURE)) { ZEND_ASSERT(GC_TYPE((zend_object*)func->op_array.prototype) == IS_OBJECT); GC_REFCOUNT((zend_object*)func->op_array.prototype)++; ZEND_ADD_CALL_FLAG(call, ZEND_CALL_CLOSURE); } if (EXPECTED((func->op_array.fn_flags & ZEND_ACC_GENERATOR) == 0)) { zend_init_execute_data(call, &func->op_array, retval_ptr); zend_execute_ex(call); } else { zend_generator_create_zval(call, &func->op_array, retval_ptr); } if (call_via_handler) { /* We must re-initialize function again */ *cache_entry = NULL; } } else if (func->type == ZEND_INTERNAL_FUNCTION) { int call_via_handler = (func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) != 0; if (func->common.scope) { EG(scope) = func->common.scope; } call->prev_execute_data = EG(current_execute_data); call->return_value = NULL; /* this is not a constructor call */ EG(current_execute_data) = call; if (EXPECTED(zend_execute_internal == NULL)) { /* saves one function call if zend_execute_internal is not used */ func->internal_function.handler(call, retval_ptr); } else { zend_execute_internal(call, retval_ptr); } EG(current_execute_data) = call->prev_execute_data; zend_vm_stack_free_args(call); /* We shouldn't fix bad extensions here, because it can break proper ones (Bug #34045) if (!EX(function_state).function->common.return_reference) { INIT_PZVAL(f->retval); }*/ if (EG(exception)) { zval_ptr_dtor(retval_ptr); ZVAL_UNDEF(retval_ptr); } if (call_via_handler) { /* We must re-initialize function again */ *cache_entry = NULL; } } else { /* ZEND_OVERLOADED_FUNCTION */ ZVAL_NULL(retval_ptr); zend_throw_error(NULL, "Cannot call overloaded function for non-object"); zend_vm_stack_free_args(call); if (func->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { zend_string_release(func->common.function_name); } efree(func); if (EG(exception)) { zval_ptr_dtor(retval_ptr); ZVAL_UNDEF(retval_ptr); } } EG(scope) = orig_scope; zend_vm_stack_free_call_frame(call); if (EG(current_execute_data) == &dummy_execute_data) { EG(current_execute_data) = dummy_execute_data.prev_execute_data; } if (EG(exception)) { zend_throw_exception_internal(NULL); } return SUCCESS; }
/* {{{ proto mixed Closure::call(object to [, mixed parameter] [, mixed ...] ) Call closure, binding to a given object with its class as the scope */ ZEND_METHOD(Closure, call) { zval *zclosure, *newthis, closure_result; zend_closure *closure; zend_fcall_info fci; zend_fcall_info_cache fci_cache; zend_function my_function; zend_object *newobj; fci.param_count = 0; fci.params = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS(), "o*", &newthis, &fci.params, &fci.param_count) == FAILURE) { return; } zclosure = getThis(); closure = (zend_closure *) Z_OBJ_P(zclosure); newobj = Z_OBJ_P(newthis); if (!zend_valid_closure_binding(closure, newthis, Z_OBJCE_P(newthis))) { return; } if (closure->func.common.fn_flags & ZEND_ACC_GENERATOR) { zval new_closure; zend_create_closure(&new_closure, &closure->func, Z_OBJCE_P(newthis), closure->called_scope, newthis); closure = (zend_closure *) Z_OBJ(new_closure); fci_cache.function_handler = &closure->func; } else { memcpy(&my_function, &closure->func, closure->func.type == ZEND_USER_FUNCTION ? sizeof(zend_op_array) : sizeof(zend_internal_function)); my_function.common.fn_flags &= ~ZEND_ACC_CLOSURE; /* use scope of passed object */ my_function.common.scope = Z_OBJCE_P(newthis); fci_cache.function_handler = &my_function; /* Runtime cache relies on bound scope to be immutable, hence we need a separate rt cache in case scope changed */ if (ZEND_USER_CODE(my_function.type) && closure->func.common.scope != Z_OBJCE_P(newthis)) { my_function.op_array.run_time_cache = emalloc(my_function.op_array.cache_size); memset(my_function.op_array.run_time_cache, 0, my_function.op_array.cache_size); } } fci_cache.called_scope = newobj->ce; fci_cache.object = fci.object = newobj; fci.size = sizeof(fci); ZVAL_COPY_VALUE(&fci.function_name, zclosure); fci.retval = &closure_result; fci.no_separation = 1; if (zend_call_function(&fci, &fci_cache) == SUCCESS && Z_TYPE(closure_result) != IS_UNDEF) { if (Z_ISREF(closure_result)) { zend_unwrap_reference(&closure_result); } ZVAL_COPY_VALUE(return_value, &closure_result); } if (fci_cache.function_handler->common.fn_flags & ZEND_ACC_GENERATOR) { /* copied upon generator creation */ GC_DELREF(&closure->std); } else if (ZEND_USER_CODE(my_function.type) && closure->func.common.scope != Z_OBJCE_P(newthis)) { efree(my_function.op_array.run_time_cache); } }
/* {{{ zend_user_it_get_new_iterator */ ZEND_API zend_object_iterator *zend_user_it_get_new_iterator(zend_class_entry *ce, zval *object, int by_ref) { zval iterator; zend_object_iterator *new_iterator; zend_class_entry *ce_it; zend_user_it_new_iterator(ce, object, &iterator); ce_it = (Z_TYPE(iterator) == IS_OBJECT) ? Z_OBJCE(iterator) : NULL; if (!ce_it || !ce_it->get_iterator || (ce_it->get_iterator == zend_user_it_get_new_iterator && Z_OBJ(iterator) == Z_OBJ_P(object))) { if (!EG(exception)) { zend_throw_exception_ex(NULL, 0, "Objects returned by %s::getIterator() must be traversable or implement interface Iterator", ce ? ce->name->val : Z_OBJCE_P(object)->name->val); } zval_ptr_dtor(&iterator); return NULL; } new_iterator = ce_it->get_iterator(ce_it, &iterator, by_ref); zval_ptr_dtor(&iterator); return new_iterator; }
/* {{{ proto mixed Closure::call(object to [, mixed parameter] [, mixed ...] ) Call closure, binding to a given object with its class as the scope */ ZEND_METHOD(Closure, call) { zval *zclosure, *newthis, closure_result; zend_closure *closure; zend_fcall_info fci; zend_fcall_info_cache fci_cache; zval *my_params; int my_param_count = 0; zend_function my_function; zend_object *newobj; if (zend_parse_parameters(ZEND_NUM_ARGS(), "o*", &newthis, &my_params, &my_param_count) == FAILURE) { return; } zclosure = getThis(); closure = (zend_closure *) Z_OBJ_P(zclosure); newobj = Z_OBJ_P(newthis); if (!zend_valid_closure_binding(closure, newthis, Z_OBJCE_P(newthis))) { return; } /* This should never happen as closures will always be callable */ if (zend_fcall_info_init(zclosure, 0, &fci, &fci_cache, NULL, NULL) != SUCCESS) { ZEND_ASSERT(0); } fci.retval = &closure_result; fci.params = my_params; fci.param_count = my_param_count; fci.object = fci_cache.object = newobj; fci_cache.initialized = 1; fci_cache.called_scope = Z_OBJCE_P(newthis); if (fci_cache.function_handler->common.fn_flags & ZEND_ACC_GENERATOR) { zval new_closure; zend_create_closure(&new_closure, fci_cache.function_handler, Z_OBJCE_P(newthis), closure->called_scope, newthis); closure = (zend_closure *) Z_OBJ(new_closure); fci_cache.function_handler = &closure->func; } else { memcpy(&my_function, fci_cache.function_handler, fci_cache.function_handler->type == ZEND_USER_FUNCTION ? sizeof(zend_op_array) : sizeof(zend_internal_function)); /* use scope of passed object */ my_function.common.scope = Z_OBJCE_P(newthis); fci_cache.function_handler = &my_function; /* Runtime cache relies on bound scope to be immutable, hence we need a separate rt cache in case scope changed */ if (ZEND_USER_CODE(my_function.type) && closure->func.common.scope != Z_OBJCE_P(newthis)) { my_function.op_array.run_time_cache = emalloc(my_function.op_array.cache_size); memset(my_function.op_array.run_time_cache, 0, my_function.op_array.cache_size); } } if (zend_call_function(&fci, &fci_cache) == SUCCESS && Z_TYPE(closure_result) != IS_UNDEF) { ZVAL_COPY_VALUE(return_value, &closure_result); } if (fci_cache.function_handler->common.fn_flags & ZEND_ACC_GENERATOR) { /* copied upon generator creation */ --GC_REFCOUNT(&closure->std); } else if (ZEND_USER_CODE(my_function.type) && closure->func.common.scope != Z_OBJCE_P(newthis)) { efree(my_function.op_array.run_time_cache); } }