|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
?? ?? 1999, Version 4.0 Beta 3
-- Updated PCRE to use the new high-performance Zend function API (Andrey)
+- Updated preg_split() to allow returning only non-empty pieces (Andrei)
+- Updated PCRE to use the new high-performance Zend function API (Andrei)
- Updated session, dba, mhash, mcrypt, sysvshm, sysvsem, gettext modules to use
the new high-performance Zend function API (Sascha)
-- Extended var_dump to handle resource type somewhat (Andrey)
-- Updated WDDX to use the new high-performance Zend function API (Andrey)
+- Extended var_dump to handle resource type somewhat (Andrei)
+- Updated WDDX to use the new high-performance Zend function API (Andrei)
- Updated XML to use the new high-performance Zend function API. (Thies)
- Updated Oracle to use the new high-performance Zend function API. (Thies)
- Improved the performance of the MySQL module significantly by using the new
typo in mcal_list_alarms() (Andrew Skalski)
- Fixed Ora_PLogon (Thies)
- Resourcified Oracle (Thies)
-- Implemented object serialization/deserialization in WDDX (Andrey)
+- Implemented object serialization/deserialization in WDDX (Andrei)
- Added krsort() function (Thies)
- Added func_num_args(), func_get_arg() and func_get_args() for standard
access to variable number of arguments functions (Zeev)
- Added optional allowable_tags arguments to strip_tags(), gzgetss() and
fgetss() to allow you to specify a string of tags that are not to be
stripped (Rasmus)
-- Upgraded var_dump() to take multiple arguments (Andrey)
+- Upgraded var_dump() to take multiple arguments (Andrei)
- Resourcified XML (Thies)
- Fixed a memory leak in the Apache per-directory directives handler (Zeev)
- Added array_count_values() function. (Thies)
- Made serialize/unserialize work on classes. If the class is known at
unserialize() time, you'll get back a fully working object! (Thies)
- Reworked preg_* functions according to the new PCRE API, which also made
- them behave much more like Perl ones (Andrey)
-- Made it possible to specify external location of PCRE library (Andrey)
-- Updated bundled PCRE library to version 2.08 (Andrey)
+ them behave much more like Perl ones (Andrei)
+- Made it possible to specify external location of PCRE library (Andrei)
+- Updated bundled PCRE library to version 2.08 (Andrei)
- count()/is_array/is_object... speedups. (Thies)
- OCI8 supports appending and positioning when saving LOBs (Thies)
- Added metaphone support (Thies)
tells PHP whether it may expose its existence to the outside world, e.g.
by adding itself to the Web server header (Zeev)
- Added support for transparent session id propagation (Sascha)
-- Made WDDX serialize object properties properly (Andrey)
+- Made WDDX serialize object properties properly (Andrei)
- Fixed WDDX mem leak when undefined variable is passed in
- for serialization (Andrey)
-- Added session_unset() function (Andrey)
-- Fixed double session globals shutdown crash (Andrey)
-- Fixed crash related to ignore_user_abort ini entry (Andrey)
+ for serialization (Andrei)
+- Added session_unset() function (Andrei)
+- Fixed double session globals shutdown crash (Andrei)
+- Fixed crash related to ignore_user_abort ini entry (Andrei)
- Added support for external entropy sources for session id creation
(on Unices /dev/random and /dev/urandom) (Sascha)
- Added gpc_globals variable directive to php.ini. By default it is On, but
This allows concurrent use of PHP 3.0 and PHP 4.0 as Apache modules. See
the end of the INSTALL file for more information.
- Added second parameter to array_keys which specifies search value
- for which the key should be returned (Andrey)
+ for which the key should be returned (Andrei)
- Resourcified Informix driver (Danny)
- New resource handling for odbc, renamed to php_odbc.[ch]
- Make set_time_limit() work on Unix (Rasmus)
- Added -d switch to the CGI binary that allows overriding php.ini values
from the command line (Zeev)
- Fixed a crash that would occur if wddx_deserialize did not receive
- a valid packet (Andrey)
+ a valid packet (Andrei)
- Fixed a bugglet when redefining a class at run-time (Andi, Zend library)
- Fixed sem_get() on AIX (Sascha)
- Fixed fopen() to work with URL's in Win32 (Andi & Zeev)
- Improved speed of uniqid() by using the combined LCG and removing
the extra usleep() (Sascha)
- Introduced general combined linear congruential generator (Sascha)
-- Made ldap_close back into an alias for ldap_unbind (Andrey)
+- Made ldap_close back into an alias for ldap_unbind (Andrei)
- OciFetchInto now resets the returned array in all cases (Thies)
- Fixed mysql_errno() to work with recent versions of MySQL (Zeev)
- Fixed a problem with define() and boolean values (Zeev)
- Oracle is now ZTS-Safe (Thies)
- Fixed flushing of cached information to disk in DBA's DB2 module (Sascha)
- OCI8 is now ZTS-Safe (Thies)
-- Fixed is_writeable/is_writable problem; they are both defined now (Andrey)
+- Fixed is_writeable/is_writable problem; they are both defined now (Andrei)
- Imported PHP 3.0 diskfreespace() function (Thies)
- Fixed thread-safety issues in the MySQL module (Zeev)
- Fixed thread-safe support for dynamic modules (Zeev)
on using the allow_builtin_links INI directive (Zeev)
- Changed phpinfo() to list modules that have no info function (Zeev)
- Modified array_walk() function so that the userland callback is passed
- a key and possible user data in addition to the value (Andrey)
+ a key and possible user data in addition to the value (Andrei)
- Fixed ldap_search(), ldap_read() and ldap_list() (Zeev)
- Fixed Apache information in phpinfo() (sam@breakfree.com)
- Improved register_shutdown_function() - you may now supply arguments that
- Fixed runtime inheritance of classes (parent methods/properties were
overriding their children) (Zeev, Zend library)
- Fixed backwards incompatibility with the "new" operator (Andi, Zend library)
-- Fixed bugs in uksort() and ksort() sort ordering (Andrey)
+- Fixed bugs in uksort() and ksort() sort ordering (Andrei)
- Fixed a memory leak when using assignment-op operators with lvalue of type
string (Zeev, Zend library)
- Fixed a problem in inheritance from classes that are defined in include()d
- Fixed a crash problem in switch statements that had a string offset
as a conditional (Andi & Zeev, Zend library)
- Imported PHP 3.0 fixes for rand() and mt_rand() (Rasmus)
-- Added function entries for strip_tags() and similar_text() (Andrey)
+- Added function entries for strip_tags() and similar_text() (Andrei)
- Fixed a bug in WDDX that would cause a crash if a number was passed in
- instead of a variable name (Andrey)
-- Ported strtotime() function from PHP 3.0 (Andrey)
+ instead of a variable name (Andrei)
+- Ported strtotime() function from PHP 3.0 (Andrei)
- Merged in gdttf stuff from PHP 3.0 (Sascha)
- buildconf now checks your installation (Stig)
- XML module now built dynamically with --with-xml=shared (Stig)
- Added a check for freetype.h - fixed build on RedHat 6.0 (Zeev)
-- Fixed array_walk() to work in PHP 4.0 (Andrey)
-- Ported all remaining date() format options from PHP 3.0 (Andrey)
-- $php_errormsg now works (Andrey)
-- Added locale support for Perl Compatible Regexp functions (Andrey)
+- Fixed array_walk() to work in PHP 4.0 (Andrei)
+- Ported all remaining date() format options from PHP 3.0 (Andrei)
+- $php_errormsg now works (Andrei)
+- Added locale support for Perl Compatible Regexp functions (Andrei)
- Informix module ported (Danny)
- Removed --with-shared-apache (Sascha)
- Added patch for reverse lookup table in base64_decode (Sascha)
}
}
-static pval *php_array_walk_func_name;
+static zval **php_array_walk_func_name;
static int php_array_walk(HashTable *target_hash, zval **userdata)
{
}
/* Call the userland function */
- call_user_function_ex(CG(function_table), NULL, php_array_walk_func_name,
- &retval, (*userdata) ? 3 : 2, args, 0);
+ call_user_function_ex(CG(function_table), NULL, *php_array_walk_func_name,
+ &retval, userdata ? 3 : 2, args, 0);
/* Clean up the key */
if (zend_hash_get_current_key_type(target_hash) == HASH_KEY_IS_STRING)
/* {{{ proto array_walk(array input, string funcname [, mixed userdata])
Apply a user function to every member of an array */
PHP_FUNCTION(array_walk) {
- int argc;
- zval *array,
- *userdata = NULL,
- *old_walk_func_name;
+ int argc;
+ zval **array,
+ **userdata = NULL,
+ **old_walk_func_name;
HashTable *target_hash;
argc = ARG_COUNT(ht);
old_walk_func_name = php_array_walk_func_name;
if (argc < 2 || argc > 3 ||
- getParameters(ht, argc, &array, &php_array_walk_func_name, &userdata) == FAILURE) {
+ getParametersEx(argc, &array, &php_array_walk_func_name, &userdata) == FAILURE) {
php_array_walk_func_name = old_walk_func_name;
WRONG_PARAM_COUNT;
}
- target_hash = HASH_OF(array);
+ target_hash = HASH_OF(*array);
if (!target_hash) {
php_error(E_WARNING, "Wrong datatype in array_walk() call");
php_array_walk_func_name = old_walk_func_name;
return;
}
- convert_to_string(php_array_walk_func_name);
- php_array_walk(target_hash, &userdata);
+ convert_to_string_ex(php_array_walk_func_name);
+ php_array_walk(target_hash, userdata);
php_array_walk_func_name = old_walk_func_name;
RETURN_TRUE;
}
/* HashTable* _phpi_splice(HashTable *in_hash, int offset, int length,
- zval **list, int list_count, HashTable **removed) */
+ zval ***list, int list_count, HashTable **removed) */
HashTable* _phpi_splice(HashTable *in_hash, int offset, int length,
- zval **list, int list_count, HashTable **removed)
+ zval ***list, int list_count, HashTable **removed)
{
HashTable *out_hash = NULL; /* Output hashtable */
int num_in, /* Number of entries in the input hashtable */
/* ..for each one, create a new zval, copy entry into it
and copy it into the output hash */
for (i=0; i<list_count; i++) {
- entry = list[i];
+ entry = *list[i];
entry->refcount++;
zend_hash_next_index_insert(out_hash, &entry, sizeof(zval *), NULL);
}
Pushes elements onto the end of the array */
PHP_FUNCTION(array_push)
{
- zval **args, /* Function arguments array */
- *stack, /* Input array */
- *new_var; /* Variable to be pushed */
+ zval ***args, /* Function arguments array */
+ *stack, /* Input array */
+ *new_var; /* Variable to be pushed */
int i, /* Loop counter */
argc; /* Number of function arguments */
}
/* Allocate arguments array and get the arguments, checking for errors. */
- args = (zval **)emalloc(argc * sizeof(zval *));
- if (getParametersArray(ht, argc, args) == FAILURE) {
+ args = (zval ***)emalloc(argc * sizeof(zval **));
+ if (getParametersArrayEx(argc, args) == FAILURE) {
efree(args);
WRONG_PARAM_COUNT;
}
/* Get first argument and check that it's an array */
- stack = args[0];
+ stack = *args[0];
if (stack->type != IS_ARRAY) {
- zend_error(E_WARNING, "First argument to push() needs to be an array");
+ zend_error(E_WARNING, "First argument to array_push() needs to be an array");
RETURN_FALSE;
}
/* For each subsequent argument, make it a reference, increase refcount,
and add it to the end of the array */
for (i=1; i<argc; i++) {
- new_var = args[i];
+ new_var = *args[i];
new_var->refcount++;
zend_hash_next_index_insert(stack->value.ht, &new_var, sizeof(zval *), NULL);
/* {{{ void _phpi_pop(INTERNAL_FUNCTION_PARAMETERS, int which_end) */
static void _phpi_pop(INTERNAL_FUNCTION_PARAMETERS, int off_the_end)
{
- zval *stack, /* Input stack */
+ zval **stack, /* Input stack */
**val; /* Value to be popped */
HashTable *new_hash; /* New stack */
/* Get the arguments and do error-checking */
- if (ARG_COUNT(ht) != 1 || getParameters(ht, 1, &stack) == FAILURE) {
+ if (ARG_COUNT(ht) != 1 || getParametersEx(1, &stack) == FAILURE) {
WRONG_PARAM_COUNT;
}
- if (stack->type != IS_ARRAY) {
+ if ((*stack)->type != IS_ARRAY) {
zend_error(E_WARNING, "The argument needs to be an array");
return;
}
- if (zend_hash_num_elements(stack->value.ht) == 0) {
+ if (zend_hash_num_elements((*stack)->value.ht) == 0) {
return;
}
/* Get the first or last value and copy it into the return value */
if (off_the_end)
- zend_hash_internal_pointer_end(stack->value.ht);
+ zend_hash_internal_pointer_end((*stack)->value.ht);
else
- zend_hash_internal_pointer_reset(stack->value.ht);
- zend_hash_get_current_data(stack->value.ht, (void **)&val);
+ zend_hash_internal_pointer_reset((*stack)->value.ht);
+ zend_hash_get_current_data((*stack)->value.ht, (void **)&val);
*return_value = **val;
zval_copy_ctor(return_value);
INIT_PZVAL(return_value);
/* Delete the first or last value */
- new_hash = _phpi_splice(stack->value.ht, (off_the_end) ? -1 : 0, 1, NULL, 0, NULL);
- zend_hash_destroy(stack->value.ht);
- efree(stack->value.ht);
- stack->value.ht = new_hash;
+ new_hash = _phpi_splice((*stack)->value.ht, (off_the_end) ? -1 : 0, 1, NULL, 0, NULL);
+ zend_hash_destroy((*stack)->value.ht);
+ efree((*stack)->value.ht);
+ (*stack)->value.ht = new_hash;
}
/* }}} */
Pushes elements onto the beginning of the array */
PHP_FUNCTION(array_unshift)
{
- zval **args, /* Function arguments array */
+ zval ***args, /* Function arguments array */
*stack; /* Input stack */
HashTable *new_hash; /* New hashtable for the stack */
int argc; /* Number of function arguments */
}
/* Allocate arguments array and get the arguments, checking for errors. */
- args = (zval **)emalloc(argc * sizeof(zval *));
- if (getParametersArray(ht, argc, args) == FAILURE) {
+ args = (zval ***)emalloc(argc * sizeof(zval **));
+ if (getParametersArrayEx(argc, args) == FAILURE) {
efree(args);
WRONG_PARAM_COUNT;
}
/* Get first argument and check that it's an array */
- stack = args[0];
+ stack = *args[0];
if (stack->type != IS_ARRAY) {
- zend_error(E_WARNING, "First argument to push() needs to be an array");
+ zend_error(E_WARNING, "First argument to array_unshift() needs to be an array");
RETURN_FALSE;
}
/* }}} */
-/* {{{ proto array array_splice(array input, int offset [, int length, mixed var [, ...] ])
+/* {{{ proto array array_splice(array input, int offset [, int length [, array replacement]])
Removes the elements designated by offset and length and replace them with
- var's if supplied */
+ supplied array */
PHP_FUNCTION(array_splice)
{
- zval **args, /* Function arguments array */
+ zval ***args, /* Function arguments array */
*array, /* Input array */
- **repl = NULL; /* Replacement elements */
+ ***repl = NULL; /* Replacement elements */
HashTable *new_hash = NULL; /* Output array's hash */
Bucket *p; /* Bucket used for traversing hash */
int argc, /* Number of function arguments */
}
/* Allocate arguments array and get the arguments, checking for errors. */
- args = (zval **)emalloc(argc * sizeof(zval *));
- if (getParametersArray(ht, argc, args) == FAILURE) {
+ args = (zval ***)emalloc(argc * sizeof(zval **));
+ if (getParametersArrayEx(argc, args) == FAILURE) {
efree(args);
WRONG_PARAM_COUNT;
}
/* Get first argument and check that it's an array */
- array = args[0];
+ array = *args[0];
if (array->type != IS_ARRAY) {
- zend_error(E_WARNING, "First argument to splice() should be an array");
+ zend_error(E_WARNING, "First argument to array_splice() should be an array");
efree(args);
return;
}
/* Get the next two arguments. If length is omitted,
it's assumed to be until the end of the array */
- convert_to_long(args[1]);
- offset = args[1]->value.lval;
+ convert_to_long_ex(args[1]);
+ offset = (*args[1])->value.lval;
if (argc > 2) {
- convert_to_long(args[2]);
- length = args[2]->value.lval;
+ convert_to_long_ex(args[2]);
+ length = (*args[2])->value.lval;
} else
length = zend_hash_num_elements(array->value.ht);
if (argc == 4) {
/* Make sure the last argument, if passed, is an array */
- convert_to_array(args[3]);
+ convert_to_array_ex(args[3]);
/* Create the array of replacement elements */
- repl_num = zend_hash_num_elements(args[3]->value.ht);
- repl = (zval **)emalloc(repl_num * sizeof(zval *));
- for (p=args[3]->value.ht->pListHead, i=0; p; p=p->pListNext, i++) {
- repl[i] = *((zval **)p->pData);
+ repl_num = zend_hash_num_elements((*args[3])->value.ht);
+ repl = (zval ***)emalloc(repl_num * sizeof(zval **));
+ for (p=(*args[3])->value.ht->pListHead, i=0; p; p=p->pListNext, i++) {
+ repl[i] = ((zval **)p->pData);
}
}
Returns elements specified by offset and length */
PHP_FUNCTION(array_slice)
{
- zval *input, /* Input array */
- *offset, /* Offset to get elements from */
- *length, /* How many elements to get */
+ zval **input, /* Input array */
+ **offset, /* Offset to get elements from */
+ **length, /* How many elements to get */
**entry; /* An array entry */
int offset_val, /* Value of the offset argument */
length_val, /* Value of the length argument */
/* Get the arguments and do error-checking */
argc = ARG_COUNT(ht);
- if (argc < 2 || argc > 3 || getParameters(ht, argc, &input, &offset, &length)) {
+ if (argc < 2 || argc > 3 || getParametersEx(argc, &input, &offset, &length)) {
WRONG_PARAM_COUNT;
}
- if (input->type != IS_ARRAY) {
- zend_error(E_WARNING, "First argument to slice() should be an array");
+ if ((*input)->type != IS_ARRAY) {
+ zend_error(E_WARNING, "First argument to array_slice() should be an array");
return;
}
/* Make sure offset and length are integers and assume
we want all entries from offset to the end if length
is not passed */
- convert_to_long(offset);
- offset_val = offset->value.lval;
+ convert_to_long_ex(offset);
+ offset_val = (*offset)->value.lval;
if (argc == 3) {
- convert_to_long(length);
- length_val = length->value.lval;
+ convert_to_long_ex(length);
+ length_val = (*length)->value.lval;
} else
- length_val = zend_hash_num_elements(input->value.ht);
+ length_val = zend_hash_num_elements((*input)->value.ht);
/* Initialize returned array */
array_init(return_value);
/* Get number of entries in the input hash */
- num_in = zend_hash_num_elements(input->value.ht);
+ num_in = zend_hash_num_elements((*input)->value.ht);
/* Clamp the offset.. */
if (offset_val > num_in)
/* Start at the beginning and go until we hit offset */
pos = 0;
- zend_hash_internal_pointer_reset(input->value.ht);
+ zend_hash_internal_pointer_reset((*input)->value.ht);
while(pos < offset_val &&
- zend_hash_get_current_data(input->value.ht, (void **)&entry) == SUCCESS) {
+ zend_hash_get_current_data((*input)->value.ht, (void **)&entry) == SUCCESS) {
pos++;
- zend_hash_move_forward(input->value.ht);
+ zend_hash_move_forward((*input)->value.ht);
}
/* Copy elements from input array to the one that's returned */
while(pos < offset_val+length_val &&
- zend_hash_get_current_data(input->value.ht, (void **)&entry) == SUCCESS) {
+ zend_hash_get_current_data((*input)->value.ht, (void **)&entry) == SUCCESS) {
(*entry)->refcount++;
- switch (zend_hash_get_current_key(input->value.ht, &string_key, &num_key)) {
+ switch (zend_hash_get_current_key((*input)->value.ht, &string_key, &num_key)) {
case HASH_KEY_IS_STRING:
zend_hash_update(return_value->value.ht, string_key, strlen(string_key)+1,
entry, sizeof(zval *), NULL);
break;
}
pos++;
- zend_hash_move_forward(input->value.ht);
+ zend_hash_move_forward((*input)->value.ht);
}
}
/* }}} */
Merges elements from passed arrays into one array */
PHP_FUNCTION(array_merge)
{
- zval **args = NULL,
+ zval ***args = NULL,
**entry;
HashTable *hash;
int argc,
}
/* Allocate arguments array and get the arguments, checking for errors. */
- args = (zval **)emalloc(argc * sizeof(zval *));
- if (getParametersArray(ht, argc, args) == FAILURE) {
+ args = (zval ***)emalloc(argc * sizeof(zval **));
+ if (getParametersArrayEx(argc, args) == FAILURE) {
efree(args);
WRONG_PARAM_COUNT;
}
array_init(return_value);
for (i=0; i<argc; i++) {
- if (args[i]->type != IS_ARRAY) {
+ if ((*args[i])->type != IS_ARRAY) {
zend_error(E_WARNING, "Skipping argument #%d to array_merge(), since it's not an array", i+1);
continue;
}
- hash = args[i]->value.ht;
+ hash = (*args[i])->value.ht;
zend_hash_internal_pointer_reset(hash);
while(zend_hash_get_current_data(hash, (void **)&entry) == SUCCESS) {
for the specified search_value */
PHP_FUNCTION(array_keys)
{
- zval *input, /* Input array */
- *search_value, /* Value to search for */
+ zval **input, /* Input array */
+ **search_value, /* Value to search for */
**entry, /* An entry in the input array */
res, /* Result of comparison */
*new_val; /* New value */
/* Get arguments and do error-checking */
if (ARG_COUNT(ht) < 1 || ARG_COUNT(ht) > 2 ||
- getParameters(ht, ARG_COUNT(ht), &input, &search_value) == FAILURE) {
+ getParametersEx(ARG_COUNT(ht), &input, &search_value) == FAILURE) {
WRONG_PARAM_COUNT;
}
- if (input->type != IS_ARRAY) {
+ if ((*input)->type != IS_ARRAY) {
zend_error(E_WARNING, "First argument to array_keys() should be an array");
return;
}
add_key = 1;
/* Go through input array and add keys to the return array */
- zend_hash_internal_pointer_reset(input->value.ht);
- while(zend_hash_get_current_data(input->value.ht, (void **)&entry) == SUCCESS) {
+ zend_hash_internal_pointer_reset((*input)->value.ht);
+ while(zend_hash_get_current_data((*input)->value.ht, (void **)&entry) == SUCCESS) {
if (search_value != NULL) {
- is_equal_function(&res, search_value, *entry);
+ is_equal_function(&res, *search_value, *entry);
add_key = zval_is_true(&res);
}
if (add_key) {
- new_val = (zval *)emalloc(sizeof(zval));
- INIT_PZVAL(new_val);
+ MAKE_STD_ZVAL(new_val);
- switch (zend_hash_get_current_key(input->value.ht, &string_key, &num_key)) {
+ switch (zend_hash_get_current_key((*input)->value.ht, &string_key, &num_key)) {
case HASH_KEY_IS_STRING:
new_val->type = IS_STRING;
new_val->value.str.val = string_key;
}
}
- zend_hash_move_forward(input->value.ht);
+ zend_hash_move_forward((*input)->value.ht);
}
}
/* }}} */
Return just the values from the input array */
PHP_FUNCTION(array_values)
{
- zval *input, /* Input array */
+ zval **input, /* Input array */
**entry; /* An entry in the input array */
/* Get arguments and do error-checking */
- if (ARG_COUNT(ht) != 1 || getParameters(ht, ARG_COUNT(ht), &input) == FAILURE) {
+ if (ARG_COUNT(ht) != 1 || getParametersEx(ARG_COUNT(ht), &input) == FAILURE) {
WRONG_PARAM_COUNT;
}
- if (input->type != IS_ARRAY) {
+ if ((*input)->type != IS_ARRAY) {
zend_error(E_WARNING, "Argument to array_values() should be an array");
return;
}
array_init(return_value);
/* Go through input array and add values to the return array */
- zend_hash_internal_pointer_reset(input->value.ht);
- while(zend_hash_get_current_data(input->value.ht, (void **)&entry) == SUCCESS) {
+ zend_hash_internal_pointer_reset((*input)->value.ht);
+ while(zend_hash_get_current_data((*input)->value.ht, (void **)&entry) == SUCCESS) {
(*entry)->refcount++;
zend_hash_next_index_insert(return_value->value.ht, entry,
sizeof(zval *), NULL);
- zend_hash_move_forward(input->value.ht);
+ zend_hash_move_forward((*input)->value.ht);
}
}
/* }}} */
projects / php / commitdiff