#define HASH_OF(p) (Z_TYPE_P(p)==IS_ARRAY ? Z_ARRVAL_P(p) : ((Z_TYPE_P(p)==IS_OBJECT ? Z_OBJ_HT_P(p)->get_properties((p) TSRMLS_CC) : NULL)))
#define ZVAL_IS_NULL(z) (Z_TYPE_P(z) == IS_NULL)
-#define ZVAL_IS_UNDEF(z) (Z_TYPE_P(z) == IS_UNDEF)
/* For compatibility */
#define ZEND_MINIT ZEND_MODULE_STARTUP_N
{
zend_user_iterator *iter = (zend_user_iterator*)_iter;
- if (!ZVAL_IS_UNDEF(&iter->value)) {
+ if (!Z_ISUNDEF(iter->value)) {
zval_ptr_dtor(&iter->value);
ZVAL_UNDEF(&iter->value);
}
zend_user_iterator *iter = (zend_user_iterator*)_iter;
zval *object = &iter->it.data;
- if (ZVAL_IS_UNDEF(&iter->value)) {
+ if (Z_ISUNDEF(iter->value)) {
zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_current, "current", &iter->value);
}
return &iter->value;
#define Z_ISREF(zval) (Z_TYPE(zval) == IS_REFERENCE)
#define Z_ISREF_P(zval_p) Z_ISREF(*(zval_p))
+#define Z_ISUNDEF(zval) (Z_TYPE(zval) == IS_UNDEF)
+#define Z_ISUNDEF_P(zval_p) Z_ISUNDEF(*(zval_p))
+
+#define Z_ISNULL(zval) (Z_TYPE(zval) == IS_NULL)
+#define Z_ISNULL_P(zval_p) Z_ISNULL(*(zval_p))
+
#define Z_LVAL(zval) (zval).value.lval
#define Z_LVAL_P(zval_p) Z_LVAL(*(zval_p))
if (objmap->ns) {
xmlFree(objmap->ns);
}
- if (!ZVAL_IS_UNDEF(&objmap->baseobj_zv)) {
+ if (!Z_ISUNDEF(objmap->baseobj_zv)) {
zval_ptr_dtor(&objmap->baseobj_zv);
}
efree(objmap);
zval_ptr_dtor(&fci->function_name);
fci->size = 0;
}
- if (!ZVAL_IS_UNDEF(object)) {
+ if (!Z_ISUNDEF_P(object)) {
zval_ptr_dtor(object);
ZVAL_UNDEF(object);
}
}
}
- context = php_stream_context_from_zval(ZVAL_IS_UNDEF(&LIBXML(stream_context))? NULL : &LIBXML(stream_context), 0);
+ context = php_stream_context_from_zval(Z_ISUNDEF(LIBXML(stream_context))? NULL : &LIBXML(stream_context), 0);
ret_val = php_stream_open_wrapper_ex(path_to_open, (char *)mode, REPORT_ERRORS, NULL, context);
if (isescaped) {
fci->no_separation = 1;
status = zend_call_function(fci, &LIBXML(entity_loader).fcc TSRMLS_CC);
- if (status != SUCCESS || ZVAL_IS_UNDEF(&retval)) {
+ if (status != SUCCESS || Z_ISUNDEF(retval)) {
php_libxml_ctx_error(context,
"Call to user entity loader callback '%s' has failed",
Z_STRVAL(fci->function_name));
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg) == FAILURE) {
return;
}
- if (!ZVAL_IS_UNDEF(&LIBXML(stream_context))) {
+ if (!Z_ISUNDEF(LIBXML(stream_context))) {
zval_ptr_dtor(&LIBXML(stream_context));
ZVAL_UNDEF(&LIBXML(stream_context));
}
/* make encoding list */
list = NULL;
size = 0;
- if (ZEND_NUM_ARGS() >= 2 && !ZVAL_IS_NULL(encoding_list)) {
+ if (ZEND_NUM_ARGS() >= 2 && !Z_ISNULL_P(encoding_list)) {
switch (Z_TYPE_P(encoding_list)) {
case IS_ARRAY:
if (FAILURE == php_mb_parse_encoding_array(encoding_list, &list, &size, 0 TSRMLS_CC)) {
{
MBREX(current_mbctype) = MBREX(default_mbctype);
- if (!ZVAL_IS_UNDEF(&MBREX(search_str))) {
+ if (!Z_ISUNDEF(MBREX(search_str))) {
zval_ptr_dtor(&MBREX(search_str));
ZVAL_UNDEF(&MBREX(search_str));
}
arg_replace_fci.params = args;
arg_replace_fci.retval = &retval;
if (zend_call_function(&arg_replace_fci, &arg_replace_fci_cache TSRMLS_CC) == SUCCESS &&
- !ZVAL_IS_UNDEF(&retval)) {
+ !Z_ISUNDEF(retval)) {
convert_to_string_ex(&retval);
smart_str_appendl(&out_buf, Z_STRVAL(retval), Z_STRLEN(retval));
if (eval_buf.s) {
pos = MBREX(search_pos);
str = NULL;
len = 0;
- if (!ZVAL_IS_UNDEF(&MBREX(search_str)) && Z_TYPE(MBREX(search_str)) == IS_STRING){
+ if (!Z_ISUNDEF(MBREX(search_str)) && Z_TYPE(MBREX(search_str)) == IS_STRING){
str = (OnigUChar *)Z_STRVAL(MBREX(search_str));
len = Z_STRLEN(MBREX(search_str));
}
}
}
- if (!ZVAL_IS_NULL(&MBREX(search_str))) {
+ if (!Z_ISNULL(MBREX(search_str))) {
zval_ptr_dtor(&MBREX(search_str));
}
return;
}
- if (position < 0 || (!ZVAL_IS_UNDEF(&MBREX(search_str)) && Z_TYPE(MBREX(search_str)) == IS_STRING && position >= Z_STRLEN(MBREX(search_str)))) {
+ if (position < 0 || (!Z_ISUNDEF(MBREX(search_str)) && Z_TYPE(MBREX(search_str)) == IS_STRING && position >= Z_STRLEN(MBREX(search_str)))) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Position is out of range");
MBREX(search_pos) = 0;
RETURN_FALSE;
if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Could not execute %s::%s()", ce->name->val, ce->constructor->common.function_name->val);
} else {
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
}
zend_update_property_string(def_ex, &ex, "message", sizeof("message") - 1, message TSRMLS_CC);
zend_update_property_string(def_ex, &ex, "code", sizeof("code") - 1, *pdo_err TSRMLS_CC);
- if (!ZVAL_IS_UNDEF(&info)) {
+ if (!Z_ISUNDEF(info)) {
zend_update_property(pdo_ex, &ex, "errorInfo", sizeof("errorInfo") - 1, &info TSRMLS_CC);
}
zend_throw_exception_object(&ex TSRMLS_CC);
}
- if (!ZVAL_IS_UNDEF(&info)) {
+ if (!Z_ISUNDEF(info)) {
zval_ptr_dtor(&info);
}
static zval *pdo_stmt_instantiate(pdo_dbh_t *dbh, zval *object, zend_class_entry *dbstmt_ce, zval *ctor_args TSRMLS_DC) /* {{{ */
{
- if (!ZVAL_IS_UNDEF(ctor_args)) {
+ if (!Z_ISUNDEF_P(ctor_args)) {
if (Z_TYPE_P(ctor_args) != IS_ARRAY) {
pdo_raise_impl_error(dbh, NULL, "HY000", "constructor arguments must be passed as an array" TSRMLS_CC);
return NULL;
if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
Z_OBJ_P(object) = NULL;
object = NULL; /* marks failure */
- } else if (!ZVAL_IS_UNDEF(&retval)) {
+ } else if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
return FAILURE;
}
dbh->def_stmt_ce = pce;
- if (!ZVAL_IS_UNDEF(&dbh->def_stmt_ctor_args)) {
+ if (!Z_ISUNDEF(dbh->def_stmt_ctor_args)) {
zval_ptr_dtor(&dbh->def_stmt_ctor_args);
ZVAL_UNDEF(&dbh->def_stmt_ctor_args);
}
case PDO_ATTR_STATEMENT_CLASS:
array_init(return_value);
add_next_index_str(return_value, STR_COPY(dbh->def_stmt_ce->name));
- if (!ZVAL_IS_UNDEF(&dbh->def_stmt_ctor_args)) {
+ if (!Z_ISUNDEF(dbh->def_stmt_ctor_args)) {
Z_ADDREF(dbh->def_stmt_ctor_args);
add_next_index_zval(return_value, &dbh->def_stmt_ctor_args);
}
pefree((char *)dbh->persistent_id, dbh->is_persistent);
}
- if (!ZVAL_IS_UNDEF(&dbh->def_stmt_ctor_args)) {
+ if (!Z_ISUNDEF(dbh->def_stmt_ctor_args)) {
zval_ptr_dtor(&dbh->def_stmt_ctor_args);
}
static void get_lazy_object(pdo_stmt_t *stmt, zval *return_value TSRMLS_DC) /* {{{ */
{
- if (ZVAL_IS_UNDEF(&stmt->lazy_object_ref)) {
+ if (Z_ISUNDEF(stmt->lazy_object_ref)) {
pdo_row_t *row = ecalloc(1, sizeof(pdo_row_t));
row->stmt = stmt;
zend_object_std_init(&row->std, pdo_row_ce TSRMLS_CC);
STR_RELEASE(param->name);
}
- if (!ZVAL_IS_UNDEF(¶m->parameter)) {
+ if (!Z_ISUNDEF(param->parameter)) {
zval_ptr_dtor(¶m->parameter);
ZVAL_UNDEF(¶m->parameter);
}
- if (!ZVAL_IS_UNDEF(¶m->driver_params)) {
+ if (!Z_ISUNDEF(param->driver_params)) {
zval_ptr_dtor(¶m->driver_params);
}
efree(param);
parameter = Z_REFVAL(param->parameter);
}
- if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_STR && param->max_value_len <= 0 && !ZVAL_IS_NULL(parameter)) {
+ if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_STR && param->max_value_len <= 0 && !Z_ISNULL_P(parameter)) {
if (Z_TYPE_P(parameter) == IS_DOUBLE) {
char *p;
int len = spprintf(&p, 0, "%.*H", (int) EG(precision), Z_DVAL_P(parameter));
ZVAL_COPY(¶m.parameter, tmp);
if (!really_register_bound_param(¶m, stmt, 1 TSRMLS_CC)) {
- if (!ZVAL_IS_UNDEF(¶m.parameter)) {
+ if (!Z_ISUNDEF(param.parameter)) {
zval_ptr_dtor(¶m.parameter);
}
RETURN_FALSE;
fcc->calling_scope = EG(scope);
fcc->called_scope = ce;
return 1;
- } else if (!ZVAL_IS_UNDEF(&stmt->fetch.cls.ctor_args)) {
+ } else if (!Z_ISUNDEF(stmt->fetch.cls.ctor_args)) {
pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "user-supplied class does not have a constructor, use NULL for the ctor_params parameter, or simply omit it" TSRMLS_CC);
return 0;
} else {
}
stmt->fetch.cls.fci.size = 0;
- if (!ZVAL_IS_UNDEF(&stmt->fetch.cls.ctor_args) && free_ctor_agrs) {
+ if (!Z_ISUNDEF(stmt->fetch.cls.ctor_args) && free_ctor_agrs) {
zval_ptr_dtor(&stmt->fetch.cls.ctor_args);
ZVAL_UNDEF(&stmt->fetch.cls.ctor_args);
stmt->fetch.cls.fci.param_count = 0;
pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not call class constructor" TSRMLS_CC);
return 0;
} else {
- if (!ZVAL_IS_UNDEF(&stmt->fetch.cls.retval)) {
+ if (!Z_ISUNDEF(stmt->fetch.cls.retval)) {
zval_ptr_dtor(&stmt->fetch.cls.retval);
ZVAL_UNDEF(&stmt->fetch.cls.retval);
}
break;
case PDO_FETCH_INTO:
- if (ZVAL_IS_UNDEF(&stmt->fetch.into)) {
+ if (Z_ISUNDEF(stmt->fetch.into)) {
pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "No fetch-into object specified." TSRMLS_CC);
return 0;
break;
break;
case PDO_FETCH_FUNC:
- if (ZVAL_IS_UNDEF(&stmt->fetch.func.function)) {
+ if (Z_ISUNDEF(stmt->fetch.func.function)) {
pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "No fetch function specified" TSRMLS_CC);
return 0;
}
pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not call class constructor" TSRMLS_CC);
return 0;
} else {
- if (!ZVAL_IS_UNDEF(&stmt->fetch.cls.retval)) {
+ if (!Z_ISUNDEF(stmt->fetch.cls.retval)) {
zval_ptr_dtor(&stmt->fetch.cls.retval);
}
}
if (return_all) {
zval_ptr_dtor(return_value); /* we don't need that */
ZVAL_COPY_VALUE(return_value, &retval);
- } else if (!ZVAL_IS_UNDEF(&retval)) {
+ } else if (!Z_ISUNDEF(retval)) {
ZVAL_COPY_VALUE(return_value, &retval);
}
}
ZVAL_COPY(¶m.parameter, parameter);
if (!really_register_bound_param(¶m, stmt, is_param TSRMLS_CC)) {
- if (!ZVAL_IS_UNDEF(¶m.parameter)) {
+ if (!Z_ISUNDEF(param.parameter)) {
zval_ptr_dtor(&(param.parameter));
}
return 0;
ZVAL_COPY(¶m.parameter, parameter);
if (!really_register_bound_param(¶m, stmt, TRUE TSRMLS_CC)) {
- if (!ZVAL_IS_UNDEF(¶m.parameter)) {
+ if (!Z_ISUNDEF(param.parameter)) {
zval_ptr_dtor(&(param.parameter));
ZVAL_UNDEF(¶m.parameter);
}
switch (stmt->default_fetch_type) {
case PDO_FETCH_INTO:
- if (!ZVAL_IS_UNDEF(&stmt->fetch.into)) {
+ if (!Z_ISUNDEF(stmt->fetch.into)) {
zval_ptr_dtor(&stmt->fetch.into);
ZVAL_UNDEF(&stmt->fetch.into);
}
stmt->columns = NULL;
}
- if (!ZVAL_IS_UNDEF(&stmt->fetch.into) && stmt->default_fetch_type == PDO_FETCH_INTO) {
+ if (!Z_ISUNDEF(stmt->fetch.into) && stmt->default_fetch_type == PDO_FETCH_INTO) {
ZVAL_UNDEF(&stmt->fetch.into);
}
do_fetch_opt_finish(stmt, 1 TSRMLS_CC);
- if (!ZVAL_IS_UNDEF(&stmt->database_object_handle)) {
+ if (!Z_ISUNDEF(stmt->database_object_handle)) {
zval_ptr_dtor(&stmt->database_object_handle);
}
zend_object_std_dtor(&stmt->std TSRMLS_CC);
zval_ptr_dtor(&I->iter.data);
- if (!ZVAL_IS_UNDEF(&I->fetch_ahead)) {
+ if (!Z_ISUNDEF(I->fetch_ahead)) {
zval_ptr_dtor(&I->fetch_ahead);
}
}
{
struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
- return ZVAL_IS_UNDEF(&I->fetch_ahead) ? FAILURE : SUCCESS;
+ return Z_ISUNDEF(I->fetch_ahead) ? FAILURE : SUCCESS;
}
static zval *pdo_stmt_iter_get_data(zend_object_iterator *iter TSRMLS_DC)
struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
/* sanity */
- if (ZVAL_IS_UNDEF(&I->fetch_ahead)) {
+ if (Z_ISUNDEF(I->fetch_ahead)) {
return NULL;
}
struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
pdo_stmt_t *stmt = Z_PDO_STMT_P(&I->iter.data); /* for PDO_HANDLE_STMT_ERR() */
- if (!ZVAL_IS_UNDEF(&I->fetch_ahead)) {
+ if (!Z_ISUNDEF(I->fetch_ahead)) {
zval_ptr_dtor(&I->fetch_ahead);
}
}
efree((char*)func->funcname);
- if (!ZVAL_IS_UNDEF(&func->func)) {
+ if (!Z_ISUNDEF(func->func)) {
zval_ptr_dtor(&func->func);
}
- if (!ZVAL_IS_UNDEF(&func->step)) {
+ if (!Z_ISUNDEF(func->step)) {
zval_ptr_dtor(&func->step);
}
- if (!ZVAL_IS_UNDEF(&func->fini)) {
+ if (!Z_ISUNDEF(func->fini)) {
zval_ptr_dtor(&func->fini);
}
efree(func);
}
efree((char*)collation->name);
- if (!ZVAL_IS_UNDEF(&collation->callback)) {
+ if (!Z_ISUNDEF(collation->callback)) {
zval_ptr_dtor(&collation->callback);
}
efree(collation);
if (!agg_context) {
ZVAL_NULL(&zargs[0]);
} else {
- if (ZVAL_IS_UNDEF(&agg_context->val)) {
+ if (Z_ISUNDEF(agg_context->val)) {
GC_REFCOUNT(agg_context) = 1;
GC_TYPE_INFO(agg_context) = IS_REFERENCE;
ZVAL_NULL(&agg_context->val);
if (!is_agg || !argv) {
/* only set the sqlite return value if we are a scalar function,
* or if we are finalizing an aggregate */
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
switch (Z_TYPE(retval)) {
case IS_LONG:
sqlite3_result_int(context, Z_LVAL(retval));
if (agg_context) {
zval_ptr_dtor(&agg_context->val);
}
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
ZVAL_COPY_VALUE(&agg_context->val, &retval);
ZVAL_UNDEF(&retval);
} else {
}
}
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
if ((ret = zend_call_function(&collation->fc.fci, &collation->fc.fcc TSRMLS_CC)) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback");
- } else if (!ZVAL_IS_UNDEF(&retval)) {
+ } else if (!Z_ISUNDEF(retval)) {
if (Z_TYPE(retval) != IS_LONG) {
convert_to_long_ex(&retval);
}
return;
}
GET_REFLECTION_OBJECT();
- if (!ZVAL_IS_UNDEF(&intern->obj)) {
+ if (!Z_ISUNDEF(intern->obj)) {
closure_this = zend_get_closure_this_ptr(&intern->obj TSRMLS_CC);
- if (!ZVAL_IS_UNDEF(closure_this)) {
+ if (!Z_ISUNDEF_P(closure_this)) {
RETURN_ZVAL(closure_this, 1, 0);
}
}
return;
}
GET_REFLECTION_OBJECT();
- if (!ZVAL_IS_UNDEF(&intern->obj)) {
+ if (!Z_ISUNDEF(intern->obj)) {
closure_func = zend_get_closure_method_def(&intern->obj TSRMLS_CC);
if (closure_func && closure_func->common.scope) {
zend_reflection_class_factory(closure_func->common.scope, return_value TSRMLS_CC);
for (i = 0; i < fptr->common.num_args; i++) {
zval parameter;
- reflection_parameter_factory(_copy_function(fptr TSRMLS_CC), ZVAL_IS_UNDEF(&intern->obj)? NULL : &intern->obj, arg_info, i, fptr->common.required_num_args, ¶meter TSRMLS_CC);
+ reflection_parameter_factory(_copy_function(fptr TSRMLS_CC), Z_ISUNDEF(intern->obj)? NULL : &intern->obj, arg_info, i, fptr->common.required_num_args, ¶meter TSRMLS_CC);
add_next_index_zval(return_value, ¶meter);
arg_info++;
GET_REFLECTION_OBJECT_PTR(param);
if (!param->fptr->common.scope) {
- reflection_function_factory(_copy_function(param->fptr TSRMLS_CC), ZVAL_IS_UNDEF(&intern->obj)? NULL : &intern->obj, return_value TSRMLS_CC);
+ reflection_function_factory(_copy_function(param->fptr TSRMLS_CC), Z_ISUNDEF(intern->obj)? NULL : &intern->obj, return_value TSRMLS_CC);
} else {
- reflection_method_factory(param->fptr->common.scope, _copy_function(param->fptr TSRMLS_CC), ZVAL_IS_UNDEF(&intern->obj)? NULL : &intern->obj, return_value TSRMLS_CC);
+ reflection_method_factory(param->fptr->common.scope, _copy_function(param->fptr TSRMLS_CC), Z_ISUNDEF(intern->obj)? NULL : &intern->obj, return_value TSRMLS_CC);
}
}
/* }}} */
GET_REFLECTION_OBJECT_PTR(ce);
lc_name = zend_str_tolower_dup(name, name_len);
- if (ce == zend_ce_closure && !ZVAL_IS_UNDEF(&intern->obj) && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
+ if (ce == zend_ce_closure && !Z_ISUNDEF(intern->obj) && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
&& memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
&& (mptr = zend_get_closure_invoke_method(Z_OBJ(intern->obj) TSRMLS_CC)) != NULL)
{
method and not the closure definition itself */
reflection_method_factory(ce, mptr, NULL, return_value TSRMLS_CC);
efree(lc_name);
- } else if (ce == zend_ce_closure && ZVAL_IS_UNDEF(&intern->obj) && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
+ } else if (ce == zend_ce_closure && Z_ISUNDEF(intern->obj) && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
&& memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
&& object_init_ex(&obj_tmp, ce) == SUCCESS && (mptr = zend_get_closure_invoke_method(Z_OBJ(obj_tmp) TSRMLS_CC)) != NULL) {
/* don't assign closure_object since we only reflect the invoke handler
if (ce->ce_flags & (ZEND_ACC_INTERFACE | ZEND_ACC_TRAIT | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS | ZEND_ACC_IMPLICIT_ABSTRACT_CLASS)) {
RETURN_FALSE;
}
- if (!ZVAL_IS_UNDEF(&intern->obj)) {
+ if (!Z_ISUNDEF(intern->obj)) {
if (ce->clone) {
RETURN_BOOL(ce->clone->common.fn_flags & ZEND_ACC_PUBLIC);
} else {
if (call_user_function(EG(function_table), NULL, func, retval, argc, argv TSRMLS_CC) == FAILURE) {
zval_ptr_dtor(retval);
ZVAL_UNDEF(retval);
- } else if (ZVAL_IS_UNDEF(retval)) {
+ } else if (Z_ISUNDEF_P(retval)) {
ZVAL_NULL(retval);
}
for (i = 0; i < argc; i++) {
#define PSF(a) PS(mod_user_names).name.ps_##a
#define FINISH \
- if (!ZVAL_IS_UNDEF(&retval)) { \
+ if (!Z_ISUNDEF(retval)) { \
convert_to_long(&retval); \
ret = Z_LVAL(retval); \
zval_ptr_dtor(&retval); \
zval args[2];
STDVARS;
- if (ZVAL_IS_UNDEF(&PSF(open))) {
+ if (Z_ISUNDEF(PSF(open))) {
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"user session functions not defined");
PS(mod_user_implemented) = 0;
if (bailout) {
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
zend_bailout();
ps_call_handler(&PSF(read), 1, args, &retval TSRMLS_CC);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
if (Z_TYPE(retval) == IS_STRING) {
*val = STR_COPY(Z_STR(retval));
ret = SUCCESS;
PS_CREATE_SID_FUNC(user)
{
/* maintain backwards compatibility */
- if (!ZVAL_IS_UNDEF(&PSF(create_sid))) {
+ if (!Z_ISUNDEF(PSF(create_sid))) {
zend_string *id = NULL;
zval retval;
ps_call_handler(&PSF(create_sid), 0, NULL, &retval TSRMLS_CC);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
if (Z_TYPE(retval) == IS_STRING) {
id = STR_COPY(Z_STR(retval));
}
#define PS_ADD_VAR(name) PS_ADD_VARL(name)
#define PS_DEL_VARL(name) do { \
- if (!ZVAL_IS_NULL(&PS(http_session_vars))) { \
+ if (!Z_ISNULL(PS(http_session_vars))) { \
zend_hash_del(Z_ARRVAL(PS(http_session_vars)), name); \
} \
} while (0)
/* Dispatched by RSHUTDOWN and by php_session_destroy */
static inline void php_rshutdown_session_globals(TSRMLS_D) /* {{{ */
{
- if (!ZVAL_IS_UNDEF(&PS(http_session_vars))) {
+ if (!Z_ISUNDEF(PS(http_session_vars))) {
zval_ptr_dtor(&PS(http_session_vars));
ZVAL_UNDEF(&PS(http_session_vars));
}
/* Unconditionally destroy existing array -- possible dirty data */
zend_delete_global_variable(var_name TSRMLS_CC);
- if (!ZVAL_IS_UNDEF(&PS(http_session_vars))) {
+ if (!Z_ISUNDEF(PS(http_session_vars))) {
zval_ptr_dtor(&PS(http_session_vars));
}
PHP_VAR_UNSERIALIZE_INIT(var_hash);
php_var_unserialize(&session_vars, (const unsigned char**)&val, endptr, &var_hash TSRMLS_CC);
PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
- if (!ZVAL_IS_UNDEF(&PS(http_session_vars))) {
+ if (!Z_ISUNDEF(PS(http_session_vars))) {
zval_ptr_dtor(&PS(http_session_vars));
}
if (Z_TYPE(session_vars) == IS_NULL) {
* '<session-name>=<session-id>' to allow URLs of the form
* http://yoursite/<session-name>=<session-id>/script.php */
- if (!PS(use_only_cookies) && !PS(id) && !ZVAL_IS_UNDEF(&PG(http_globals)[TRACK_VARS_SERVER]) &&
+ if (!PS(use_only_cookies) && !PS(id) && !Z_ISUNDEF(PG(http_globals)[TRACK_VARS_SERVER]) &&
(data = zend_hash_str_find(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "REQUEST_URI", sizeof("REQUEST_URI") - 1)) &&
Z_TYPE_P(data) == IS_STRING &&
(p = strstr(Z_STRVAL_P(data), PS(session_name))) &&
if (PS(id) &&
PS(extern_referer_chk)[0] != '\0' &&
- !ZVAL_IS_UNDEF(&PG(http_globals)[TRACK_VARS_SERVER]) &&
+ !Z_ISUNDEF(PG(http_globals)[TRACK_VARS_SERVER]) &&
(data = zend_hash_str_find(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "HTTP_REFERER", sizeof("HTTP_REFERER") - 1)) &&
Z_TYPE_P(data) == IS_STRING &&
Z_STRLEN_P(data) != 0 &&
zend_hash_get_current_key_ex(&php_session_iface_entry->function_table, &func_name, &func_index, 0, &pos);
if ((current_mptr = zend_hash_find_ptr(&Z_OBJCE_P(obj)->function_table, func_name))) {
- if (!ZVAL_IS_UNDEF(&PS(mod_user_names).names[i])) {
+ if (!Z_ISUNDEF(PS(mod_user_names).names[i])) {
zval_ptr_dtor(&PS(mod_user_names).names[i]);
}
zend_hash_get_current_key_ex(&php_session_id_iface_entry->function_table, &func_name, &func_index, 0, &pos);
if ((current_mptr = zend_hash_find_ptr(&Z_OBJCE_P(obj)->function_table, func_name))) {
- if (!ZVAL_IS_UNDEF(&PS(mod_user_names).names[i])) {
+ if (!Z_ISUNDEF(PS(mod_user_names).names[i])) {
zval_ptr_dtor(&PS(mod_user_names).names[i]);
}
}
for (i = 0; i < argc; i++) {
- if (!ZVAL_IS_UNDEF(&PS(mod_user_names).names[i])) {
+ if (!Z_ISUNDEF(PS(mod_user_names).names[i])) {
zval_ptr_dtor(&PS(mod_user_names).names[i]);
}
ZVAL_COPY(&PS(mod_user_names).names[i], &args[i]);
/* this should NOT be done in php_rshutdown_session_globals() */
for (i = 0; i < 7; i++) {
- if (!ZVAL_IS_UNDEF(&PS(mod_user_names).names[i])) {
+ if (!Z_ISUNDEF(PS(mod_user_names).names[i])) {
zval_ptr_dtor(&PS(mod_user_names).names[i]);
ZVAL_UNDEF(&PS(mod_user_names).names[i]);
}
{
zval *ppid;
- if (ZVAL_IS_UNDEF(&PG(http_globals)[where])) {
+ if (Z_ISUNDEF(PG(http_globals)[where])) {
return 0;
}
}
/* First FILE_START event, initializing data */
- if (ZVAL_IS_UNDEF(&progress->data)) {
+ if (Z_ISUNDEF(progress->data)) {
if (PS(rfc1867_freq) >= 0) {
progress->update_step = PS(rfc1867_freq);
php_rshutdown_session_globals(TSRMLS_C);
}
- if (!ZVAL_IS_UNDEF(&progress->data)) {
+ if (!Z_ISUNDEF(progress->data)) {
zval_ptr_dtor(&progress->data);
}
zval_ptr_dtor(&progress->sid);
if (sxe && sxe->iter.type != SXE_ITER_NONE) {
php_sxe_reset_iterator(sxe, 1 TSRMLS_CC);
- if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
+ if (!Z_ISUNDEF(sxe->iter.data)) {
intern = Z_SXEOBJ_P(&sxe->iter.data);
GET_NODE(intern, retnode)
}
zval_dtor(&tmp_zv);
}
- if (ZVAL_IS_UNDEF(rv)) {
+ if (Z_ISUNDEF_P(rv)) {
ZVAL_COPY_VALUE(rv, &EG(uninitialized_zval));
}
_node_as_zval(sxe, node, &ret, type, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
sxe = Z_SXEOBJ_P(&ret);
- if (!ZVAL_IS_UNDEF(&sxe->tmp)) {
+ if (!Z_ISUNDEF(sxe->tmp)) {
zval_ptr_dtor(&sxe->tmp);
}
if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr)attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
ZVAL_STR(&value, sxe_xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, attr->children, 1 TSRMLS_CC));
namelen = xmlStrlen(attr->name);
- if (ZVAL_IS_UNDEF(&zattr)) {
+ if (Z_ISUNDEF(zattr)) {
array_init(&zattr);
sxe_properties_add(rv, "@attributes", sizeof("@attributes") - 1, &zattr TSRMLS_CC);
}
}
if (use_iter) {
- if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
+ if (!Z_ISUNDEF(sxe->iter.data)) {
zval_ptr_dtor(&sxe->iter.data);
}
ZVAL_COPY_VALUE(&sxe->iter.data, &iter_data);
node = php_sxe_iterator_fetch(sxe, node->next, 0 TSRMLS_CC);
}
- if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
+ if (!Z_ISUNDEF(sxe->iter.data)) {
zval_ptr_dtor(&sxe->iter.data);
}
ZVAL_COPY_VALUE(&sxe->iter.data, &data);
if (intern->fptr_count) {
zval rv;
zend_call_method_with_0_params(object, intern->zo.ce, &intern->fptr_count, "count", &rv);
- if (!ZVAL_IS_UNDEF(&rv)) {
- if (!ZVAL_IS_UNDEF(&intern->tmp)) {
+ if (!Z_ISUNDEF(rv)) {
+ if (!Z_ISUNDEF(intern->tmp)) {
zval_ptr_dtor(&intern->tmp);
}
ZVAL_ZVAL(&intern->tmp, &rv, 0, 0);
sxe = php_sxe_fetch_object(object);
- if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
+ if (!Z_ISUNDEF(sxe->iter.data)) {
zval_ptr_dtor(&sxe->iter.data);
ZVAL_UNDEF(&sxe->iter.data);
}
xmlFree(sxe->iter.nsprefix);
sxe->iter.nsprefix = NULL;
}
- if (!ZVAL_IS_UNDEF(&sxe->tmp)) {
+ if (!Z_ISUNDEF(sxe->tmp)) {
zval_ptr_dtor(&sxe->tmp);
ZVAL_UNDEF(&sxe->tmp);
}
{
xmlNodePtr node;
- if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
+ if (!Z_ISUNDEF(sxe->iter.data)) {
zval_ptr_dtor(&sxe->iter.data);
ZVAL_UNDEF(&sxe->iter.data);
}
php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
/* cleanup handled in sxe_object_dtor as we dont always have an iterator wrapper */
- if (!ZVAL_IS_UNDEF(&iterator->intern.data)) {
+ if (!Z_ISUNDEF(iterator->intern.data)) {
zval_ptr_dtor(&iterator->intern.data);
}
}
{
php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
- return ZVAL_IS_UNDEF(&iterator->sxe->iter.data) ? FAILURE : SUCCESS;
+ return Z_ISUNDEF(iterator->sxe->iter.data) ? FAILURE : SUCCESS;
}
/* }}} */
xmlNodePtr node = NULL;
php_sxe_object *intern;
- if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
+ if (!Z_ISUNDEF(sxe->iter.data)) {
intern = Z_SXEOBJ_P(&sxe->iter.data);
GET_NODE(intern, node)
zval_ptr_dtor(&sxe->iter.data);
return;
}
- RETURN_BOOL(!ZVAL_IS_UNDEF(&sxe->iter.data));
+ RETURN_BOOL(!Z_ISUNDEF(sxe->iter.data));
}
/* }}} */
return;
}
- if (ZVAL_IS_UNDEF(&sxe->iter.data)) {
+ if (Z_ISUNDEF(sxe->iter.data)) {
return; /* return NULL */
}
return;
}
- if (ZVAL_IS_UNDEF(&sxe->iter.data)) {
+ if (Z_ISUNDEF(sxe->iter.data)) {
RETURN_FALSE;
}
return;
}
- if (ZVAL_IS_UNDEF(&sxe->iter.data) || sxe->iter.type == SXE_ITER_ATTRLIST) {
+ if (Z_ISUNDEF(sxe->iter.data) || sxe->iter.type == SXE_ITER_ATTRLIST) {
RETURN_FALSE;
}
child = Z_SXEOBJ_P(&sxe->iter.data);
return;
}
- if (ZVAL_IS_UNDEF(&sxe->iter.data) || sxe->iter.type == SXE_ITER_ATTRLIST) {
+ if (Z_ISUNDEF(sxe->iter.data) || sxe->iter.type == SXE_ITER_ATTRLIST) {
return; /* return NULL */
}
RETURN_ZVAL(&sxe->iter.data, 1, 0);
static void autoload_func_info_dtor(zval *element)
{
autoload_func_info *alfi = (autoload_func_info*)Z_PTR_P(element);
- if (!ZVAL_IS_UNDEF(&alfi->obj)) {
+ if (!Z_ISUNDEF(alfi->obj)) {
zval_ptr_dtor(&alfi->obj);
}
- if (!ZVAL_IS_UNDEF(&alfi->closure)) {
+ if (!Z_ISUNDEF(alfi->closure)) {
zval_ptr_dtor(&alfi->closure);
}
efree(alfi);
while (zend_hash_has_more_elements_ex(SPL_G(autoload_functions), &function_pos) == SUCCESS) {
zend_hash_get_current_key_ex(SPL_G(autoload_functions), &func_name, &dummy, 0, &function_pos);
alfi = zend_hash_get_current_data_ptr_ex(SPL_G(autoload_functions), &function_pos);
- zend_call_method(ZVAL_IS_UNDEF(&alfi->obj)? NULL : &alfi->obj, alfi->ce, &alfi->func_ptr, func_name->val, func_name->len, retval, 1, class_name, NULL TSRMLS_CC);
+ zend_call_method(Z_ISUNDEF(alfi->obj)? NULL : &alfi->obj, alfi->ce, &alfi->func_ptr, func_name->val, func_name->len, retval, 1, class_name, NULL TSRMLS_CC);
zend_exception_save(TSRMLS_C);
if (retval) {
zval_ptr_dtor(retval);
STR_RELEASE(func_name);
if (SPL_G(autoload_functions) && zend_hash_exists(SPL_G(autoload_functions), lc_name)) {
- if (!ZVAL_IS_UNDEF(&alfi.closure)) {
+ if (!Z_ISUNDEF(alfi.closure)) {
Z_DELREF_P(&alfi.closure);
}
goto skip;
if (obj_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
Z_DELREF(alfi.obj);
}
- if (!ZVAL_IS_UNDEF(&alfi.closure)) {
+ if (!Z_ISUNDEF(alfi.closure)) {
Z_DELREF(alfi.closure);
}
}
zend_hash_internal_pointer_reset_ex(SPL_G(autoload_functions), &function_pos);
while (zend_hash_has_more_elements_ex(SPL_G(autoload_functions), &function_pos) == SUCCESS) {
alfi = zend_hash_get_current_data_ptr_ex(SPL_G(autoload_functions), &function_pos);
- if (!ZVAL_IS_UNDEF(&alfi->closure)) {
+ if (!Z_ISUNDEF(alfi->closure)) {
Z_ADDREF(alfi->closure);
add_next_index_zval(return_value, &alfi->closure);
} else if (alfi->func_ptr->common.scope) {
zval tmp;
array_init(&tmp);
- if (!ZVAL_IS_UNDEF(&alfi->obj)) {
+ if (!Z_ISUNDEF(alfi->obj)) {
Z_ADDREF(alfi->obj);
add_next_index_zval(&tmp, &alfi->obj);
} else {
spl_array_object *intern = Z_SPLARRAY_P(object);
HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
- if (!offset || ZVAL_IS_UNDEF(offset)) {
+ if (!offset || Z_ISUNDEF_P(offset)) {
return &EG(uninitialized_zval);
}
}
zend_call_method_with_1_params(object, Z_OBJCE_P(object), &intern->fptr_offset_get, "offsetGet", &rv, offset);
zval_ptr_dtor(offset);
- if (!ZVAL_IS_UNDEF(&rv)) {
+ if (!Z_ISUNDEF(rv)) {
zval_ptr_dtor(&intern->retval);
ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
return &intern->retval;
zend_call_method_with_1_params(object, Z_OBJCE_P(object), &intern->fptr_offset_has, "offsetExists", &rv, offset);
zval_ptr_dtor(offset);
- if (!ZVAL_IS_UNDEF(&rv) && zend_is_true(&rv TSRMLS_CC)) {
+ if (!Z_ISUNDEF(rv) && zend_is_true(&rv TSRMLS_CC)) {
zval_ptr_dtor(&rv);
if (check_empty == 2) {
return 1;
spl_array_write_dimension(object, NULL, append_value TSRMLS_CC);
if (intern->pos == INVALID_IDX) {
- if (aht->nNumUsed && !ZVAL_IS_UNDEF(&aht->arData[aht->nNumUsed-1].val)) {
+ if (aht->nNumUsed && !Z_ISUNDEF(aht->arData[aht->nNumUsed-1].val)) {
spl_array_set_pos(intern, aht, aht->nNumUsed - 1);
}
}
efree(Z_ARR_P(Z_REFVAL(tmp)));
efree(Z_REF(tmp));
}
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
ZVAL_COPY_VALUE(return_value, &retval);
}
} /* }}} */
efree(intern->u.file.current_line);
intern->u.file.current_line = NULL;
}
- if (!ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
+ if (!Z_ISUNDEF(intern->u.file.current_zval)) {
zval_ptr_dtor(&intern->u.file.current_zval);
ZVAL_UNDEF(&intern->u.file.current_zval);
}
while (intern->u.dir.index < pos) {
int valid = 0;
zend_call_method_with_0_params(&EG(This), Z_OBJCE(EG(This)), &intern->u.dir.func_valid, "valid", &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
valid = zend_is_true(&retval TSRMLS_CC);
zval_ptr_dtor(&retval);
}
{
spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
- if (!ZVAL_IS_UNDEF(&iterator->intern.data)) {
+ if (!Z_ISUNDEF(iterator->intern.data)) {
zval *object = &iterator->intern.data;
zval_ptr_dtor(object);
}
{
spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
- if (!ZVAL_IS_UNDEF(&iterator->intern.data)) {
+ if (!Z_ISUNDEF(iterator->intern.data)) {
zval *object = &iterator->intern.data;
zval_ptr_dtor(object);
} else {
- if (!ZVAL_IS_UNDEF(&iterator->current)) {
+ if (!Z_ISUNDEF(iterator->current)) {
zval_ptr_dtor(&iterator->current);
ZVAL_UNDEF(&iterator->current);
}
spl_filesystem_object *object = spl_filesystem_iterator_to_object(iterator TSRMLS_CC);
if (SPL_FILE_DIR_CURRENT(object, SPL_FILE_DIR_CURRENT_AS_PATHNAME)) {
- if (ZVAL_IS_UNDEF(&iterator->current)) {
+ if (Z_ISUNDEF(iterator->current)) {
spl_filesystem_object_get_file_name(object TSRMLS_CC);
ZVAL_STRINGL(&iterator->current, object->file_name, object->file_name_len);
}
return &iterator->current;
} else if (SPL_FILE_DIR_CURRENT(object, SPL_FILE_DIR_CURRENT_AS_FILEINFO)) {
- if (ZVAL_IS_UNDEF(&iterator->current)) {
+ if (Z_ISUNDEF(iterator->current)) {
spl_filesystem_object_get_file_name(object TSRMLS_CC);
spl_filesystem_object_create_type(0, object, SPL_FS_INFO, NULL, &iterator->current TSRMLS_CC);
}
efree(object->file_name);
object->file_name = NULL;
}
- if (!ZVAL_IS_UNDEF(&iterator->current)) {
+ if (!Z_ISUNDEF(iterator->current)) {
zval_ptr_dtor(&iterator->current);
ZVAL_UNDEF(&iterator->current);
}
do {
spl_filesystem_dir_read(object TSRMLS_CC);
} while (spl_filesystem_is_dot(object->u.dir.entry.d_name));
- if (!ZVAL_IS_UNDEF(&iterator->current)) {
+ if (!Z_ISUNDEF(iterator->current)) {
zval_ptr_dtor(&iterator->current);
ZVAL_UNDEF(&iterator->current);
}
{
char *buf;
size_t line_len = 0;
- long line_add = (intern->u.file.current_line || !ZVAL_IS_UNDEF(&intern->u.file.current_zval)) ? 1 : 0;
+ long line_add = (intern->u.file.current_line || !Z_ISUNDEF(intern->u.file.current_zval)) ? 1 : 0;
spl_filesystem_file_free_line(intern TSRMLS_CC);
result = zend_call_function(&fci, &fcic TSRMLS_CC);
- if (result == FAILURE || ZVAL_IS_UNDEF(&retval)) {
+ if (result == FAILURE || Z_ISUNDEF(retval)) {
RETVAL_FALSE;
} else {
ZVAL_ZVAL(return_value, &retval, 0, 0);
size_t buf_len = intern->u.file.current_line_len;
char *buf = estrndup(intern->u.file.current_line, buf_len);
- if (!ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
+ if (!Z_ISUNDEF(intern->u.file.current_zval)) {
zval_ptr_dtor(&intern->u.file.current_zval);
ZVAL_UNDEF(&intern->u.file.current_zval);
}
} else {
zend_call_method_with_0_params(this_ptr, Z_OBJCE_P(getThis()), &intern->u.file.func_getCurr, "getCurrentLine", &retval);
}
- if (!ZVAL_IS_UNDEF(&retval)) {
- if (intern->u.file.current_line || !ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
+ if (!Z_ISUNDEF(retval)) {
+ if (intern->u.file.current_line || !Z_ISUNDEF(intern->u.file.current_zval)) {
intern->u.file.current_line_num++;
}
spl_filesystem_file_free_line(intern TSRMLS_CC);
{
if (intern->u.file.current_line) {
return intern->u.file.current_line_len == 0;
- } else if (!ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
+ } else if (!Z_ISUNDEF(intern->u.file.current_zval)) {
switch(Z_TYPE(intern->u.file.current_zval)) {
case IS_STRING:
return Z_STRLEN(intern->u.file.current_zval) == 0;
uint idx = 0;
zval *first;
- while (ZVAL_IS_UNDEF(&Z_ARRVAL(intern->u.file.current_zval)->arData[idx].val)) {
+ while (Z_ISUNDEF(Z_ARRVAL(intern->u.file.current_zval)->arData[idx].val)) {
idx++;
}
first = &Z_ARRVAL(intern->u.file.current_zval)->arData[idx].val;
}
if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_AHEAD)) {
- RETURN_BOOL(intern->u.file.current_line || !ZVAL_IS_UNDEF(&intern->u.file.current_zval));
+ RETURN_BOOL(intern->u.file.current_line || !Z_ISUNDEF(intern->u.file.current_zval));
} else {
RETVAL_BOOL(!php_stream_eof(intern->u.file.stream));
}
return;
}
- if (!intern->u.file.current_line && ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
+ if (!intern->u.file.current_line && Z_ISUNDEF(intern->u.file.current_zval)) {
spl_filesystem_file_read_line(getThis(), intern, 1 TSRMLS_CC);
}
- if (intern->u.file.current_line && (!SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV) || ZVAL_IS_UNDEF(&intern->u.file.current_zval))) {
+ if (intern->u.file.current_line && (!SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV) || Z_ISUNDEF(intern->u.file.current_zval))) {
RETURN_STRINGL(intern->u.file.current_line, intern->u.file.current_line_len);
- } else if (!ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
+ } else if (!Z_ISUNDEF(intern->u.file.current_zval)) {
RETURN_ZVAL(&intern->u.file.current_zval, 1, 0);
}
RETURN_FALSE;
/* {{{ spl_ptr_llist */
static void spl_ptr_llist_zval_dtor(spl_ptr_llist_element *elem TSRMLS_DC) { /* {{{ */
- if (!ZVAL_IS_UNDEF(&elem->data)) {
+ if (!Z_ISUNDEF(elem->data)) {
zval_ptr_dtor(&elem->data);
ZVAL_UNDEF(&elem->data);
}
if (intern->fptr_count) {
zval rv;
zend_call_method_with_0_params(object, intern->std.ce, &intern->fptr_count, "count", &rv);
- if (!ZVAL_IS_UNDEF(&rv)) {
+ if (!Z_ISUNDEF(rv)) {
zval_ptr_dtor(&intern->retval);
ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
convert_to_long(&intern->retval);
intern = Z_SPLDLLIST_P(getThis());
spl_ptr_llist_pop(intern->llist, return_value TSRMLS_CC);
- if (ZVAL_IS_UNDEF(return_value)) {
+ if (Z_ISUNDEF_P(return_value)) {
zend_throw_exception(spl_ce_RuntimeException, "Can't pop from an empty datastructure", 0 TSRMLS_CC);
RETURN_NULL();
}
intern = Z_SPLDLLIST_P(getThis());
spl_ptr_llist_shift(intern->llist, return_value TSRMLS_CC);
- if (ZVAL_IS_UNDEF(return_value)) {
+ if (Z_ISUNDEF_P(return_value)) {
zend_throw_exception(spl_ce_RuntimeException, "Can't shift from an empty datastructure", 0 TSRMLS_CC);
RETURN_NULL();
}
intern = Z_SPLDLLIST_P(getThis());
value = spl_ptr_llist_last(intern->llist);
- if (value == NULL || ZVAL_IS_UNDEF(value)) {
+ if (value == NULL || Z_ISUNDEF_P(value)) {
zend_throw_exception(spl_ce_RuntimeException, "Can't peek at an empty datastructure", 0 TSRMLS_CC);
return;
}
intern = Z_SPLDLLIST_P(getThis());
value = spl_ptr_llist_first(intern->llist);
- if (value == NULL || ZVAL_IS_UNDEF(value)) {
+ if (value == NULL || Z_ISUNDEF_P(value)) {
zend_throw_exception(spl_ce_RuntimeException, "Can't peek at an empty datastructure", 0 TSRMLS_CC);
return;
}
spl_dllist_it *iterator = (spl_dllist_it *)iter;
spl_ptr_llist_element *element = iterator->traverse_pointer;
- if (element == NULL || ZVAL_IS_UNDEF(&element->data)) {
+ if (element == NULL || Z_ISUNDEF(element->data)) {
return NULL;
}
return;
}
- if (element == NULL || ZVAL_IS_UNDEF(&element->data)) {
+ if (element == NULL || Z_ISUNDEF(element->data)) {
RETURN_NULL();
} else {
RETURN_ZVAL(&element->data, 1, 0);
int j = zend_hash_num_elements(ht);
for (i = 0; i < intern->array->size; i++) {
- if (!ZVAL_IS_UNDEF(&intern->array->elements[i])) {
+ if (!Z_ISUNDEF(intern->array->elements[i])) {
zend_hash_index_update(ht, i, &intern->array->elements[i]);
if (Z_REFCOUNTED(intern->array->elements[i])){
Z_ADDREF(intern->array->elements[i]);
if (index < 0 || intern->array == NULL || index >= intern->array->size) {
zend_throw_exception(spl_ce_RuntimeException, "Index invalid or out of range", 0 TSRMLS_CC);
return NULL;
- } else if (ZVAL_IS_UNDEF(&intern->array->elements[index])) {
+ } else if (Z_ISUNDEF(intern->array->elements[index])) {
return NULL;
} else {
return &intern->array->elements[index];
}
zend_call_method_with_1_params(object, intern->std.ce, &intern->fptr_offset_get, "offsetGet", &rv, offset);
zval_ptr_dtor(offset);
- if (!ZVAL_IS_UNDEF(&rv)) {
+ if (!Z_ISUNDEF(rv)) {
zval_ptr_dtor(&intern->retval);
ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
return &intern->retval;
zend_throw_exception(spl_ce_RuntimeException, "Index invalid or out of range", 0 TSRMLS_CC);
return;
} else {
- if (!ZVAL_IS_UNDEF(&intern->array->elements[index])) {
+ if (!Z_ISUNDEF(intern->array->elements[index])) {
zval_ptr_dtor(&(intern->array->elements[index]));
}
SEPARATE_ARG_IF_REF(value);
if (index < 0 || intern->array == NULL || index >= intern->array->size) {
retval = 0;
} else {
- if (ZVAL_IS_UNDEF(&intern->array->elements[index])) {
+ if (Z_ISUNDEF(intern->array->elements[index])) {
retval = 0;
} else if (check_empty) {
if (zend_is_true(&intern->array->elements[index] TSRMLS_CC)) {
SEPARATE_ARG_IF_REF(offset);
zend_call_method_with_1_params(object, intern->std.ce, &intern->fptr_offset_has, "offsetExists", &rv, offset);
zval_ptr_dtor(offset);
- if (!ZVAL_IS_UNDEF(&rv)) {
+ if (!Z_ISUNDEF(rv)) {
zval_ptr_dtor(&intern->retval);
ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
return zend_is_true(&intern->retval TSRMLS_CC);
if (intern->fptr_count) {
zval rv;
zend_call_method_with_0_params(object, intern->std.ce, &intern->fptr_count, "count", &rv);
- if (!ZVAL_IS_UNDEF(&rv)) {
+ if (!Z_ISUNDEF(rv)) {
zval_ptr_dtor(&intern->retval);
ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
convert_to_long(&intern->retval);
if (intern->array) {
int i = 0;
for (; i < intern->array->size; i++) {
- if (!ZVAL_IS_UNDEF(&intern->array->elements[i])) {
+ if (!Z_ISUNDEF(intern->array->elements[i])) {
zend_hash_index_update(Z_ARRVAL_P(return_value), i, &intern->array->elements[i]);
if (Z_REFCOUNTED(intern->array->elements[i])) {
Z_ADDREF(intern->array->elements[i]);
#define Z_SPLHEAP_P(zv) spl_heap_from_obj(Z_OBJ_P((zv)))
static void spl_ptr_heap_zval_dtor(zval *elem TSRMLS_DC) { /* {{{ */
- if (!ZVAL_IS_UNDEF(elem)) {
+ if (!Z_ISUNDEF_P(elem)) {
zval_ptr_dtor(elem);
}
}
return NULL;
}
- return ZVAL_IS_UNDEF(&heap->elements[0])? NULL : &heap->elements[0];
+ return Z_ISUNDEF(heap->elements[0])? NULL : &heap->elements[0];
}
/* }}} */
zend_object_std_dtor(&intern->std TSRMLS_CC);
for (i = 0; i < intern->heap->count; ++i) {
- if (!ZVAL_IS_UNDEF(&intern->heap->elements[i])) {
+ if (!Z_ISUNDEF(intern->heap->elements[i])) {
zval_ptr_dtor(&intern->heap->elements[i]);
}
}
if (intern->fptr_count) {
zval rv;
zend_call_method_with_0_params(object, intern->std.ce, &intern->fptr_count, "count", &rv);
- if (!ZVAL_IS_UNDEF(&rv)) {
+ if (!Z_ISUNDEF(rv)) {
zval_ptr_dtor(&intern->retval);
ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
convert_to_long(&intern->retval);
spl_ptr_heap_delete_top(intern->heap, &value, getThis() TSRMLS_CC);
- if (ZVAL_IS_UNDEF(&value)) {
+ if (Z_ISUNDEF(value)) {
zend_throw_exception(spl_ce_RuntimeException, "Can't extract from an empty heap", 0 TSRMLS_CC);
return;
}
spl_ptr_heap_delete_top(intern->heap, &value, getThis() TSRMLS_CC);
- if (ZVAL_IS_UNDEF(&value)) {
+ if (Z_ISUNDEF(value)) {
zend_throw_exception(spl_ce_RuntimeException, "Can't extract from an empty heap", 0 TSRMLS_CC);
return;
}
return NULL;
}
- if (object->heap->count == 0 || ZVAL_IS_UNDEF(element)) {
+ if (object->heap->count == 0 || Z_ISUNDEF_P(element)) {
return NULL;
} else {
return element;
return NULL;
}
- if (object->heap->count == 0 || ZVAL_IS_UNDEF(element)) {
+ if (object->heap->count == 0 || Z_ISUNDEF_P(element)) {
return NULL;
} else {
zval *data = spl_pqueue_extract_helper(element, object->flags);
return;
}
- if (!intern->heap->count || ZVAL_IS_UNDEF(element)) {
+ if (!intern->heap->count || Z_ISUNDEF_P(element)) {
RETURN_NULL();
} else {
RETURN_ZVAL(element, 1, 0);
return;
}
- if (!intern->heap->count || ZVAL_IS_UNDEF(element)) {
+ if (!intern->heap->count || Z_ISUNDEF_P(element)) {
RETURN_NULL();
} else {
zval *data = spl_pqueue_extract_helper(element, intern->flags);
SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
- if (!ZVAL_IS_UNDEF(&intern->inner.zobject)) {
+ if (!Z_ISUNDEF(intern->inner.zobject)) {
RETVAL_ZVAL(&intern->inner.zobject, 1, 0);
} else {
RETURN_NULL();
if (use_copy) {
efree(subject);
}
- if (!ZVAL_IS_UNDEF(&subject_copy)) {
+ if (!Z_ISUNDEF(subject_copy)) {
zval_ptr_dtor(&subject_copy);
}
} /* }}} */
spl_dual_it_object *object = spl_dual_it_from_obj(_object);
- if (!ZVAL_IS_UNDEF(&object->inner.zobject)) {
+ if (!Z_ISUNDEF(object->inner.zobject)) {
zval_ptr_dtor(&object->inner.zobject);
}
{
spl_dual_it_free(intern TSRMLS_CC);
- if (!ZVAL_IS_UNDEF(&intern->inner.zobject)) {
+ if (!Z_ISUNDEF(intern->inner.zobject)) {
zval_ptr_dtor(&intern->inner.zobject);
ZVAL_UNDEF(&intern->inner.zobject);
intern->inner.ce = NULL;
if (intern->fptr_get_hash) {
zval rv;
zend_call_method_with_1_params(this, intern->std.ce, &intern->fptr_get_hash, "getHash", &rv, obj);
- if (!ZVAL_IS_UNDEF(&rv)) {
+ if (!Z_ISUNDEF(rv)) {
if (Z_TYPE(rv) == IS_STRING) {
return Z_STR(rv);
} else {
pelement = spl_object_storage_get(intern, hash TSRMLS_CC);
spl_object_storage_free_hash(intern, hash);
if (pelement) {
- if (!ZVAL_IS_UNDEF(&pelement->inf)) {
+ if (!Z_ISUNDEF(pelement->inf)) {
var_push_dtor(&var_hash, &pelement->inf);
}
- if (!ZVAL_IS_UNDEF(&pelement->obj)) {
+ if (!Z_ISUNDEF(pelement->obj)) {
var_push_dtor(&var_hash, &pelement->obj);
}
}
it = &element->obj;
zend_call_method_with_0_params(it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_valid, "valid", &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
valid = (Z_TYPE(retval) == IS_TRUE);
zval_ptr_dtor(&retval);
} else {
it = &element->obj;
zend_call_method_with_0_params(it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_valid, "valid", &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
valid = Z_TYPE(retval) == IS_TRUE;
zval_ptr_dtor(&retval);
} else {
} else {
zend_call_method_with_0_params(it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_key, "key", &retval);
}
- if (ZVAL_IS_UNDEF(&retval)) {
+ if (Z_ISUNDEF(retval)) {
zend_throw_exception(spl_ce_RuntimeException, "Failed to call sub iterator method", 0 TSRMLS_CC);
return;
}
/* summon the aggregation context */
agg_context = (php_sqlite3_agg_context *)sqlite3_aggregate_context(context, sizeof(php_sqlite3_agg_context));
- if (ZVAL_IS_UNDEF(&agg_context->zval_context)) {
+ if (Z_ISUNDEF(agg_context->zval_context)) {
ZVAL_NULL(&agg_context->zval_context);
}
ZVAL_COPY_VALUE(&zargs[0], &agg_context->zval_context);
if (!is_agg || !argv) {
/* only set the sqlite return value if we are a scalar function,
* or if we are finalizing an aggregate */
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
switch (Z_TYPE(retval)) {
case IS_LONG:
#if LONG_MAX > 2147483647
sqlite3_result_error(context, "failed to invoke callback", 0);
}
- if (agg_context && !ZVAL_IS_UNDEF(&agg_context->zval_context)) {
+ if (agg_context && !Z_ISUNDEF(agg_context->zval_context)) {
zval_ptr_dtor(&agg_context->zval_context);
}
} else {
/* we're stepping in an aggregate; the return value goes into
* the context */
- if (agg_context && !ZVAL_IS_UNDEF(&agg_context->zval_context)) {
+ if (agg_context && !Z_ISUNDEF(agg_context->zval_context)) {
zval_ptr_dtor(&agg_context->zval_context);
}
ZVAL_COPY_VALUE(&agg_context->zval_context, &retval);
ZVAL_UNDEF(&retval);
}
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
return ret;
ZVAL_COPY(¶m.parameter, parameter);
if (!register_bound_parameter_to_sqlite(¶m, stmt_obj TSRMLS_CC)) {
- if (!ZVAL_IS_UNDEF(¶m.parameter)) {
+ if (!Z_ISUNDEF(param.parameter)) {
zval_ptr_dtor(&(param.parameter));
ZVAL_UNDEF(¶m.parameter);
}
ZVAL_COPY(¶m.parameter, parameter);
if (!register_bound_parameter_to_sqlite(¶m, stmt_obj TSRMLS_CC)) {
- if (!ZVAL_IS_UNDEF(¶m.parameter)) {
+ if (!Z_ISUNDEF(param.parameter)) {
zval_ptr_dtor(&(param.parameter));
ZVAL_UNDEF(¶m.parameter);
}
efree((char*)func->func_name);
- if (!ZVAL_IS_UNDEF(&func->func)) {
+ if (!Z_ISUNDEF(func->func)) {
zval_ptr_dtor(&func->func);
}
- if (!ZVAL_IS_UNDEF(&func->step)) {
+ if (!Z_ISUNDEF(func->step)) {
zval_ptr_dtor(&func->step);
}
- if (!ZVAL_IS_UNDEF(&func->fini)) {
+ if (!Z_ISUNDEF(func->fini)) {
zval_ptr_dtor(&func->fini);
}
efree(func);
sqlite3_create_collation(intern->db, collation->collation_name, SQLITE_UTF8, NULL, NULL);
}
efree((char*)collation->collation_name);
- if (!ZVAL_IS_UNDEF(&collation->cmp_func)) {
+ if (!Z_ISUNDEF(collation->cmp_func)) {
zval_ptr_dtor(&collation->cmp_func);
}
efree(collation);
(int (*)(void *, void *)) php_sqlite3_compare_stmt_free);
}
- if (!ZVAL_IS_UNDEF(&intern->db_obj_zval)) {
+ if (!Z_ISUNDEF(intern->db_obj_zval)) {
zval_ptr_dtor(&intern->db_obj_zval);
}
return;
}
- if (!ZVAL_IS_NULL(&intern->stmt_obj_zval)) {
+ if (!Z_ISNULL(intern->stmt_obj_zval)) {
if (intern->stmt_obj->initialised) {
sqlite3_reset(intern->stmt_obj->stmt);
}
STR_RELEASE(param->name);
}
- if (!ZVAL_IS_NULL(¶m->parameter)) {
+ if (!Z_ISNULL(param->parameter)) {
zval_ptr_dtor(&(param->parameter));
ZVAL_UNDEF(¶m->parameter);
}
if (use_type == ARRAY_FILTER_USE_BOTH) {
zval_ptr_dtor(&args[1]);
}
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
int retval_true = zend_is_true(&retval TSRMLS_CC);
zval_ptr_dtor(&retval);
array_init(return_value);
- if (!ZVAL_IS_UNDEF(&stream->wrapperdata)) {
+ if (!Z_ISUNDEF(stream->wrapperdata)) {
Z_ADDREF_P(&stream->wrapperdata);
add_assoc_zval(return_value, "wrapper_data", &stream->wrapperdata);
}
efree(parser->ltags[ inx ]);
efree(parser->ltags);
}
- if (!ZVAL_IS_UNDEF(&parser->startElementHandler)) {
+ if (!Z_ISUNDEF(parser->startElementHandler)) {
zval_ptr_dtor(&parser->startElementHandler);
}
- if (!ZVAL_IS_UNDEF(&parser->endElementHandler)) {
+ if (!Z_ISUNDEF(parser->endElementHandler)) {
zval_ptr_dtor(&parser->endElementHandler);
}
- if (!ZVAL_IS_UNDEF(&parser->characterDataHandler)) {
+ if (!Z_ISUNDEF(parser->characterDataHandler)) {
zval_ptr_dtor(&parser->characterDataHandler);
}
- if (!ZVAL_IS_UNDEF(&parser->processingInstructionHandler)) {
+ if (!Z_ISUNDEF(parser->processingInstructionHandler)) {
zval_ptr_dtor(&parser->processingInstructionHandler);
}
- if (!ZVAL_IS_UNDEF(&parser->defaultHandler)) {
+ if (!Z_ISUNDEF(parser->defaultHandler)) {
zval_ptr_dtor(&parser->defaultHandler);
}
- if (!ZVAL_IS_UNDEF(&parser->unparsedEntityDeclHandler)) {
+ if (!Z_ISUNDEF(parser->unparsedEntityDeclHandler)) {
zval_ptr_dtor(&parser->unparsedEntityDeclHandler);
}
- if (!ZVAL_IS_UNDEF(&parser->notationDeclHandler)) {
+ if (!Z_ISUNDEF(parser->notationDeclHandler)) {
zval_ptr_dtor(&parser->notationDeclHandler);
}
- if (!ZVAL_IS_UNDEF(&parser->externalEntityRefHandler)) {
+ if (!Z_ISUNDEF(parser->externalEntityRefHandler)) {
zval_ptr_dtor(&parser->externalEntityRefHandler);
}
- if (!ZVAL_IS_UNDEF(&parser->unknownEncodingHandler)) {
+ if (!Z_ISUNDEF(parser->unknownEncodingHandler)) {
zval_ptr_dtor(&parser->unknownEncodingHandler);
}
- if (!ZVAL_IS_UNDEF(&parser->startNamespaceDeclHandler)) {
+ if (!Z_ISUNDEF(parser->startNamespaceDeclHandler)) {
zval_ptr_dtor(&parser->startNamespaceDeclHandler);
}
- if (!ZVAL_IS_UNDEF(&parser->endNamespaceDeclHandler)) {
+ if (!Z_ISUNDEF(parser->endNamespaceDeclHandler)) {
zval_ptr_dtor(&parser->endNamespaceDeclHandler);
}
if (parser->baseURI) {
efree(parser->baseURI);
}
- if (!ZVAL_IS_UNDEF(&parser->object)) {
+ if (!Z_ISUNDEF(parser->object)) {
zval_ptr_dtor(&parser->object);
}
{
zval *element;
- if (ZVAL_IS_UNDEF(&parser->info)) {
+ if (Z_ISUNDEF(parser->info)) {
return;
}
tag_name = _xml_decode_tag(parser, (const char *)name);
- if (!ZVAL_IS_UNDEF(&parser->startElementHandler)) {
+ if (!Z_ISUNDEF(parser->startElementHandler)) {
ZVAL_COPY(&args[0], &parser->index);
ZVAL_STRING(&args[1], tag_name->val + parser->toffset);
array_init(&args[2]);
}
xml_call_handler(parser, &parser->startElementHandler, parser->startElementPtr, 3, args, &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
}
- if (!ZVAL_IS_UNDEF(&parser->data)) {
+ if (!Z_ISUNDEF(parser->data)) {
if (parser->level <= XML_MAXLEVEL) {
zval tag, atr;
int atcnt = 0;
tag_name = _xml_decode_tag(parser, (const char *)name);
- if (!ZVAL_IS_UNDEF(&parser->endElementHandler)) {
+ if (!Z_ISUNDEF(parser->endElementHandler)) {
ZVAL_COPY(&args[0], &parser->index);
ZVAL_STRING(&args[1], (tag_name->val) + parser->toffset);
xml_call_handler(parser, &parser->endElementHandler, parser->endElementPtr, 2, args, &retval);
- if (ZVAL_IS_UNDEF(&retval)) {
+ if (Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
}
- if (!ZVAL_IS_UNDEF(&parser->data)) {
+ if (!Z_ISUNDEF(parser->data)) {
zval tag;
if (parser->lastwasopen) {
if (parser) {
zval retval, args[2];
- if (!ZVAL_IS_UNDEF(&parser->characterDataHandler)) {
+ if (!Z_ISUNDEF(parser->characterDataHandler)) {
ZVAL_COPY(&args[0], &parser->index);
_xml_xmlchar_zval(s, len, parser->target_encoding, &args[1]);
xml_call_handler(parser, &parser->characterDataHandler, parser->characterDataPtr, 2, args, &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
}
- if (!ZVAL_IS_UNDEF(&parser->data)) {
+ if (!Z_ISUNDEF(parser->data)) {
int i;
int doprint = 0;
zend_string *decoded_value;
{
xml_parser *parser = (xml_parser *)userData;
- if (parser && !ZVAL_IS_UNDEF(&parser->processingInstructionHandler)) {
+ if (parser && !Z_ISUNDEF(parser->processingInstructionHandler)) {
zval retval, args[3];
ZVAL_COPY(&args[0], &parser->index);
_xml_xmlchar_zval(target, 0, parser->target_encoding, &args[1]);
_xml_xmlchar_zval(data, 0, parser->target_encoding, &args[2]);
xml_call_handler(parser, &parser->processingInstructionHandler, parser->processingInstructionPtr, 3, args, &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
}
{
xml_parser *parser = (xml_parser *)userData;
- if (parser && !ZVAL_IS_UNDEF(&parser->defaultHandler)) {
+ if (parser && !Z_ISUNDEF(parser->defaultHandler)) {
zval retval, args[2];
ZVAL_COPY(&args[0], &parser->index);
_xml_xmlchar_zval(s, len, parser->target_encoding, &args[1]);
xml_call_handler(parser, &parser->defaultHandler, parser->defaultPtr, 2, args, &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
}
{
xml_parser *parser = (xml_parser *)userData;
- if (parser && !ZVAL_IS_UNDEF(&parser->unparsedEntityDeclHandler)) {
+ if (parser && !Z_ISUNDEF(parser->unparsedEntityDeclHandler)) {
zval retval, args[6];
ZVAL_COPY(&args[0], &parser->index);
_xml_xmlchar_zval(publicId, 0, parser->target_encoding, &args[4]);
_xml_xmlchar_zval(notationName, 0, parser->target_encoding, &args[5]);
xml_call_handler(parser, &parser->unparsedEntityDeclHandler, parser->unparsedEntityDeclPtr, 6, args, &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
}
{
xml_parser *parser = (xml_parser *)userData;
- if (parser && !ZVAL_IS_UNDEF(&parser->notationDeclHandler)) {
+ if (parser && !Z_ISUNDEF(parser->notationDeclHandler)) {
zval retval, args[5];
ZVAL_COPY(&args[0], &parser->index);
_xml_xmlchar_zval(systemId, 0, parser->target_encoding, &args[3]);
_xml_xmlchar_zval(publicId, 0, parser->target_encoding, &args[4]);
xml_call_handler(parser, &parser->notationDeclHandler, parser->notationDeclPtr, 5, args, &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
}
xml_parser *parser = XML_GetUserData(parserPtr);
int ret = 0; /* abort if no handler is set (should be configurable?) */
- if (parser && !ZVAL_IS_UNDEF(&parser->externalEntityRefHandler)) {
+ if (parser && !Z_ISUNDEF(parser->externalEntityRefHandler)) {
zval retval, args[5];
ZVAL_COPY(&args[0], &parser->index);
_xml_xmlchar_zval(systemId, 0, parser->target_encoding, &args[3]);
_xml_xmlchar_zval(publicId, 0, parser->target_encoding, &args[4]);
xml_call_handler(parser, &parser->externalEntityRefHandler, parser->externalEntityRefPtr, 5, args, &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
convert_to_long(&retval);
ret = Z_LVAL(retval);
} else {
{
xml_parser *parser = (xml_parser *)userData;
- if (parser && !ZVAL_IS_UNDEF(&parser->startNamespaceDeclHandler)) {
+ if (parser && !Z_ISUNDEF(parser->startNamespaceDeclHandler)) {
zval retval, args[3];
ZVAL_COPY(&args[0], &parser->index);
_xml_xmlchar_zval(prefix, 0, parser->target_encoding, &args[1]);
_xml_xmlchar_zval(uri, 0, parser->target_encoding, &args[2]);
xml_call_handler(parser, &parser->startNamespaceDeclHandler, parser->startNamespaceDeclPtr, 3, args, &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
}
{
xml_parser *parser = (xml_parser *)userData;
- if (parser && !ZVAL_IS_UNDEF(&parser->endNamespaceDeclHandler)) {
+ if (parser && !Z_ISUNDEF(parser->endNamespaceDeclHandler)) {
zval retval, args[2];
ZVAL_COPY(&args[0], &parser->index);
_xml_xmlchar_zval(prefix, 0, parser->target_encoding, &args[1]);
xml_call_handler(parser, &parser->endNamespaceDeclHandler, parser->endNamespaceDeclPtr, 2, args, &retval);
- if (!ZVAL_IS_UNDEF(&retval)) {
+ if (!Z_ISUNDEF(retval)) {
zval_ptr_dtor(&retval);
}
}
ZEND_FETCH_RESOURCE(parser,xml_parser *, pind, -1, "XML Parser", le_xml_parser);
/* please leave this commented - or ask thies@thieso.net before doing it (again) */
- if (!ZVAL_IS_UNDEF(&parser->object)) {
+ if (!Z_ISUNDEF(parser->object)) {
zval_ptr_dtor(&parser->object);
}
ZVAL_STRING(&zfuncname, USERSTREAM_OPEN);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&zfuncname,
&zretval,
4, args,
ZVAL_STRING(&zfuncname, USERSTREAM_DIR_OPEN);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&zfuncname,
&zretval,
2, args,
ZVAL_STRINGL(&args[0], (char*)buf, count);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
1, args,
ZVAL_LONG(&args[0], count);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
1, args,
ZVAL_STRINGL(&func_name, USERSTREAM_EOF, sizeof(USERSTREAM_EOF)-1);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
0, NULL, 0, NULL TSRMLS_CC);
ZVAL_STRINGL(&func_name, USERSTREAM_CLOSE, sizeof(USERSTREAM_CLOSE)-1);
call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
0, NULL, 0, NULL TSRMLS_CC);
ZVAL_STRINGL(&func_name, USERSTREAM_FLUSH, sizeof(USERSTREAM_FLUSH)-1);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
0, NULL, 0, NULL TSRMLS_CC);
ZVAL_LONG(&args[1], whence);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
2, args,
ZVAL_STRINGL(&func_name, USERSTREAM_TELL, sizeof(USERSTREAM_TELL)-1);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
0, NULL, 0, NULL TSRMLS_CC);
ZVAL_STRINGL(&func_name, USERSTREAM_STAT, sizeof(USERSTREAM_STAT)-1);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
0, NULL, 0, NULL TSRMLS_CC);
switch (option) {
case PHP_STREAM_OPTION_CHECK_LIVENESS:
ZVAL_STRINGL(&func_name, USERSTREAM_EOF, sizeof(USERSTREAM_EOF)-1);
- call_result = call_user_function_ex(NULL, ZVAL_IS_UNDEF(&us->object)? NULL : &us->object, &func_name, &retval, 0, NULL, 0, NULL TSRMLS_CC);
+ call_result = call_user_function_ex(NULL, Z_ISUNDEF(us->object)? NULL : &us->object, &func_name, &retval, 0, NULL, 0, NULL TSRMLS_CC);
if (call_result == SUCCESS && (Z_TYPE(retval) == IS_FALSE || Z_TYPE(retval) == IS_TRUE)) {
ret = zval_is_true(&retval) ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
} else {
ZVAL_STRINGL(&func_name, USERSTREAM_LOCK, sizeof(USERSTREAM_LOCK)-1);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
1, args, 0, NULL TSRMLS_CC);
switch (value) {
case PHP_STREAM_TRUNCATE_SUPPORTED:
if (zend_is_callable_ex(&func_name,
- ZVAL_IS_UNDEF(&us->object)? NULL : Z_OBJ(us->object),
+ Z_ISUNDEF(us->object)? NULL : Z_OBJ(us->object),
IS_CALLABLE_CHECK_SILENT, NULL, NULL, NULL TSRMLS_CC))
ret = PHP_STREAM_OPTION_RETURN_OK;
else
if (new_size >= 0 && new_size <= (ptrdiff_t)LONG_MAX) {
ZVAL_LONG(&args[0], (long)new_size);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
1, args, 0, NULL TSRMLS_CC);
}
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
3, args, 0, NULL TSRMLS_CC);
ZVAL_STRINGL(&func_name, USERSTREAM_DIR_READ, sizeof(USERSTREAM_DIR_READ)-1);
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
0, NULL,
ZVAL_STRINGL(&func_name, USERSTREAM_DIR_CLOSE, sizeof(USERSTREAM_DIR_CLOSE)-1);
call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
0, NULL, 0, NULL TSRMLS_CC);
ZVAL_STRINGL(&func_name, USERSTREAM_DIR_REWIND, sizeof(USERSTREAM_DIR_REWIND)-1);
call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
0, NULL, 0, NULL TSRMLS_CC);
}
call_result = call_user_function_ex(NULL,
- ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+ Z_ISUNDEF(us->object)? NULL : &us->object,
&func_name,
&retval,
1, args, 0, NULL TSRMLS_CC);
us->wrapper->classname);
break;
}
- if (ZVAL_IS_UNDEF(&retval) || !zend_is_true(&retval TSRMLS_CC)) {
+ if (Z_ISUNDEF(retval) || !zend_is_true(&retval TSRMLS_CC)) {
break;
}
php_stream_from_zval_no_verify(intstream, &retval);
projects / php / commitdiff