{
void **p;
int arg_count;
- zval **z_requested_offset;
zval *arg;
long requested_offset;
zend_execute_data *ex = EG(current_execute_data)->prev_execute_data;
- if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &z_requested_offset)==FAILURE) {
- RETURN_FALSE;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &requested_offset) == FAILURE) {
+ return;
}
- convert_to_long_ex(z_requested_offset);
- requested_offset = Z_LVAL_PP(z_requested_offset);
if (requested_offset < 0) {
zend_error(E_WARNING, "func_get_arg(): The argument number should be >= 0");
Get string length */
ZEND_NAMED_FUNCTION(zend_if_strlen)
{
- zval **str;
+ char *s1;
+ int s1_len;
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &str) == FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &s1, &s1_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(str);
- RETVAL_LONG(Z_STRLEN_PP(str));
+
+ RETVAL_LONG(s1_len);
}
/* }}} */
Binary safe string comparison */
ZEND_FUNCTION(strcmp)
{
- zval **s1, **s2;
+ char *s1, *s2;
+ int s1_len, s2_len;
- if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &s1, &s2) == FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1_len, &s2, &s2_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(s1);
- convert_to_string_ex(s2);
- RETURN_LONG(zend_binary_zval_strcmp(*s1, *s2));
+
+ RETURN_LONG(zend_binary_strcmp(s1, s1_len, s2, s2_len));
}
/* }}} */
Binary safe string comparison */
ZEND_FUNCTION(strncmp)
{
- zval **s1, **s2, **s3;
-
- if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &s1, &s2, &s3) == FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ char *s1, *s2;
+ int s1_len, s2_len;
+ long len;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl", &s1, &s1_len, &s2, &s2_len, &len) == FAILURE) {
+ return;
}
- convert_to_string_ex(s1);
- convert_to_string_ex(s2);
- convert_to_long_ex(s3);
- if (Z_LVAL_PP(s3) < 0) {
+ if (len < 0) {
zend_error(E_WARNING, "Length must be greater than or equal to 0");
RETURN_FALSE;
}
-
- RETURN_LONG(zend_binary_zval_strncmp(*s1, *s2, *s3));
+
+ RETURN_LONG(zend_binary_strncmp(s1, s1_len, s2, s2_len, len));
}
/* }}} */
Binary safe case-insensitive string comparison */
ZEND_FUNCTION(strcasecmp)
{
- zval **s1, **s2;
+ char *s1, *s2;
+ int s1_len, s2_len;
- if (ZEND_NUM_ARGS()!=2 || zend_get_parameters_ex(2, &s1, &s2) == FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &s1, &s1_len, &s2, &s2_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(s1);
- convert_to_string_ex(s2);
- RETURN_LONG(zend_binary_zval_strcasecmp(*s1, *s2));
+
+ RETURN_LONG(zend_binary_strcasecmp(s1, s1_len, s2, s2_len));
}
/* }}} */
Binary safe string comparison */
ZEND_FUNCTION(strncasecmp)
{
- zval **s1, **s2, **s3;
-
- if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &s1, &s2, &s3) == FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ char *s1, *s2;
+ int s1_len, s2_len;
+ long len;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl", &s1, &s1_len, &s2, &s2_len, &len) == FAILURE) {
+ return;
}
- convert_to_string_ex(s1);
- convert_to_string_ex(s2);
- convert_to_long_ex(s3);
- if (Z_LVAL_PP(s3) < 0) {
+ if (len < 0) {
zend_error(E_WARNING, "Length must be greater than or equal to 0");
RETURN_FALSE;
}
- RETURN_LONG(zend_binary_zval_strncasecmp(*s1, *s2, *s3));
+ RETURN_LONG(zend_binary_strncasecmp(s1, s1_len, s2, s2_len, len));
}
/* }}} */
Return the currently pointed key..value pair in the passed array, and advance the pointer to the next element */
ZEND_FUNCTION(each)
{
- zval **array, *entry, **entry_ptr, *tmp;
+ zval *array, *entry, **entry_ptr, *tmp;
char *string_key;
uint string_key_len;
ulong num_key;
zval **inserted_pointer;
HashTable *target_hash;
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &array) == FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &array) == FAILURE) {
+ return;
}
- target_hash = HASH_OF(*array);
+ target_hash = HASH_OF(array);
if (!target_hash) {
zend_error(E_WARNING,"Variable passed to each() is not an array or object");
return;
Return the current error_reporting level, and if an argument was passed - change to the new level */
ZEND_FUNCTION(error_reporting)
{
- zval **arg;
+ char *err;
+ int err_len;
int old_error_reporting;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &err, &err_len) == FAILURE) {
+ return;
+ }
+
old_error_reporting = EG(error_reporting);
- switch (ZEND_NUM_ARGS()) {
- case 0:
- break;
- case 1:
- if (zend_get_parameters_ex(1, &arg) == FAILURE) {
- RETURN_FALSE;
- }
- convert_to_string_ex(arg);
- zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
- break;
- default:
- ZEND_WRONG_PARAM_COUNT();
- break;
+ if(ZEND_NUM_ARGS() != 0) {
+ zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), err, err_len, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
}
RETVAL_LONG(old_error_reporting);
/* }}} */
-/* {{{ proto bool define(string constant_name, mixed value, boolean case_sensitive=true)
+/* {{{ proto bool define(string constant_name, mixed value, boolean case_insensitive=false)
Define a new constant */
ZEND_FUNCTION(define)
{
- zval **var, **val, **non_cs, *val_free = NULL;
- int case_sensitive;
+ char *name;
+ int name_len;
+ zval *val, *val_free;
+ zend_bool non_cs = 0;
+ int case_sensitive = CONST_CS;
zend_constant c;
- switch (ZEND_NUM_ARGS()) {
- case 2:
- if (zend_get_parameters_ex(2, &var, &val)==FAILURE) {
- RETURN_FALSE;
- }
- case_sensitive = CONST_CS;
- break;
- case 3:
- if (zend_get_parameters_ex(3, &var, &val, &non_cs)==FAILURE) {
- RETURN_FALSE;
- }
- convert_to_long_ex(non_cs);
- if (Z_LVAL_PP(non_cs)) {
- case_sensitive = 0;
- } else {
- case_sensitive = CONST_CS;
- }
- break;
- default:
- ZEND_WRONG_PARAM_COUNT();
- break;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|b", &name, &name_len, &val, &non_cs) == FAILURE) {
+ return;
+ }
+
+ if(non_cs) {
+ case_sensitive = 0;
}
repeat:
- switch (Z_TYPE_PP(val)) {
+ switch (Z_TYPE_P(val)) {
case IS_LONG:
case IS_DOUBLE:
case IS_STRING:
break;
case IS_OBJECT:
if (!val_free) {
- if (Z_OBJ_HT_PP(val)->get) {
- val_free = *val = Z_OBJ_HT_PP(val)->get(*val TSRMLS_CC);
+ if (Z_OBJ_HT_P(val)->get) {
+ val_free = val = Z_OBJ_HT_P(val)->get(val TSRMLS_CC);
goto repeat;
- } else if (Z_OBJ_HT_PP(val)->cast_object) {
+ } else if (Z_OBJ_HT_P(val)->cast_object) {
ALLOC_INIT_ZVAL(val_free);
- if (Z_OBJ_HT_PP(val)->cast_object(*val, val_free, IS_STRING TSRMLS_CC) == SUCCESS) {
- val = &val_free;
+ if (Z_OBJ_HT_P(val)->cast_object(val, val_free, IS_STRING TSRMLS_CC) == SUCCESS) {
+ val = val_free;
break;
}
}
}
RETURN_FALSE;
}
- convert_to_string_ex(var);
- c.value = **val;
+ c.value = *val;
zval_copy_ctor(&c.value);
if (val_free) {
zval_ptr_dtor(&val_free);
}
c.flags = case_sensitive; /* non persistent */
- c.name = zend_strndup(Z_STRVAL_PP(var), Z_STRLEN_PP(var));
- c.name_len = Z_STRLEN_PP(var)+1;
+ c.name = zend_strndup(name, name_len);
+ c.name_len = name_len+1;
c.module_number = PHP_USER_CONSTANT;
if (zend_register_constant(&c TSRMLS_CC) == SUCCESS) {
RETURN_TRUE;
Check whether a constant exists */
ZEND_FUNCTION(defined)
{
- zval **var;
+ char *name;
+ int name_len;
zval c;
- if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &var)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(var);
- if (zend_get_constant_ex(Z_STRVAL_PP(var), Z_STRLEN_PP(var), &c, NULL, ZEND_FETCH_CLASS_SILENT TSRMLS_CC)) {
+ if (zend_get_constant_ex(name, name_len, &c, NULL, ZEND_FETCH_CLASS_SILENT TSRMLS_CC)) {
zval_dtor(&c);
RETURN_TRUE;
} else {
Retrieves the class name */
ZEND_FUNCTION(get_class)
{
- zval **arg;
+ zval *obj = NULL;
char *name = "";
zend_uint name_len = 0;
int dup;
- if (!ZEND_NUM_ARGS()) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|o", &obj) == FAILURE) {
+ return;
+ }
+
+ if (!obj) {
if (EG(scope)) {
RETURN_STRINGL(EG(scope)->name, EG(scope)->name_length, 1);
} else {
RETURN_FALSE;
}
}
- if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &arg)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
- }
- if (Z_TYPE_PP(arg) != IS_OBJECT) {
- RETURN_FALSE;
- }
- dup = zend_get_object_classname(*arg, &name, &name_len TSRMLS_CC);
+ dup = zend_get_object_classname(obj, &name, &name_len TSRMLS_CC);
RETURN_STRINGL(name, name_len, dup);
}
Retrieves the "Late Static Binding" class name */
ZEND_FUNCTION(get_called_class)
{
- if (!ZEND_NUM_ARGS()) {
- if (EG(called_scope)) {
- RETURN_STRINGL(EG(called_scope)->name, EG(called_scope)->name_length, 1);
- } else {
- zend_error(E_WARNING, "get_called_class() called from outside a class");
- RETURN_FALSE;
- }
+ if (zend_parse_parameters_none() == FAILURE) {
+ return;
+ }
+
+ if (EG(called_scope)) {
+ RETURN_STRINGL(EG(called_scope)->name, EG(called_scope)->name_length, 1);
} else {
- ZEND_WRONG_PARAM_COUNT();
+ zend_error(E_WARNING, "get_called_class() called from outside a class");
RETURN_FALSE;
}
}
Retrieves the parent class name for object or class or current scope. */
ZEND_FUNCTION(get_parent_class)
{
- zval **arg;
+ zval *arg;
zend_class_entry *ce = NULL;
char *name;
zend_uint name_length;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arg) == FAILURE) {
+ return;
+ }
+
if (!ZEND_NUM_ARGS()) {
ce = EG(scope);
if (ce && ce->parent) {
RETURN_FALSE;
}
}
- if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &arg)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
- }
- if (Z_TYPE_PP(arg) == IS_OBJECT) {
- if (Z_OBJ_HT_PP(arg)->get_class_name
- && Z_OBJ_HT_PP(arg)->get_class_name(*arg, &name, &name_length, 1 TSRMLS_CC) == SUCCESS) {
+ if (Z_TYPE_P(arg) == IS_OBJECT) {
+ if (Z_OBJ_HT_P(arg)->get_class_name
+ && Z_OBJ_HT_P(arg)->get_class_name(arg, &name, &name_length, 1 TSRMLS_CC) == SUCCESS) {
RETURN_STRINGL(name, name_length, 0);
} else {
- ce = zend_get_class_entry(*arg TSRMLS_CC);
+ ce = zend_get_class_entry(arg TSRMLS_CC);
}
- } else if (Z_TYPE_PP(arg) == IS_STRING) {
+ } else if (Z_TYPE_P(arg) == IS_STRING) {
zend_class_entry **pce;
- if (zend_lookup_class(Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), &pce TSRMLS_CC) == SUCCESS) {
+ if (zend_lookup_class(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &pce TSRMLS_CC) == SUCCESS) {
ce = *pce;
}
}
static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool only_subclass)
{
- zval **obj, **class_name;
+ zval *obj;
+ char *class_name;
+ int class_name_len;
zend_class_entry *instance_ce;
zend_class_entry **ce;
zend_bool retval;
- if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &obj, &class_name)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &obj, &class_name, &class_name_len) == FAILURE) {
+ return;
}
-
- if (only_subclass && Z_TYPE_PP(obj) == IS_STRING) {
+
+ if (only_subclass && Z_TYPE_P(obj) == IS_STRING) {
zend_class_entry **the_ce;
- if (zend_lookup_class(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), &the_ce TSRMLS_CC) == FAILURE) {
+ if (zend_lookup_class(Z_STRVAL_P(obj), Z_STRLEN_P(obj), &the_ce TSRMLS_CC) == FAILURE) {
zend_error(E_WARNING, "Unknown class passed as parameter");
RETURN_FALSE;
}
instance_ce = *the_ce;
- } else if (Z_TYPE_PP(obj) != IS_OBJECT) {
+ } else if (Z_TYPE_P(obj) != IS_OBJECT) {
RETURN_FALSE;
} else {
instance_ce = NULL;
}
/* TBI!! new object handlers */
- if (Z_TYPE_PP(obj) == IS_OBJECT && !HAS_CLASS_ENTRY(**obj)) {
+ if (Z_TYPE_P(obj) == IS_OBJECT && !HAS_CLASS_ENTRY(*obj)) {
RETURN_FALSE;
}
- convert_to_string_ex(class_name);
-
- if (zend_lookup_class_ex(Z_STRVAL_PP(class_name), Z_STRLEN_PP(class_name), 0, &ce TSRMLS_CC) == FAILURE) {
+ if (zend_lookup_class_ex(class_name, class_name_len, 0, &ce TSRMLS_CC) == FAILURE) {
retval = 0;
} else {
if (only_subclass) {
if (!instance_ce) {
- instance_ce = Z_OBJCE_PP(obj)->parent;
+ instance_ce = Z_OBJCE_P(obj)->parent;
} else {
instance_ce = instance_ce->parent;
}
} else {
- instance_ce = Z_OBJCE_PP(obj);
+ instance_ce = Z_OBJCE_P(obj);
}
if (!instance_ce) {
Returns an array of object properties */
ZEND_FUNCTION(get_object_vars)
{
- zval **obj;
+ zval *obj;
zval **value;
HashTable *properties;
HashPosition pos;
ulong num_index;
zend_object *zobj;
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &obj) == FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
+ return;
}
- if (Z_TYPE_PP(obj) != IS_OBJECT) {
- RETURN_FALSE;
- }
- if (Z_OBJ_HT_PP(obj)->get_properties == NULL) {
+ if (Z_OBJ_HT_P(obj)->get_properties == NULL) {
RETURN_FALSE;
}
- properties = Z_OBJ_HT_PP(obj)->get_properties(*obj TSRMLS_CC);
+ properties = Z_OBJ_HT_P(obj)->get_properties(obj TSRMLS_CC);
if (properties == NULL) {
RETURN_FALSE;
}
- zobj = zend_objects_get_address(*obj TSRMLS_CC);
+ zobj = zend_objects_get_address(obj TSRMLS_CC);
array_init(return_value);
Returns an array of method names for class or class instance. */
ZEND_FUNCTION(get_class_methods)
{
- zval **class;
+ zval *klass;
zval *method_name;
zend_class_entry *ce = NULL, **pce;
HashPosition pos;
zend_function *mptr;
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &class)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &klass) == FAILURE) {
+ return;
}
- if (Z_TYPE_PP(class) == IS_OBJECT) {
+ if (Z_TYPE_P(klass) == IS_OBJECT) {
/* TBI!! new object handlers */
- if (!HAS_CLASS_ENTRY(**class)) {
+ if (!HAS_CLASS_ENTRY(*klass)) {
RETURN_FALSE;
}
- ce = Z_OBJCE_PP(class);
- } else if (Z_TYPE_PP(class) == IS_STRING) {
- if (zend_lookup_class(Z_STRVAL_PP(class), Z_STRLEN_PP(class), &pce TSRMLS_CC) == SUCCESS) {
+ ce = Z_OBJCE_P(klass);
+ } else if (Z_TYPE_P(klass) == IS_STRING) {
+ if (zend_lookup_class(Z_STRVAL_P(klass), Z_STRLEN_P(klass), &pce TSRMLS_CC) == SUCCESS) {
ce = *pce;
}
}
Checks if the class method exists */
ZEND_FUNCTION(method_exists)
{
- zval **klass, **method_name;
+ zval *klass;
+ char *method_name;
+ int method_len;
char *lcname;
zend_class_entry * ce, **pce;
- if (ZEND_NUM_ARGS()!=2 || zend_get_parameters_ex(2, &klass, &method_name)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &klass, &method_name, &method_len) == FAILURE) {
+ return;
}
- if (Z_TYPE_PP(klass) == IS_OBJECT) {
- ce = Z_OBJCE_PP(klass);
- } else if (Z_TYPE_PP(klass) == IS_STRING) {
- if (zend_lookup_class(Z_STRVAL_PP(klass), Z_STRLEN_PP(klass), &pce TSRMLS_CC) == FAILURE) {
+ if (Z_TYPE_P(klass) == IS_OBJECT) {
+ ce = Z_OBJCE_P(klass);
+ } else if (Z_TYPE_P(klass) == IS_STRING) {
+ if (zend_lookup_class(Z_STRVAL_P(klass), Z_STRLEN_P(klass), &pce TSRMLS_CC) == FAILURE) {
RETURN_FALSE;
}
ce = *pce;
RETURN_FALSE;
}
- convert_to_string_ex(method_name);
- lcname = zend_str_tolower_dup(Z_STRVAL_PP(method_name), Z_STRLEN_PP(method_name));
- if (zend_hash_exists(&ce->function_table, lcname, Z_STRLEN_PP(method_name)+1)) {
+ lcname = zend_str_tolower_dup(method_name, method_len);
+ if (zend_hash_exists(&ce->function_table, lcname, method_len+1)) {
efree(lcname);
RETURN_TRUE;
} else {
union _zend_function *func = NULL;
efree(lcname);
- if (Z_TYPE_PP(klass) == IS_OBJECT
- && Z_OBJ_HT_PP(klass)->get_method != NULL
- && (func = Z_OBJ_HT_PP(klass)->get_method(klass, Z_STRVAL_PP(method_name), Z_STRLEN_PP(method_name) TSRMLS_CC)) != NULL
+ if (Z_TYPE_P(klass) == IS_OBJECT
+ && Z_OBJ_HT_P(klass)->get_method != NULL
+ && (func = Z_OBJ_HT_P(klass)->get_method(&klass, method_name, method_len TSRMLS_CC)) != NULL
) {
if (func->type == ZEND_INTERNAL_FUNCTION
&& ((zend_internal_function*)func)->handler == zend_std_call_user_call
Checks if the object or class has a property */
ZEND_FUNCTION(property_exists)
{
- zval **object, **property;
+ zval *object;
+ char *property;
+ int property_len;
zend_class_entry *ce, **pce;
zend_property_info *property_info;
char *prop_name, *class_name;
+ zval property_z;
- if (ZEND_NUM_ARGS()!= 2 || zend_get_parameters_ex(2, &object, &property)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &object, &property, &property_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(property);
- if (!Z_STRLEN_PP(property)) {
+
+ if (property_len == 0) {
RETURN_FALSE;
}
- switch((*object)->type) {
+ ZVAL_STRINGL(&property_z, property, property_len, 0);
+
+ switch(Z_TYPE_P(object)) {
case IS_STRING:
- if (!Z_STRLEN_PP(object)) {
+ if (!Z_STRLEN_P(object)) {
RETURN_FALSE;
}
- if (zend_lookup_class(Z_STRVAL_PP(object), Z_STRLEN_PP(object), &pce TSRMLS_CC) == SUCCESS) {
+ if (zend_lookup_class(Z_STRVAL_P(object), Z_STRLEN_P(object), &pce TSRMLS_CC) == SUCCESS) {
ce = *pce;
} else {
RETURN_FALSE;
if (!ce) {
RETURN_NULL();
}
- if (!(property_info = zend_get_property_info(ce, *property, 1 TSRMLS_CC)) || property_info == &EG(std_property_info)) {
+ if (!(property_info = zend_get_property_info(ce, &property_z, 1 TSRMLS_CC)) || property_info == &EG(std_property_info)) {
RETURN_FALSE;
}
if (property_info->flags & ZEND_ACC_PUBLIC) {
}
RETURN_FALSE;
}
- if (zend_lookup_class(Z_STRVAL_PP(object), Z_STRLEN_PP(object), &pce TSRMLS_CC) == SUCCESS) {
+ if (zend_lookup_class(Z_STRVAL_P(object), Z_STRLEN_P(object), &pce TSRMLS_CC) == SUCCESS) {
ce = *pce;
} else {
RETURN_FALSE; /* shouldn't happen */
RETURN_BOOL(EG(scope) == ce);
case IS_OBJECT:
- if (Z_OBJ_HANDLER_PP(object, has_property) && Z_OBJ_HANDLER_PP(object, has_property)(*object, *property, 2 TSRMLS_CC)) {
+ if (Z_OBJ_HANDLER_P(object, has_property) && Z_OBJ_HANDLER_P(object, has_property)(object, &property_z, 2 TSRMLS_CC)) {
RETURN_TRUE;
}
RETURN_FALSE;
Checks if the function exists */
ZEND_FUNCTION(function_exists)
{
- zval **function_name;
+ char *name;
+ int name_len;
zend_function *func;
char *lcname;
zend_bool retval;
- if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &function_name)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(function_name);
- lcname = zend_str_tolower_dup(Z_STRVAL_PP(function_name), Z_STRLEN_PP(function_name));
- retval = (zend_hash_find(EG(function_table), lcname, Z_STRLEN_PP(function_name)+1, (void **)&func) == SUCCESS);
+ lcname = zend_str_tolower_dup(name, name_len);
+
+ retval = (zend_hash_find(EG(function_table), lcname, name_len+1, (void **)&func) == SUCCESS);
efree(lcname);
Cause an intentional memory leak, for testing/debugging purposes */
ZEND_FUNCTION(leak)
{
- int leakbytes=3;
- zval **leak;
+ long leakbytes=3;
- if (ZEND_NUM_ARGS()>=1) {
- if (zend_get_parameters_ex(1, &leak)==SUCCESS) {
- convert_to_long_ex(leak);
- leakbytes = Z_LVAL_PP(leak);
- }
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &leakbytes) == FAILURE) {
+ return;
}
emalloc(leakbytes);
ZEND_FUNCTION(trigger_error)
{
int error_type = E_USER_NOTICE;
- zval **z_error_type, **z_error_message;
+ char *message;
+ int message_len;
- switch (ZEND_NUM_ARGS()) {
- case 1:
- if (zend_get_parameters_ex(1, &z_error_message)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
- }
- break;
- case 2:
- if (zend_get_parameters_ex(2, &z_error_message, &z_error_type)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
- }
- convert_to_long_ex(z_error_type);
- error_type = Z_LVAL_PP(z_error_type);
- switch (error_type) {
- case E_USER_ERROR:
- case E_USER_WARNING:
- case E_USER_NOTICE:
- break;
- default:
- zend_error(E_WARNING, "Invalid error type specified");
- RETURN_FALSE;
- break;
- }
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &message, &message_len, &error_type) == FAILURE) {
+ return;
+ }
+
+ switch (error_type) {
+ case E_USER_ERROR:
+ case E_USER_WARNING:
+ case E_USER_NOTICE:
break;
default:
- ZEND_WRONG_PARAM_COUNT();
+ zend_error(E_WARNING, "Invalid error type specified");
+ RETURN_FALSE;
+ break;
}
- convert_to_string_ex(z_error_message);
- zend_error(error_type, "%s", Z_STRVAL_PP(z_error_message));
+
+ zend_error(error_type, "%s", message);
RETURN_TRUE;
}
/* }}} */
Sets a user-defined exception handler function. Returns the previously defined exception handler, or false on error */
ZEND_FUNCTION(set_exception_handler)
{
- zval **exception_handler;
+ zval *exception_handler;
char *exception_handler_name = NULL;
zend_bool had_orig_exception_handler=0;
- if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &exception_handler)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &exception_handler) == FAILURE) {
+ return;
}
- if (Z_TYPE_PP(exception_handler) != IS_NULL) { /* NULL == unset */
- if (!zend_is_callable(*exception_handler, 0, &exception_handler_name)) {
+ if (Z_TYPE_P(exception_handler) != IS_NULL) { /* NULL == unset */
+ if (!zend_is_callable(exception_handler, 0, &exception_handler_name)) {
zend_error(E_WARNING, "%s() expects the argument (%s) to be a valid callback",
get_active_function_name(TSRMLS_C), exception_handler_name?exception_handler_name:"unknown");
efree(exception_handler_name);
}
ALLOC_ZVAL(EG(user_exception_handler));
- if (Z_TYPE_PP(exception_handler) == IS_NULL) { /* unset user-defined handler */
+ if (Z_TYPE_P(exception_handler) == IS_NULL) { /* unset user-defined handler */
FREE_ZVAL(EG(user_exception_handler));
EG(user_exception_handler) = NULL;
RETURN_TRUE;
}
- *EG(user_exception_handler) = **exception_handler;
+ *EG(user_exception_handler) = *exception_handler;
zval_copy_ctor(EG(user_exception_handler));
if (!had_orig_exception_handler) {
Creates an anonymous function, and returns its name (funny, eh?) */
ZEND_FUNCTION(create_function)
{
- char *eval_code, *function_name;
- int eval_code_length, function_name_length;
- zval **z_function_args, **z_function_code;
+ char *eval_code, *function_name, *function_args, *function_code;
+ int function_name_length, function_args_len, function_code_len;
int retval;
char *eval_name;
- if (ZEND_NUM_ARGS()!=2 || zend_get_parameters_ex(2, &z_function_args, &z_function_code)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &function_args, &function_args_len, &function_code, &function_code_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(z_function_args);
- convert_to_string_ex(z_function_code);
-
- eval_code_length = sizeof("function " LAMBDA_TEMP_FUNCNAME)
- +Z_STRLEN_PP(z_function_args)
- +2 /* for the args parentheses */
- +2 /* for the curly braces */
- +Z_STRLEN_PP(z_function_code);
-
- zend_spprintf(&eval_code, 0, "function " LAMBDA_TEMP_FUNCNAME "(%s){%s}", Z_STRVAL_PP(z_function_args), Z_STRVAL_PP(z_function_code));
+ zend_spprintf(&eval_code, 0, "function " LAMBDA_TEMP_FUNCNAME "(%s){%s}", function_args, function_code);
eval_name = zend_make_compiled_string_description("runtime-created function" TSRMLS_CC);
retval = zend_eval_string(eval_code, NULL, eval_name TSRMLS_CC);
ZEND_FUNCTION(get_resource_type)
{
char *resource_type;
- zval **z_resource_type;
+ zval *z_resource_type;
- if (ZEND_NUM_ARGS()!=1 || zend_get_parameters_ex(1, &z_resource_type)==FAILURE) {
- ZEND_WRONG_PARAM_COUNT();
- }
-
- if (Z_TYPE_PP(z_resource_type) != IS_RESOURCE) {
- zend_error(E_WARNING, "Supplied argument is not a valid resource handle");
- RETURN_FALSE;
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_resource_type) == FAILURE) {
+ return;
}
- resource_type = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(z_resource_type) TSRMLS_CC);
+ resource_type = zend_rsrc_list_get_rsrc_type(Z_LVAL_P(z_resource_type) TSRMLS_CC);
if (resource_type) {
RETURN_STRING(resource_type, 1);
} else {
Returns true if the named extension is loaded */
ZEND_FUNCTION(extension_loaded)
{
- zval **extension_name;
+ char *extension_name;
+ int extension_name_len;
char *lcname;
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &extension_name)) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(extension_name);
- lcname = zend_str_tolower_dup(Z_STRVAL_PP(extension_name), Z_STRLEN_PP(extension_name));
- if (zend_hash_exists(&module_registry, lcname, Z_STRLEN_PP(extension_name)+1)) {
+ lcname = zend_str_tolower_dup(extension_name, extension_name_len);
+ if (zend_hash_exists(&module_registry, lcname, extension_name_len+1)) {
RETVAL_TRUE;
} else {
RETVAL_FALSE;
Returns an array with the names of functions belonging to the named extension */
ZEND_FUNCTION(get_extension_funcs)
{
- zval **extension_name;
+ char *extension_name;
+ int extension_name_len;
zend_module_entry *module;
const zend_function_entry *func;
- if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &extension_name)) {
- ZEND_WRONG_PARAM_COUNT();
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) {
+ return;
}
- convert_to_string_ex(extension_name);
- if (strncasecmp(Z_STRVAL_PP(extension_name), "zend", sizeof("zend"))) {
- char *lcname = zend_str_tolower_dup(Z_STRVAL_PP(extension_name), Z_STRLEN_PP(extension_name));
+ if (strncasecmp(extension_name, "zend", sizeof("zend"))) {
+ char *lcname = zend_str_tolower_dup(extension_name, extension_name_len);
if (zend_hash_find(&module_registry, lcname,
- Z_STRLEN_PP(extension_name)+1, (void**)&module) == FAILURE) {
+ extension_name_len+1, (void**)&module) == FAILURE) {
efree(lcname);
RETURN_FALSE;
}
projects / php / commitdiff