zend_function *mptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(mptr);
RETURN_BOOL(mptr->common.fn_flags & mask);
if (ctor_argc == 1) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|b", &argument_ptr, &return_output) == FAILURE) {
- return;
+ RETURN_THROWS();
}
ZVAL_COPY_VALUE(¶ms[0], argument_ptr);
ZVAL_NULL(¶ms[1]);
} else {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz|b", &argument_ptr, &argument2_ptr, &return_output) == FAILURE) {
- return;
+ RETURN_THROWS();
}
ZVAL_COPY_VALUE(¶ms[0], argument_ptr);
ZVAL_COPY_VALUE(¶ms[1], argument2_ptr);
zend_long modifiers;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &modifiers) == FAILURE) {
- return;
+ RETURN_THROWS();
}
array_init(return_value);
ALLOCA_FLAG(use_heap)
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &fname) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (UNEXPECTED(ZSTR_VAL(fname)[0] == '\\')) {
smart_str str = {0};
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
_function_string(&str, fptr, intern->ce, "");
ZEND_METHOD(reflection_function, getName)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
_default_get_name(ZEND_THIS, return_value);
}
zend_function *fptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
RETURN_BOOL(fptr->common.fn_flags & ZEND_ACC_CLOSURE);
zval* closure_this;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT();
if (!Z_ISUNDEF(intern->obj)) {
const zend_function *closure_func;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT();
if (!Z_ISUNDEF(intern->obj)) {
zend_function *fptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
zend_function *fptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
RETURN_BOOL(fptr->type == ZEND_INTERNAL_FUNCTION);
zend_function *fptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
RETURN_BOOL(fptr->type == ZEND_USER_FUNCTION);
GET_REFLECTION_OBJECT_PTR(fptr);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(fptr->type == ZEND_INTERNAL_FUNCTION && fptr->internal_function.handler == zif_display_disabled_function);
zend_function *fptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
if (fptr->type == ZEND_USER_FUNCTION) {
zend_function *fptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
if (fptr->type == ZEND_USER_FUNCTION) {
zend_function *fptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
if (fptr->type == ZEND_USER_FUNCTION) {
zend_function *fptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.doc_comment) {
zval *val;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
GET_REFLECTION_OBJECT_PTR(fptr);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "*", ¶ms, &num_args) == FAILURE) {
- return;
+ RETURN_THROWS();
}
fci.size = sizeof(fci);
GET_REFLECTION_OBJECT_PTR(fptr);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "a", ¶m_array) == FAILURE) {
- return;
+ RETURN_THROWS();
}
argc = zend_hash_num_elements(Z_ARRVAL_P(param_array));
GET_REFLECTION_OBJECT_PTR(fptr);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL((fptr->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0);
GET_REFLECTION_OBJECT_PTR(fptr);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
num_args = fptr->common.num_args;
GET_REFLECTION_OBJECT_PTR(fptr);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(fptr->common.required_num_args);
GET_REFLECTION_OBJECT_PTR(fptr);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
arg_info= fptr->common.arg_info;
GET_REFLECTION_OBJECT_PTR(fptr);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (fptr->type != ZEND_INTERNAL_FUNCTION) {
GET_REFLECTION_OBJECT_PTR(fptr);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (fptr->type != ZEND_INTERNAL_FUNCTION) {
intern = Z_REFLECTION_P(object);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &generator, zend_ce_generator) == FAILURE) {
- return;
+ RETURN_THROWS();
}
ex = ((zend_generator *) Z_OBJ_P(generator))->execute_data;
zend_execute_data *root_prev = NULL, *cur_prev;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &options) == FAILURE) {
- return;
+ RETURN_THROWS();
}
REFLECTION_CHECK_VALID_GENERATOR(ex)
zend_execute_data *ex = generator->execute_data;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
REFLECTION_CHECK_VALID_GENERATOR(ex)
zend_execute_data *ex = generator->execute_data;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
REFLECTION_CHECK_VALID_GENERATOR(ex)
zend_execute_data *ex = generator->execute_data;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
REFLECTION_CHECK_VALID_GENERATOR(ex)
zend_execute_data *ex = generator->execute_data;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
REFLECTION_CHECK_VALID_GENERATOR(ex)
zend_generator *current;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
REFLECTION_CHECK_VALID_GENERATOR(ex)
zend_bool is_closure = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &reference, ¶meter) == FAILURE) {
- return;
+ RETURN_THROWS();
}
object = ZEND_THIS;
smart_str str = {0};
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
_parameter_string(&str, param->fptr, param->arg_info, param->offset, param->required, "");
ZEND_METHOD(reflection_parameter, getName)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
_default_get_name(ZEND_THIS, return_value);
}
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
uint32_t type_mask;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
uint32_t type_mask;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
zend_op *precv;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
zend_op *precv;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
param = _reflection_param_get_default_param(INTERNAL_FUNCTION_PARAM_PASSTHRU);
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
param = _reflection_param_get_default_param(INTERNAL_FUNCTION_PARAM_PASSTHRU);
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
param = _reflection_param_get_default_param(INTERNAL_FUNCTION_PARAM_PASSTHRU);
parameter_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
type_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
type_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
type_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
type_reference *param;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
uint32_t type_mask;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(param);
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "zs", &classname, &name_str, &name_len) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((tmp = strstr(name_str, "::")) == NULL) {
smart_str str = {0};
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(mptr);
_function_string(&str, mptr, intern->ce, "");
zend_create_fake_closure(return_value, mptr, mptr->common.scope, mptr->common.scope, NULL);
} else {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &obj) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (!instanceof_function(Z_OBJCE_P(obj), mptr->common.scope)) {
if (variadic) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o!*", &object, ¶ms, &argc) == FAILURE) {
- return;
+ RETURN_THROWS();
}
} else {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o!a", &object, ¶m_array) == FAILURE) {
- return;
+ RETURN_THROWS();
}
argc = zend_hash_num_elements(Z_ARRVAL_P(param_array));
const char *backslash;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((name = _default_load_name(ZEND_THIS)) == NULL) {
RETURN_FALSE;
const char *backslash;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((name = _default_load_name(ZEND_THIS)) == NULL) {
RETURN_FALSE;
const char *backslash;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((name = _default_load_name(ZEND_THIS)) == NULL) {
RETURN_FALSE;
zend_function *fptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
zend_function *fptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(fptr);
zend_function *mptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(mptr);
/* we need to check if the ctor is the ctor of the class level we we
zend_function *mptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(mptr);
RETURN_BOOL(mptr->common.fn_flags & ZEND_ACC_DTOR);
| ZEND_ACC_STATIC | ZEND_ACC_ABSTRACT | ZEND_ACC_FINAL;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(mptr);
GET_REFLECTION_OBJECT_PTR(mptr);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_reflection_class_factory(mptr->common.scope, return_value);
GET_REFLECTION_OBJECT_PTR(mptr);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (!mptr->common.prototype) {
zend_bool visible;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &visible) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_REFLECTION_P(ZEND_THIS);
zend_class_constant *constant = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zS", &classname, &constname) == FAILURE) {
- return;
+ RETURN_THROWS();
}
object = ZEND_THIS;
zval name;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
_default_get_name(ZEND_THIS, &name);
ZEND_METHOD(reflection_class_constant, getName)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
_default_get_name(ZEND_THIS, return_value);
}
zend_class_constant *ref;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
RETURN_BOOL(Z_ACCESS_FLAGS(ref->value) & mask);
zend_class_constant *ref;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
zend_class_constant *ref;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
zend_class_constant *ref;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
zend_class_constant *ref;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
if (ref->doc_comment) {
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zval *prop, *def_value = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|z", &name, &def_value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zval *variable_ptr, *value;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz", &name, &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
array_init(return_value);
smart_str str = {0};
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
_class_string(&str, ce, &intern->obj, "");
ZEND_METHOD(reflection_class, getName)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
_default_get_name(ZEND_THIS, return_value);
}
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
RETURN_BOOL(ce->type == ZEND_INTERNAL_CLASS);
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
RETURN_BOOL(ce->type == ZEND_USER_CLASS);
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
RETURN_BOOL(ce->ce_flags & ZEND_ACC_ANON_CLASS);
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
if (ce->type == ZEND_USER_CLASS) {
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
if (ce->type == ZEND_USER_CLASS) {
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
if (ce->type == ZEND_USER_CLASS) {
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
if (ce->type == ZEND_USER_CLASS && ce->info.user.doc_comment) {
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zend_string *name, *lc_name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zend_string *name, *lc_name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zend_bool filter_is_null = 1;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l!", &filter, &filter_is_null) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (filter_is_null) {
zend_string *name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
size_t classname_len, str_name_len;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zend_bool filter_is_null = 1;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l!", &filter, &filter_is_null) == FAILURE) {
- return;
+ RETURN_THROWS();
}
-
+
if (filter_is_null) {
filter = ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC;
}
zend_string *name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zval val;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
array_init(return_value);
zend_class_constant *constant;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
array_init(return_value);
zend_string *name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
GET_REFLECTION_OBJECT_PTR(ce);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((constant = zend_hash_find_ptr(&ce->constants_table, name)) == NULL) {
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
RETVAL_BOOL(ce->ce_flags & mask);
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
if (ce->ce_flags & (ZEND_ACC_INTERFACE | ZEND_ACC_TRAIT | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS | ZEND_ACC_IMPLICIT_ABSTRACT_CLASS)) {
zval obj;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
if (ce->ce_flags & (ZEND_ACC_INTERFACE | ZEND_ACC_TRAIT | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS | ZEND_ACC_IMPLICIT_ABSTRACT_CLASS)) {
| ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zval *object;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &object) == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
RETURN_BOOL(instanceof_function(Z_OBJCE_P(object), ce));
if (zend_parse_parameters(ZEND_NUM_ARGS(), "*", ¶ms, &num_args) == FAILURE) {
zval_ptr_dtor(return_value);
- RETURN_FALSE;
+ RETURN_THROWS();
}
for (i = 0; i < num_args; i++) {
GET_REFLECTION_OBJECT_PTR(ce);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (ce->type == ZEND_INTERNAL_CLASS
GET_REFLECTION_OBJECT_PTR(ce);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|h", &args) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (ZEND_NUM_ARGS() > 0) {
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
uint32_t i;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
uint32_t i;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
uint32_t i;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
GET_REFLECTION_OBJECT_PTR(ce);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &class_name) == FAILURE) {
- return;
+ RETURN_THROWS();
}
switch (Z_TYPE_P(class_name)) {
GET_REFLECTION_OBJECT_PTR(ce);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &interface) == FAILURE) {
- return;
+ RETURN_THROWS();
}
switch (Z_TYPE_P(interface)) {
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ce);
const char *backslash;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((name = _default_load_name(ZEND_THIS)) == NULL) {
RETURN_FALSE;
const char *backslash;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((name = _default_load_name(ZEND_THIS)) == NULL) {
RETURN_FALSE;
const char *backslash;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((name = _default_load_name(ZEND_THIS)) == NULL) {
RETURN_FALSE;
property_reference *reference;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zS", &classname, &name) == FAILURE) {
- return;
+ RETURN_THROWS();
}
object = ZEND_THIS;
smart_str str = {0};
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
_property_string(&str, ref->prop, ZSTR_VAL(ref->unmangled_name), "");
ZEND_METHOD(reflection_property, getName)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
_default_get_name(ZEND_THIS, return_value);
}
property_reference *ref;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
RETURN_BOOL(prop_get_flags(ref) & mask);
property_reference *ref;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
RETURN_BOOL(ref->prop != NULL);
uint32_t keep_flags = ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
zval rv;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &object) == FAILURE) {
- return;
+ RETURN_THROWS();
}
/* TODO: Should this always use intern->ce? */
if (prop_get_flags(ref) & ZEND_ACC_STATIC) {
if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "z", &value) == FAILURE) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &tmp, &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
}
zend_update_static_property_ex(intern->ce, ref->unmangled_name, value);
} else {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "oz", &object, &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_update_property_ex(intern->ce, object, ref->unmangled_name, value);
int retval;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &object) == FAILURE) {
- return;
+ RETURN_THROWS();
}
/* TODO: Should this always use intern->ce? */
zend_property_info *tmp_info;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
property_reference *ref;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
if (ref->prop && ref->prop->doc_comment) {
zend_bool visible;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &visible) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_REFLECTION_P(ZEND_THIS);
property_reference *ref;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
property_reference *ref;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(ref);
ALLOCA_FLAG(use_heap)
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) {
- return;
+ RETURN_THROWS();
}
object = ZEND_THIS;
smart_str str = {0};
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(module);
_extension_string(&str, module, "");
ZEND_METHOD(reflection_extension, getName)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
_default_get_name(ZEND_THIS, return_value);
}
zend_module_entry *module;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(module);
zend_function *fptr;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(module);
zend_constant *constant;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(module);
zend_ini_entry *ini_entry;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(module);
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(module);
zend_class_entry *ce;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(module);
const zend_module_dep *dep;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(module);
zend_module_entry *module;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(module);
zend_module_entry *module;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(module);
zend_module_entry *module;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(module);
size_t name_len;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name_str, &name_len) == FAILURE) {
- return;
+ RETURN_THROWS();
}
object = ZEND_THIS;
smart_str str = {0};
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(extension);
_zend_extension_string(&str, extension, "");
zend_extension *extension;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(extension);
zend_extension *extension;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(extension);
zend_extension *extension;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(extension);
zend_extension *extension;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(extension);
zend_extension *extension;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
GET_REFLECTION_OBJECT_PTR(extension);
reflection_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "hz", &ht, &key) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (Z_TYPE_P(key) == IS_LONG) {
PHP_SHA1_CTX context;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_REFLECTION_P(getThis());
if (zend_parse_parameters(ZEND_NUM_ARGS(),
"z", &buf_zv) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
ZVAL_DEREF(buf_zv);
if (Z_TYPE_P(buf_zv) != IS_STRING) {
if (zend_parse_parameters(ZEND_NUM_ARGS(),
"z", &val_zv) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
ZVAL_DEREF(val_zv);
if (Z_TYPE_P(val_zv) != IS_STRING) {
if (zend_parse_parameters(ZEND_NUM_ARGS(),
"zs", &val_zv, &addv, &addv_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
ZVAL_DEREF(val_zv);
if (Z_TYPE_P(val_zv) != IS_STRING) {
&buf1, &len1,
&buf2, &len2) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (len1 != len2) {
zend_throw_exception(sodium_exception_ce, "arguments have different sizes", 0);
&msg, &msg_len,
&key, &key_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (key_len != crypto_shorthash_KEYBYTES) {
zend_throw_exception(sodium_exception_ce,
&nonce, &nonce_len,
&key, &key_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (nonce_len != crypto_secretbox_NONCEBYTES) {
zend_throw_exception(sodium_exception_ce,
&nonce, &nonce_len,
&key, &key_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (nonce_len != crypto_secretbox_NONCEBYTES) {
zend_throw_exception(sodium_exception_ce,
&key, &key_len,
&hash_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (hash_len < crypto_generichash_BYTES_MIN ||
hash_len > crypto_generichash_BYTES_MAX) {
&key, &key_len,
&hash_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (hash_len < crypto_generichash_BYTES_MIN ||
hash_len > crypto_generichash_BYTES_MAX) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs",
&state_zv, &msg, &msg_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
ZVAL_DEREF(state_zv);
if (Z_TYPE_P(state_zv) != IS_STRING) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|l",
&state_zv, &hash_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
ZVAL_DEREF(state_zv);
if (Z_TYPE_P(state_zv) != IS_STRING) {
size_t keypair_len;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
keypair_len = crypto_box_SECRETKEYBYTES + crypto_box_PUBLICKEYBYTES;
keypair = zend_string_alloc(keypair_len, 0);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&seed, &seed_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (seed_len != crypto_box_SEEDBYTES) {
zend_throw_exception(sodium_exception_ce,
&secretkey, &secretkey_len,
&publickey, &publickey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (secretkey_len != crypto_box_SECRETKEYBYTES) {
zend_throw_exception(sodium_exception_ce,
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&keypair, &keypair_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (keypair_len !=
crypto_box_SECRETKEYBYTES + crypto_box_PUBLICKEYBYTES) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&keypair, &keypair_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (keypair_len !=
crypto_box_SECRETKEYBYTES + crypto_box_PUBLICKEYBYTES) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (secretkey_len != crypto_box_SECRETKEYBYTES) {
zend_throw_exception(sodium_exception_ce,
&nonce, &nonce_len,
&keypair, &keypair_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (nonce_len != crypto_box_NONCEBYTES) {
zend_throw_exception(sodium_exception_ce,
&nonce, &nonce_len,
&keypair, &keypair_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (nonce_len != crypto_box_NONCEBYTES) {
zend_throw_exception(sodium_exception_ce,
&msg, &msg_len,
&publickey, &publickey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (publickey_len != crypto_box_PUBLICKEYBYTES) {
zend_throw_exception(sodium_exception_ce,
&ciphertext, &ciphertext_len,
&keypair, &keypair_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (keypair_len != crypto_box_SECRETKEYBYTES + crypto_box_PUBLICKEYBYTES) {
zend_throw_exception(sodium_exception_ce,
size_t keypair_len;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
keypair_len = crypto_sign_SECRETKEYBYTES + crypto_sign_PUBLICKEYBYTES;
keypair = zend_string_alloc(keypair_len, 0);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&seed, &seed_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (seed_len != crypto_sign_SEEDBYTES) {
zend_throw_exception(sodium_exception_ce,
&secretkey, &secretkey_len,
&publickey, &publickey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (secretkey_len != crypto_sign_SECRETKEYBYTES) {
zend_throw_exception(sodium_exception_ce,
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (secretkey_len != crypto_sign_SECRETKEYBYTES) {
zend_throw_exception(sodium_exception_ce,
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&keypair, &keypair_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (keypair_len !=
crypto_sign_SECRETKEYBYTES + crypto_sign_PUBLICKEYBYTES) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&keypair, &keypair_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (keypair_len !=
crypto_sign_SECRETKEYBYTES + crypto_sign_PUBLICKEYBYTES) {
&msg, &msg_len,
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (secretkey_len != crypto_sign_SECRETKEYBYTES) {
zend_throw_exception(sodium_exception_ce,
&msg_signed, &msg_signed_len,
&publickey, &publickey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (publickey_len != crypto_sign_PUBLICKEYBYTES) {
zend_throw_exception(sodium_exception_ce,
&msg, &msg_len,
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (secretkey_len != crypto_sign_SECRETKEYBYTES) {
zend_throw_exception(sodium_exception_ce,
&msg, &msg_len,
&publickey, &publickey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (signature_len != crypto_sign_BYTES) {
zend_throw_exception(sodium_exception_ce,
&nonce, &nonce_len,
&key, &key_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (ciphertext_len <= 0 || ciphertext_len >= SIZE_MAX) {
zend_throw_exception(sodium_exception_ce, "ciphertext length must be greater than 0", 0);
&nonce, &nonce_len,
&key, &key_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (nonce_len != crypto_stream_NONCEBYTES) {
zend_throw_exception(sodium_exception_ce, "nonce should be SODIUM_CRYPTO_STREAM_NONCEBYTES bytes", 0);
&salt, &salt_len,
&opslimit, &memlimit, &alg) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (hash_len <= 0 || hash_len >= 0xffffffff) {
zend_throw_exception(sodium_exception_ce, "hash length must be greater than 0", 0);
&passwd, &passwd_len,
&opslimit, &memlimit) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (opslimit <= 0) {
zend_throw_exception(sodium_exception_ce, "ops limit must be greater than 0", 0);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "sll",
&hash_str, &hash_str_len, &opslimit, &memlimit) == FAILURE) {
zend_throw_exception(sodium_exception_ce, "a PHP string is required", 0);
- return;
+ RETURN_THROWS();
}
if (crypto_pwhash_str_needs_rehash(hash_str, opslimit, memlimit) == 0) {
RETURN_FALSE;
&hash_str, &hash_str_len,
&passwd, &passwd_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (passwd_len >= 0xffffffff) {
zend_throw_exception(sodium_exception_ce,
&salt, &salt_len,
&opslimit, &memlimit) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (hash_len <= 0 || hash_len >= SIZE_MAX || hash_len > 0x1fffffffe0ULL) {
zend_throw_exception(sodium_exception_ce, "hash length must be greater than 0", 0);
&passwd, &passwd_len,
&opslimit, &memlimit) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (opslimit <= 0) {
zend_throw_exception(sodium_exception_ce, "ops limit must be greater than 0", 0);
&hash_str, &hash_str_len,
&passwd, &passwd_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (passwd_len <= 0) {
zend_error(E_WARNING, "empty password");
PHP_FUNCTION(sodium_crypto_aead_aes256gcm_is_available)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
#ifdef HAVE_AESGCM
RETURN_BOOL(crypto_aead_aes256gcm_is_available());
&npub, &npub_len,
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (npub_len != crypto_aead_aes256gcm_NPUBBYTES) {
zend_throw_exception(sodium_exception_ce,
&npub, &npub_len,
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (npub_len != crypto_aead_aes256gcm_NPUBBYTES) {
zend_throw_exception(sodium_exception_ce,
&npub, &npub_len,
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (npub_len != crypto_aead_chacha20poly1305_NPUBBYTES) {
zend_throw_exception(sodium_exception_ce,
&npub, &npub_len,
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (npub_len != crypto_aead_chacha20poly1305_NPUBBYTES) {
zend_throw_exception(sodium_exception_ce,
&npub, &npub_len,
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (npub_len != crypto_aead_chacha20poly1305_IETF_NPUBBYTES) {
zend_throw_exception(sodium_exception_ce,
&npub, &npub_len,
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (npub_len != crypto_aead_chacha20poly1305_IETF_NPUBBYTES) {
zend_throw_exception(sodium_exception_ce,
&npub, &npub_len,
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (npub_len != crypto_aead_xchacha20poly1305_IETF_NPUBBYTES) {
zend_throw_exception(sodium_exception_ce,
&npub, &npub_len,
&secretkey, &secretkey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (npub_len != crypto_aead_xchacha20poly1305_IETF_NPUBBYTES) {
zend_throw_exception(sodium_exception_ce,
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&bin, &bin_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (bin_len >= SIZE_MAX / 2U) {
zend_throw_exception(sodium_exception_ce, "arithmetic overflow", 0);
&hex, &hex_len,
&ignore, &ignore_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
bin_len = hex_len / 2;
bin = zend_string_alloc(bin_len, 0);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl",
&bin, &bin_len, &variant) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if ((((unsigned int) variant) & ~ 0x6U) != 0x1U) {
zend_throw_exception(sodium_exception_ce,
&b64, &b64_len, &variant,
&ignore, &ignore_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if ((((unsigned int) variant) & ~ 0x6U) != 0x1U) {
zend_throw_exception(sodium_exception_ce,
if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
&n, &n_len, &p, &p_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (n_len != crypto_scalarmult_SCALARBYTES ||
p_len != crypto_scalarmult_BYTES) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&seed, &seed_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (seed_len != crypto_kx_SEEDBYTES) {
zend_throw_exception(sodium_exception_ce, "seed must be SODIUM_CRYPTO_KX_SEEDBYTES bytes", 0);
zend_string *keypair;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
keypair = zend_string_alloc(crypto_kx_SECRETKEYBYTES + crypto_kx_PUBLICKEYBYTES, 0);
sk = (unsigned char *) ZSTR_VAL(keypair);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&keypair, &keypair_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (keypair_len !=
crypto_kx_SECRETKEYBYTES + crypto_kx_PUBLICKEYBYTES) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&keypair, &keypair_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (keypair_len !=
crypto_kx_SECRETKEYBYTES + crypto_kx_PUBLICKEYBYTES) {
&keypair, &keypair_len,
&server_pk, &server_pk_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (keypair_len != crypto_kx_SECRETKEYBYTES + crypto_kx_PUBLICKEYBYTES) {
zend_throw_exception(sodium_exception_ce, "keypair must be SODIUM_CRYPTO_KX_KEYPAIRBYTES bytes", 0);
&keypair, &keypair_len,
&client_pk, &client_pk_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (keypair_len != crypto_kx_SECRETKEYBYTES + crypto_kx_PUBLICKEYBYTES) {
zend_throw_exception(sodium_exception_ce, "keypair must be SODIUM_CRYPTO_KX_KEYPAIRBYTES bytes", 0);
&msg, &msg_len,
&key, &key_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (key_len != crypto_auth_KEYBYTES) {
zend_throw_exception(sodium_exception_ce, "key must be SODIUM_CRYPTO_AUTH_KEYBYTES bytes", 0);
&msg, &msg_len,
&key, &key_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (key_len != crypto_auth_KEYBYTES) {
zend_throw_exception(sodium_exception_ce, "key must be SODIUM_CRYPTO_AUTH_KEYBYTES bytes", 0);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&eddsakey, &eddsakey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (eddsakey_len != crypto_sign_SECRETKEYBYTES) {
zend_throw_exception(sodium_exception_ce,
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&eddsakey, &eddsakey_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (eddsakey_len != crypto_sign_PUBLICKEYBYTES) {
zend_throw_exception(sodium_exception_ce,
&buf1, &len1,
&buf2, &len2) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (len1 != len2) {
zend_throw_exception(sodium_exception_ce, "arguments have different sizes", 0);
unsigned char key[crypto_aead_aes256gcm_KEYBYTES];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
randombytes_buf(key, sizeof key);
RETURN_STRINGL((const char *) key, sizeof key);
unsigned char key[crypto_aead_chacha20poly1305_KEYBYTES];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
randombytes_buf(key, sizeof key);
RETURN_STRINGL((const char *) key, sizeof key);
unsigned char key[crypto_aead_chacha20poly1305_IETF_KEYBYTES];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
randombytes_buf(key, sizeof key);
RETURN_STRINGL((const char *) key, sizeof key);
unsigned char key[crypto_aead_xchacha20poly1305_IETF_KEYBYTES];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
randombytes_buf(key, sizeof key);
RETURN_STRINGL((const char *) key, sizeof key);
unsigned char key[crypto_auth_KEYBYTES];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
randombytes_buf(key, sizeof key);
RETURN_STRINGL((const char *) key, sizeof key);
unsigned char key[crypto_generichash_KEYBYTES];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
randombytes_buf(key, sizeof key);
RETURN_STRINGL((const char *) key, sizeof key);
unsigned char key[crypto_kdf_KEYBYTES];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
randombytes_buf(key, sizeof key);
RETURN_STRINGL((const char *) key, sizeof key);
unsigned char key[crypto_secretbox_KEYBYTES];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
randombytes_buf(key, sizeof key);
RETURN_STRINGL((const char *) key, sizeof key);
unsigned char key[crypto_shorthash_KEYBYTES];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
randombytes_buf(key, sizeof key);
RETURN_STRINGL((const char *) key, sizeof key);
unsigned char key[crypto_stream_KEYBYTES];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
randombytes_buf(key, sizeof key);
RETURN_STRINGL((const char *) key, sizeof key);
&ctx, &ctx_len,
&key, &key_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (subkey_len < crypto_kdf_BYTES_MIN) {
zend_throw_exception(sodium_exception_ce, "subkey cannot be smaller than SODIUM_CRYPTO_KDF_BYTES_MIN", 0);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl",
&unpadded, &unpadded_len, &blocksize) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (blocksize <= 0) {
zend_throw_exception(sodium_exception_ce, "block size cannot be less than 1", 0);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl",
&padded, &padded_len, &blocksize) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (blocksize <= 0) {
zend_throw_exception(sodium_exception_ce, "block size cannot be less than 1", 0);
unsigned char key[crypto_secretstream_xchacha20poly1305_KEYBYTES];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
randombytes_buf(key, sizeof key);
RETURN_STRINGL((const char *) key, sizeof key);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
&key, &key_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (key_len != crypto_secretstream_xchacha20poly1305_KEYBYTES) {
zend_throw_exception(sodium_exception_ce,
&state_zv,
&msg, &msg_len, &ad, &ad_len, &tag) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
ZVAL_DEREF(state_zv);
if (Z_TYPE_P(state_zv) != IS_STRING) {
&header, &header_len,
&key, &key_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
if (header_len != crypto_secretstream_xchacha20poly1305_HEADERBYTES) {
zend_throw_exception(sodium_exception_ce,
&state_zv,
&c, &c_len, &ad, &ad_len) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
ZVAL_DEREF(state_zv);
if (Z_TYPE_P(state_zv) != IS_STRING) {
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &state_zv) == FAILURE) {
sodium_remove_param_values_from_backtrace(EG(exception));
- return;
+ RETURN_THROWS();
}
ZVAL_DEREF(state_zv);
if (Z_TYPE_P(state_zv) != IS_STRING) {
zend_bool autoload = 1;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|b", &obj, &autoload) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (Z_TYPE_P(obj) != IS_OBJECT && Z_TYPE_P(obj) != IS_STRING) {
zend_class_entry *ce;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|b", &obj, &autoload) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (Z_TYPE_P(obj) != IS_OBJECT && Z_TYPE_P(obj) != IS_STRING) {
zend_type_error("object or string expected");
zend_class_entry *ce;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|b", &obj, &autoload) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (Z_TYPE_P(obj) != IS_OBJECT && Z_TYPE_P(obj) != IS_STRING) {
zend_type_error("object or string expected");
PHP_FUNCTION(spl_classes)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
array_init(return_value);
zend_string *class_name, *lc_name, *file_exts = SPL_G(autoload_extensions);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|S", &class_name, &file_exts) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (file_exts == NULL) { /* autoload_extensions is not initialized, set to defaults */
zend_string *file_exts = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|S", &file_exts) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (file_exts) {
if (SPL_G(autoload_extensions)) {
autoload_func_info *alfi;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &class_name) == FAILURE || Z_TYPE_P(class_name) != IS_STRING) {
- return;
+ RETURN_THROWS();
}
if (SPL_G(autoload_functions)) {
zend_fcall_info_cache fcc;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|zbb", &zcallable, &do_throw, &prepend) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (ZEND_NUM_ARGS()) {
zend_fcall_info_cache fcc;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcallable) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (!zend_is_callable_ex(zcallable, NULL, IS_CALLABLE_CHECK_SYNTAX_ONLY, &func_name, &fcc, &error)) {
autoload_func_info *alfi;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (!EG(autoload_func)) {
zval *obj;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &obj) == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_NEW_STR(php_spl_object_hash(obj));
{
zval *index;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &index) == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(spl_array_has_dimension_ex(0, Z_OBJ_P(ZEND_THIS), index, 2));
} /* }}} */
{
zval *value, *index;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &index) == FAILURE) {
- return;
+ RETURN_THROWS();
}
value = spl_array_read_dimension_ex(0, Z_OBJ_P(ZEND_THIS), index, BP_VAR_R, return_value);
if (value != return_value) {
{
zval *index, *value;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &index, &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_array_write_dimension_ex(0, Z_OBJ_P(ZEND_THIS), index, value);
} /* }}} */
zval *value;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_array_iterator_append(ZEND_THIS, value);
} /* }}} */
{
zval *index;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &index) == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_array_unset_dimension_ex(0, Z_OBJ_P(ZEND_THIS), index);
} /* }}} */
}
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|lC", &array, &ar_flags, &ce_get_iterator) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLARRAY_P(object);
}
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|l", &array, &ar_flags) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLARRAY_P(object);
spl_array_object *intern = Z_SPLARRAY_P(object);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_string_addref(intern->ce_get_iterator->name);
spl_array_object *intern = Z_SPLARRAY_P(object);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(intern->ar_flags & ~SPL_ARRAY_INT_MASK);
zend_long ar_flags = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &ar_flags) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern->ar_flags = (intern->ar_flags & SPL_ARRAY_INT_MASK) | (ar_flags & ~SPL_ARRAY_INT_MASK);
spl_array_object *intern = Z_SPLARRAY_P(object);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &array) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (intern->nApplyCount > 0) {
spl_array_object *intern = Z_SPLARRAY_P(object);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
ZVAL_OBJ(return_value, spl_array_object_new_ex(intern->ce_get_iterator, Z_OBJ_P(object), 0));
spl_array_object *intern = Z_SPLARRAY_P(object);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_array_rewind(intern);
int result;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &position) == FAILURE) {
- return;
+ RETURN_THROWS();
}
opos = position;
spl_array_object *intern = Z_SPLARRAY_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(spl_array_object_count_elements_helper(intern));
HashTable *aht = spl_array_get_hash_table(intern);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((entry = zend_hash_get_current_data_ex(aht, spl_array_get_pos_ptr(aht, intern))) == NULL) {
SPL_METHOD(Array, key)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_array_iterator_key(ZEND_THIS, return_value);
HashTable *aht = spl_array_get_hash_table(intern);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_array_next_ex(intern, aht);
HashTable *aht = spl_array_get_hash_table(intern);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(zend_hash_has_more_elements_ex(aht, spl_array_get_pos_ptr(aht, intern)) == SUCCESS);
HashTable *aht = spl_array_get_hash_table(intern);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((entry = zend_hash_get_current_data_ex(aht, spl_array_get_pos_ptr(aht, intern))) == NULL) {
HashTable *aht = spl_array_get_hash_table(intern);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((entry = zend_hash_get_current_data_ex(aht, spl_array_get_pos_ptr(aht, intern))) == NULL) {
zend_long flags;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &buf, &buf_len) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (buf_len == 0) {
zval tmp;
if (zend_parse_parameters_none_throw() == FAILURE) {
- return;
+ RETURN_THROWS();
}
array_init(return_value);
zend_long flags;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "h", &data) == FAILURE) {
- return;
+ RETURN_THROWS();
}
flags_zv = zend_hash_index_find(data, 0);
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern->u.dir.index = 0;
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (intern->u.dir.dirp) {
SPL_METHOD(DirectoryIterator, current)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
ZVAL_OBJ(return_value, Z_OBJ_P(ZEND_THIS));
Z_ADDREF_P(return_value);
int skip_dots = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_SKIPDOTS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern->u.dir.index++;
zend_long pos;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &pos) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (intern->u.dir.index > pos) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(intern->u.dir.entry.d_name[0] != '\0');
size_t path_len;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
path = spl_filesystem_object_get_path(intern, &path_len);
size_t path_len;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_filesystem_object_get_path(intern, &path_len);
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_STRING(intern->u.dir.entry.d_name);
zend_string *ret;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_filesystem_object_get_path(intern, &path_len);
zend_string *fname;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
fname = php_basename(intern->u.dir.entry.d_name, strlen(intern->u.dir.entry.d_name), NULL, 0);
size_t slen = 0, path_len;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &suffix, &slen) == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_filesystem_object_get_path(intern, &path_len);
zend_string *fname;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &suffix, &slen) == FAILURE) {
- return;
+ RETURN_THROWS();
}
fname = php_basename(intern->u.dir.entry.d_name, strlen(intern->u.dir.entry.d_name), suffix, slen);
size_t path_len;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
path = spl_filesystem_object_get_pathname(intern, &path_len);
if (path != NULL) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (SPL_FILE_DIR_KEY(intern, SPL_FILE_DIR_KEY_AS_FILENAME)) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (SPL_FILE_DIR_CURRENT(intern, SPL_FILE_DIR_CURRENT_AS_PATHNAME)) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(spl_filesystem_is_dot(intern->u.dir.entry.d_name));
size_t len;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "p", &path, &len) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS); \
zend_error_handling error_handling; \
if (zend_parse_parameters_none() == FAILURE) { \
- return; \
+ RETURN_THROWS(); \
} \
\
zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling);\
zend_error_handling error_handling;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling);
zend_error_handling error_handling;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling);
zend_class_entry *ce = spl_ce_SplFileObject;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|C", &ce) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern->file_class = ce;
zend_class_entry *ce = spl_ce_SplFileInfo;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|C", &ce) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern->info_class = ce;
zend_class_entry *ce = intern->info_class;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|C", &ce) == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_filesystem_object_create_type(ZEND_NUM_ARGS(), intern, SPL_FS_INFO, ce, return_value);
char *path;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|C", &ce) == FAILURE) {
- return;
+ RETURN_THROWS();
}
path = spl_filesystem_object_get_pathname(intern, &path_len);
int skip_dots = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_SKIPDOTS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern->u.dir.index = 0;
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(intern->flags & (SPL_FILE_DIR_KEY_MODE_MASK | SPL_FILE_DIR_CURRENT_MODE_MASK | SPL_FILE_DIR_OTHERS_MASK));
zend_long flags;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &flags) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern->flags &= ~(SPL_FILE_DIR_KEY_MODE_MASK|SPL_FILE_DIR_CURRENT_MODE_MASK|SPL_FILE_DIR_OTHERS_MASK);
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &allow_links) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (spl_filesystem_is_invalid_or_dot(intern->u.dir.entry.d_name)) {
RETURN_FALSE;
char slash = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_UNIXPATHS) ? '/' : DEFAULT_SLASH;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_filesystem_object_get_file_name(intern);
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (intern->u.dir.sub_path) {
char slash = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_UNIXPATHS) ? '/' : DEFAULT_SLASH;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (intern->u.dir.sub_path) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (intern->u.dir.dirp && php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) {
&use_include_path, &intern->u.file.zcontext) == FAILURE) {
intern->u.file.open_mode = NULL;
intern->file_name = NULL;
- return;
+ RETURN_THROWS();
}
if (intern->u.file.open_mode == NULL) {
zend_error_handling error_handling;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &max_memory) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (max_memory < 0) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_filesystem_file_rewind(ZEND_THIS, intern);
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!intern->u.file.stream) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_AHEAD)) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!intern->u.file.stream) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!intern->u.file.stream) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
/* Do not read the next line to support correct counting with fgetc()
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_filesystem_file_free_line(intern);
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &intern->flags) == FAILURE) {
- return;
+ RETURN_THROWS();
}
} /* }}} */
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(intern->flags & SPL_FILE_OBJECT_MASK);
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &max_len) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (max_len < 0) {
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG((zend_long)intern->u.file.max_line_len);
SPL_METHOD(SplFileObject, hasChildren)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_FALSE;
SPL_METHOD(SplFileObject, getChildren)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
/* return NULL */
} /* }}} */
{
case 3:
switch (esc_len) {
- case 0:
+ case 0:
escape = PHP_CSV_NO_ESCAPE;
break;
case 1:
zend_long pos, whence = SEEK_SET;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|l", &pos, &whence) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!intern->u.file.stream) {
ssize_t written;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &str_len, &length) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!intern->u.file.stream) {
zend_string *str;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &length) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!intern->u.file.stream) {
zend_long size;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &size) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!intern->u.file.stream) {
zend_long line_pos;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &line_pos) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!intern->u.file.stream) {
zend_throw_exception_ex(spl_ce_RuntimeException, 0, "Object not initialized");
spl_dllist_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_dllist_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_dllist_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_dllist_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_dllist_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_dllist_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
count = spl_ptr_llist_count(intern->llist);
zend_long count;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_dllist_object_count_elements(Z_OBJ_P(ZEND_THIS), &count);
spl_dllist_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_dllist_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
zend_long index;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zindex) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_ptr_llist_element *element;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zindex) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_dllist_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &zindex, &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_ptr_llist *llist;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zindex) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(intern->traverse_position);
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_dllist_it_helper_move_forward(&intern->traverse_pointer, &intern->traverse_position, intern->llist, intern->flags ^ SPL_DLLIST_IT_LIFO);
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_dllist_it_helper_move_forward(&intern->traverse_pointer, &intern->traverse_position, intern->llist, intern->flags);
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(intern->traverse_pointer != NULL);
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_dllist_it_helper_rewind(&intern->traverse_pointer, &intern->traverse_position, intern->llist, intern->flags);
spl_ptr_llist_element *element = intern->traverse_pointer;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (element == NULL || Z_ISUNDEF(element->data)) {
php_serialize_data_t var_hash;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
PHP_VAR_SERIALIZE_INIT(var_hash);
php_unserialize_data_t var_hash;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &buf, &buf_len) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (buf_len == 0) {
zval tmp;
if (zend_parse_parameters_none_throw() == FAILURE) {
- return;
+ RETURN_THROWS();
}
array_init(return_value);
zval *flags_zv, *storage_zv, *members_zv, *elem;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "h", &data) == FAILURE) {
- return;
+ RETURN_THROWS();
}
flags_zv = zend_hash_index_find(data, 0);
zend_long index;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &zindex, &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLDLLIST_P(ZEND_THIS);
zend_long size = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &size) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (size < 0) {
zval *data;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (intern->array.size == 0) {
spl_fixedarray_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLFIXEDARRAY_P(object);
spl_fixedarray_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
zend_bool save_indexes = 1;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "a|b", &data, &save_indexes) == FAILURE) {
- return;
+ RETURN_THROWS();
}
num = zend_hash_num_elements(Z_ARRVAL_P(data));
spl_fixedarray_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLFIXEDARRAY_P(object);
zend_long size;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &size) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (size < 0) {
spl_fixedarray_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zindex) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
spl_fixedarray_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zindex) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
spl_fixedarray_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &zindex, &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
spl_fixedarray_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zindex) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(intern->current);
spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern->current++;
spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(intern->current >= 0 && intern->current < intern->array.size);
spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern->current = 0;
spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
ZVAL_LONG(&zindex, intern->current);
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
count = spl_ptr_heap_count(intern->heap);
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(spl_ptr_heap_count(intern->heap) == 0);
spl_heap_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLHEAP_P(ZEND_THIS);
spl_heap_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLHEAP_P(ZEND_THIS);
spl_pqueue_elem elem;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &data, &priority) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLHEAP_P(ZEND_THIS);
spl_heap_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLHEAP_P(ZEND_THIS);
spl_pqueue_elem *elem;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLHEAP_P(ZEND_THIS);
spl_heap_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
value &= SPL_PQUEUE_EXTR_MASK;
spl_heap_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLHEAP_P(ZEND_THIS);
spl_heap_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLHEAP_P(ZEND_THIS);
spl_heap_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLHEAP_P(ZEND_THIS);
zval *a, *b;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &a, &b) == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(spl_ptr_heap_zval_max_cmp(a, b, NULL));
spl_heap_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLHEAP_P(ZEND_THIS);
zval *a, *b;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &a, &b) == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(spl_ptr_heap_zval_min_cmp(a, b, NULL));
zval *a, *b;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &a, &b) == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(spl_ptr_heap_zval_max_cmp(a, b, NULL));
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(intern->heap->count - 1);
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_ptr_heap_delete_top(intern->heap, NULL, ZEND_THIS);
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(intern->heap->count != 0);
SPL_METHOD(SplHeap, rewind)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
/* do nothing, the iterator always points to the top element */
}
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (!intern->heap->count) {
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (!intern->heap->count) {
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_recursive_it_rewind_ex(object, ZEND_THIS);
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(spl_recursive_it_valid_ex(object, ZEND_THIS) == SUCCESS);
zend_object_iterator *iterator;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_SUB_ITERATOR(iterator, object);
zval *data;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_SUB_ITERATOR(iterator, object);
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_recursive_it_move_forward_ex(object, ZEND_THIS);
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(object->level);
zval *value;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &level) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (level < 0 || level > object->level) {
RETURN_NULL();
zval *zobject;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_SUB_ELEMENT_ADDR(zobject, object, zobject);
SPL_METHOD(RecursiveIteratorIterator, beginIteration)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
/* nothing to do */
} /* }}} */
SPL_METHOD(RecursiveIteratorIterator, endIteration)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
/* nothing to do */
} /* }}} */
zval *zobject;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (!object->iterators) {
zval *zobject;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_SUB_ELEMENT(ce, object, ce);
SPL_METHOD(RecursiveIteratorIterator, beginChildren)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
/* nothing to do */
} /* }}} */
SPL_METHOD(RecursiveIteratorIterator, endChildren)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
/* nothing to do */
} /* }}} */
SPL_METHOD(RecursiveIteratorIterator, nextElement)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
/* nothing to do */
} /* }}} */
zend_long max_depth = -1;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &max_depth) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (max_depth < -1) {
zend_throw_exception(spl_ce_OutOfRangeException, "Parameter max_depth must be >= -1", 0);
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (object->max_depth == -1) {
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "ls", &part, &prefix, &prefix_len) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (0 > part || part > 5) {
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!object->iterators) {
size_t postfix_len;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &postfix, &postfix_len) == FAILURE) {
- return;
+ RETURN_THROWS();
}
smart_str_free(&object->postfix[0]);
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!object->iterators) {
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!object->iterators) {
zend_string *str;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if(!object->iterators) {
zend_string *str;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_SUB_ITERATOR(iterator, object);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zval retval;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zval retval;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zval retval;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zval params[3];
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (Z_TYPE(intern->current.data) == IS_UNDEF || Z_TYPE(intern->current.key) == IS_UNDEF) {
int rc;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern = Z_SPLDUAL_IT_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_STR_COPY(intern->u.regex.regex);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zend_long mode;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &mode) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (mode < 0 || mode >= REGIT_MODE_MAX) {
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zend_long flags;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &flags) == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zend_long preg_flags;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &preg_flags) == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zval retval;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zend_long pos;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &pos) == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
}
if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz", &key, &value) == FAILURE) {
- return;
+ RETURN_THROWS();
}
Z_TRY_ADDREF_P(value);
}
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &key) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((value = zend_symtable_find(Z_ARRVAL(intern->u.caching.zcache), key)) == NULL) {
}
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &key) == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_symtable_del(Z_ARRVAL(intern->u.caching.zcache), key);
}
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &key) == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(zend_symtable_exists(Z_ARRVAL(intern->u.caching.zcache), key));
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &flags) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (spl_cit_check_flags(flags) != SUCCESS) {
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
SPL_METHOD(NoRewindIterator, rewind)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
/* nothing to do */
} /* }}} */
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zval *data;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
SPL_METHOD(EmptyIterator, rewind)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
} /* }}} */
SPL_METHOD(EmptyIterator, valid)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_FALSE;
} /* }}} */
SPL_METHOD(EmptyIterator, key)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_throw_exception(spl_ce_BadMethodCallException, "Accessing the key of an EmptyIterator", 0);
} /* }}} */
SPL_METHOD(EmptyIterator, current)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_throw_exception(spl_ce_BadMethodCallException, "Accessing the value of an EmptyIterator", 0);
} /* }}} */
SPL_METHOD(EmptyIterator, next)
{
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
} /* }}} */
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &it, zend_ce_iterator) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (intern->u.append.iterator->funcs->valid(intern->u.append.iterator) == SUCCESS && spl_dual_it_valid(intern) != SUCCESS) {
spl_array_iterator_append(&intern->u.append.zarrayit, it);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
spl_dual_it_object *intern;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zval *value;
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
SPL_FETCH_AND_CHECK_DUAL_IT(intern, ZEND_THIS);
zend_bool use_keys = 1;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "O|b", &obj, zend_ce_traversable, &use_keys) == FAILURE) {
- return;
+ RETURN_THROWS();
}
array_init(return_value);
zend_long count = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &obj, zend_ce_traversable) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (spl_iterator_apply(obj, spl_iterator_count_apply, (void*)&count) == FAILURE) {
apply_info.args = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "Of|a!", &apply_info.obj, zend_ce_traversable, &apply_info.fci, &apply_info.fcc, &apply_info.args) == FAILURE) {
- return;
+ RETURN_THROWS();
}
apply_info.count = 0;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o|z!", &obj, &inf) == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_object_storage_attach(intern, obj, inf);
} /* }}} */
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &obj) == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_object_storage_detach(intern, obj);
zval *obj;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &obj) == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_NEW_STR(php_spl_object_hash(obj));
zend_hash_key key;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &obj) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (spl_object_storage_get_hash(&key, intern, obj) == FAILURE) {
spl_SplObjectStorage *other;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &obj, spl_ce_SplObjectStorage) == FAILURE) {
- return;
+ RETURN_THROWS();
}
other = Z_SPLOBJSTORAGE_P(obj);
spl_SplObjectStorageElement *element;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &obj, spl_ce_SplObjectStorage) == FAILURE) {
- return;
+ RETURN_THROWS();
}
other = Z_SPLOBJSTORAGE_P(obj);
spl_SplObjectStorageElement *element;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &obj, spl_ce_SplObjectStorage) == FAILURE) {
- return;
+ RETURN_THROWS();
}
other = Z_SPLOBJSTORAGE_P(obj);
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &obj) == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(spl_object_storage_contains(intern, obj));
} /* }}} */
zend_long mode = COUNT_NORMAL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &mode) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (mode == COUNT_RECURSIVE) {
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_BOOL(zend_hash_has_more_elements_ex(&intern->storage, &intern->pos) == SUCCESS);
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(intern->index);
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) == NULL) {
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) == NULL) {
zval *inf;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &inf) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) == NULL) {
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_hash_move_forward_ex(&intern->storage, &intern->pos);
smart_str buf = {0};
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
PHP_VAR_SERIALIZE_INIT(var_hash);
zend_long count;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &buf, &buf_len) == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (buf_len == 0) {
zval tmp;
if (zend_parse_parameters_none_throw() == FAILURE) {
- return;
+ RETURN_THROWS();
}
array_init(return_value);
zval *storage_zv, *members_zv, *key, *val;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "h", &data) == FAILURE) {
- return;
+ RETURN_THROWS();
}
storage_zv = zend_hash_index_find(data, 0);
zend_long flags = MIT_NEED_ALL|MIT_KEYS_NUMERIC;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &flags) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
RETURN_LONG(intern->flags);
}
intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &intern->flags) == FAILURE) {
- return;
+ RETURN_THROWS();
}
}
/* }}} */
zval *iterator = NULL, *info = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "O|z!", &iterator, zend_ce_iterator, &info) == FAILURE) {
- return;
+ RETURN_THROWS();
}
intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
if (!zend_hash_num_elements(&intern->storage)) {
intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_multiple_iterator_get_all(intern, SPL_MULTIPLE_ITERATOR_GET_ALL_CURRENT, return_value);
intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
if (zend_parse_parameters_none() == FAILURE) {
- return;
+ RETURN_THROWS();
}
spl_multiple_iterator_get_all(intern, SPL_MULTIPLE_ITERATOR_GET_ALL_KEY, return_value);
projects / php / commitdiff