}
/* }}} */
-/* {{{ spl_functions
- */
-static const zend_function_entry spl_functions[] = {
- PHP_FE(spl_classes, arginfo_spl_classes)
- PHP_FE(spl_autoload, arginfo_spl_autoload)
- PHP_FE(spl_autoload_extensions, arginfo_spl_autoload_extensions)
- PHP_FE(spl_autoload_register, arginfo_spl_autoload_register)
- PHP_FE(spl_autoload_unregister, arginfo_spl_autoload_unregister)
- PHP_FE(spl_autoload_functions, arginfo_spl_autoload_functions)
- PHP_FE(spl_autoload_call, arginfo_spl_autoload_call)
- PHP_FE(class_parents, arginfo_class_parents)
- PHP_FE(class_implements, arginfo_class_implements)
- PHP_FE(class_uses, arginfo_class_uses)
- PHP_FE(spl_object_hash, arginfo_spl_object_hash)
- PHP_FE(spl_object_id, arginfo_spl_object_id)
- PHP_FE(iterator_to_array, arginfo_iterator_to_array)
- PHP_FE(iterator_count, arginfo_iterator_count)
- PHP_FE(iterator_apply, arginfo_iterator_apply)
- PHP_FE_END
-};
-/* }}} */
-
/* {{{ PHP_MINIT_FUNCTION(spl)
*/
PHP_MINIT_FUNCTION(spl)
zend_module_entry spl_module_entry = {
STANDARD_MODULE_HEADER,
"SPL",
- spl_functions,
+ ext_functions,
PHP_MINIT(spl),
NULL,
PHP_RINIT(spl),
ZEND_EXTERN_MODULE_GLOBALS(spl)
#define SPL_G(v) ZEND_MODULE_GLOBALS_ACCESSOR(spl, v)
-PHP_FUNCTION(spl_classes);
-PHP_FUNCTION(class_parents);
-PHP_FUNCTION(class_implements);
-PHP_FUNCTION(class_uses);
-
PHPAPI zend_string *php_spl_object_hash(zval *obj);
#endif /* PHP_SPL_H */
<?php
+/** @generate-function-entries */
+
function class_implements($what, bool $autoload = true): array|false {}
function class_parents($instance, bool $autoload = true): array|false {}
ZEND_ARG_OBJ_INFO(0, iterator, Traversable, 0)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, use_keys, _IS_BOOL, 0, "true")
ZEND_END_ARG_INFO()
+
+
+ZEND_FUNCTION(class_implements);
+ZEND_FUNCTION(class_parents);
+ZEND_FUNCTION(class_uses);
+ZEND_FUNCTION(spl_autoload);
+ZEND_FUNCTION(spl_autoload_call);
+ZEND_FUNCTION(spl_autoload_extensions);
+ZEND_FUNCTION(spl_autoload_functions);
+ZEND_FUNCTION(spl_autoload_register);
+ZEND_FUNCTION(spl_autoload_unregister);
+ZEND_FUNCTION(spl_classes);
+ZEND_FUNCTION(spl_object_hash);
+ZEND_FUNCTION(spl_object_id);
+ZEND_FUNCTION(iterator_apply);
+ZEND_FUNCTION(iterator_count);
+ZEND_FUNCTION(iterator_to_array);
+
+
+static const zend_function_entry ext_functions[] = {
+ ZEND_FE(class_implements, arginfo_class_implements)
+ ZEND_FE(class_parents, arginfo_class_parents)
+ ZEND_FE(class_uses, arginfo_class_uses)
+ ZEND_FE(spl_autoload, arginfo_spl_autoload)
+ ZEND_FE(spl_autoload_call, arginfo_spl_autoload_call)
+ ZEND_FE(spl_autoload_extensions, arginfo_spl_autoload_extensions)
+ ZEND_FE(spl_autoload_functions, arginfo_spl_autoload_functions)
+ ZEND_FE(spl_autoload_register, arginfo_spl_autoload_register)
+ ZEND_FE(spl_autoload_unregister, arginfo_spl_autoload_unregister)
+ ZEND_FE(spl_classes, arginfo_spl_classes)
+ ZEND_FE(spl_object_hash, arginfo_spl_object_hash)
+ ZEND_FE(spl_object_id, arginfo_spl_object_id)
+ ZEND_FE(iterator_apply, arginfo_iterator_apply)
+ ZEND_FE(iterator_count, arginfo_iterator_count)
+ ZEND_FE(iterator_to_array, arginfo_iterator_to_array)
+ ZEND_FE_END
+};
/* {{{ proto bool ArrayObject::offsetExists(mixed $index)
proto bool ArrayIterator::offsetExists(mixed $index)
Returns whether the requested $index exists. */
-SPL_METHOD(Array, offsetExists)
+PHP_METHOD(ArrayObject, offsetExists)
{
zval *index;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &index) == FAILURE) {
/* {{{ proto mixed ArrayObject::offsetGet(mixed $index)
proto mixed ArrayIterator::offsetGet(mixed $index)
Returns the value at the specified $index. */
-SPL_METHOD(Array, offsetGet)
+PHP_METHOD(ArrayObject, offsetGet)
{
zval *value, *index;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &index) == FAILURE) {
/* {{{ proto void ArrayObject::offsetSet(mixed $index, mixed $newval)
proto void ArrayIterator::offsetSet(mixed $index, mixed $newval)
Sets the value at the specified $index to $newval. */
-SPL_METHOD(Array, offsetSet)
+PHP_METHOD(ArrayObject, offsetSet)
{
zval *index, *value;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &index, &value) == FAILURE) {
/* {{{ proto void ArrayObject::append(mixed $newval)
proto void ArrayIterator::append(mixed $newval)
Appends the value (cannot be called for objects). */
-SPL_METHOD(Array, append)
+PHP_METHOD(ArrayObject, append)
{
zval *value;
/* {{{ proto void ArrayObject::offsetUnset(mixed $index)
proto void ArrayIterator::offsetUnset(mixed $index)
Unsets the value at the specified $index. */
-SPL_METHOD(Array, offsetUnset)
+PHP_METHOD(ArrayObject, offsetUnset)
{
zval *index;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &index) == FAILURE) {
/* {{{ proto array ArrayObject::getArrayCopy()
proto array ArrayIterator::getArrayCopy()
Return a copy of the contained array */
-SPL_METHOD(Array, getArrayCopy)
+PHP_METHOD(ArrayObject, getArrayCopy)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto ArrayObject::__construct([array|object ar = array() [, int flags = 0 [, string iterator_class = "ArrayIterator"]]])
Constructs a new array object from an array or object. */
-SPL_METHOD(Array, __construct)
+PHP_METHOD(ArrayObject, __construct)
{
zval *object = ZEND_THIS;
spl_array_object *intern;
/* {{{ proto ArrayIterator::__construct([array|object ar = array() [, int flags = 0]])
Constructs a new array iterator from an array or object. */
-SPL_METHOD(ArrayIterator, __construct)
+PHP_METHOD(ArrayIterator, __construct)
{
zval *object = ZEND_THIS;
spl_array_object *intern;
/* {{{ proto void ArrayObject::setIteratorClass(string iterator_class)
Set the class used in getIterator. */
-SPL_METHOD(Array, setIteratorClass)
+PHP_METHOD(ArrayObject, setIteratorClass)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto string ArrayObject::getIteratorClass()
Get the class used in getIterator. */
-SPL_METHOD(Array, getIteratorClass)
+PHP_METHOD(ArrayObject, getIteratorClass)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto int ArrayObject::getFlags()
Get flags */
-SPL_METHOD(Array, getFlags)
+PHP_METHOD(ArrayObject, getFlags)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto void ArrayObject::setFlags(int flags)
Set flags */
-SPL_METHOD(Array, setFlags)
+PHP_METHOD(ArrayObject, setFlags)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto Array|Object ArrayObject::exchangeArray(Array|Object input = array())
Replace the referenced array or object with a new one and return the old one (right now copy - to be changed) */
-SPL_METHOD(Array, exchangeArray)
+PHP_METHOD(ArrayObject, exchangeArray)
{
zval *object = ZEND_THIS, *array;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto ArrayIterator ArrayObject::getIterator()
Create a new iterator from a ArrayObject instance */
-SPL_METHOD(Array, getIterator)
+PHP_METHOD(ArrayObject, getIterator)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto void ArrayIterator::rewind()
Rewind array back to the start */
-SPL_METHOD(Array, rewind)
+PHP_METHOD(ArrayIterator, rewind)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto void ArrayIterator::seek(int $position)
Seek to position. */
-SPL_METHOD(Array, seek)
+PHP_METHOD(ArrayIterator, seek)
{
zend_long opos, position;
zval *object = ZEND_THIS;
/* {{{ proto int ArrayObject::count()
proto int ArrayIterator::count()
Return the number of elements in the Iterator. */
-SPL_METHOD(Array, count)
+PHP_METHOD(ArrayObject, count)
{
spl_array_object *intern = Z_SPLARRAY_P(ZEND_THIS);
} /* }}} */
#define SPL_ARRAY_METHOD(cname, fname, use_arg) \
-SPL_METHOD(cname, fname) \
+PHP_METHOD(cname, fname) \
{ \
spl_array_method(INTERNAL_FUNCTION_PARAM_PASSTHRU, #fname, sizeof(#fname)-1, use_arg); \
}
/* {{{ proto int ArrayObject::asort([int $sort_flags = SORT_REGULAR ])
proto int ArrayIterator::asort([int $sort_flags = SORT_REGULAR ])
Sort the entries by values. */
-SPL_ARRAY_METHOD(Array, asort, SPL_ARRAY_METHOD_MAY_USER_ARG) /* }}} */
+SPL_ARRAY_METHOD(ArrayObject, asort, SPL_ARRAY_METHOD_MAY_USER_ARG) /* }}} */
/* {{{ proto int ArrayObject::ksort([int $sort_flags = SORT_REGULAR ])
proto int ArrayIterator::ksort([int $sort_flags = SORT_REGULAR ])
Sort the entries by key. */
-SPL_ARRAY_METHOD(Array, ksort, SPL_ARRAY_METHOD_MAY_USER_ARG) /* }}} */
+SPL_ARRAY_METHOD(ArrayObject, ksort, SPL_ARRAY_METHOD_MAY_USER_ARG) /* }}} */
/* {{{ proto int ArrayObject::uasort(callback cmp_function)
proto int ArrayIterator::uasort(callback cmp_function)
Sort the entries by values user defined function. */
-SPL_ARRAY_METHOD(Array, uasort, SPL_ARRAY_METHOD_USE_ARG) /* }}} */
+SPL_ARRAY_METHOD(ArrayObject, uasort, SPL_ARRAY_METHOD_USE_ARG) /* }}} */
/* {{{ proto int ArrayObject::uksort(callback cmp_function)
proto int ArrayIterator::uksort(callback cmp_function)
Sort the entries by key using user defined function. */
-SPL_ARRAY_METHOD(Array, uksort, SPL_ARRAY_METHOD_USE_ARG) /* }}} */
+SPL_ARRAY_METHOD(ArrayObject, uksort, SPL_ARRAY_METHOD_USE_ARG) /* }}} */
/* {{{ proto int ArrayObject::natsort()
proto int ArrayIterator::natsort()
Sort the entries by values using "natural order" algorithm. */
-SPL_ARRAY_METHOD(Array, natsort, SPL_ARRAY_METHOD_NO_ARG) /* }}} */
+SPL_ARRAY_METHOD(ArrayObject, natsort, SPL_ARRAY_METHOD_NO_ARG) /* }}} */
/* {{{ proto int ArrayObject::natcasesort()
proto int ArrayIterator::natcasesort()
Sort the entries by key using case insensitive "natural order" algorithm. */
-SPL_ARRAY_METHOD(Array, natcasesort, SPL_ARRAY_METHOD_NO_ARG) /* }}} */
+SPL_ARRAY_METHOD(ArrayObject, natcasesort, SPL_ARRAY_METHOD_NO_ARG) /* }}} */
/* {{{ proto mixed|NULL ArrayIterator::current()
Return current array entry */
-SPL_METHOD(Array, current)
+PHP_METHOD(ArrayIterator, current)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto mixed|NULL ArrayIterator::key()
Return current array key */
-SPL_METHOD(Array, key)
+PHP_METHOD(ArrayIterator, key)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto void ArrayIterator::next()
Move to next entry */
-SPL_METHOD(Array, next)
+PHP_METHOD(ArrayIterator, next)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto bool ArrayIterator::valid()
Check whether array contains more entries */
-SPL_METHOD(Array, valid)
+PHP_METHOD(ArrayIterator, valid)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto bool RecursiveArrayIterator::hasChildren()
Check whether current element has children (e.g. is an array) */
-SPL_METHOD(Array, hasChildren)
+PHP_METHOD(RecursiveArrayIterator, hasChildren)
{
zval *object = ZEND_THIS, *entry;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto object RecursiveArrayIterator::getChildren()
Create a sub iterator for the current element (same class as $this) */
-SPL_METHOD(Array, getChildren)
+PHP_METHOD(RecursiveArrayIterator, getChildren)
{
zval *object = ZEND_THIS, *entry, flags;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto string ArrayObject::serialize()
Serialize the object */
-SPL_METHOD(Array, serialize)
+PHP_METHOD(ArrayObject, serialize)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
/* {{{ proto void ArrayObject::unserialize(string serialized)
* unserialize the object
*/
-SPL_METHOD(Array, unserialize)
+PHP_METHOD(ArrayObject, unserialize)
{
zval *object = ZEND_THIS;
spl_array_object *intern = Z_SPLARRAY_P(object);
} /* }}} */
/* {{{ proto array ArrayObject::__serialize() */
-SPL_METHOD(Array, __serialize)
+PHP_METHOD(ArrayObject, __serialize)
{
spl_array_object *intern = Z_SPLARRAY_P(ZEND_THIS);
zval tmp;
/* {{{ proto void ArrayObject::__unserialize(array data) */
-SPL_METHOD(Array, __unserialize)
+PHP_METHOD(ArrayObject, __unserialize)
{
spl_array_object *intern = Z_SPLARRAY_P(ZEND_THIS);
HashTable *data;
/* }}} */
/* {{{ proto void Array::__debugInfo() */
-SPL_METHOD(Array, __debugInfo)
+PHP_METHOD(ArrayObject, __debugInfo)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
RETURN_ARR(spl_array_get_debug_info(Z_OBJ_P(ZEND_THIS)));
} /* }}} */
-static const zend_function_entry spl_funcs_ArrayObject[] = {
- SPL_ME(Array, __construct, arginfo_class_ArrayObject___construct, ZEND_ACC_PUBLIC)
- SPL_ME(Array, offsetExists, arginfo_class_ArrayObject_offsetExists, ZEND_ACC_PUBLIC)
- SPL_ME(Array, offsetGet, arginfo_class_ArrayObject_offsetGet, ZEND_ACC_PUBLIC)
- SPL_ME(Array, offsetSet, arginfo_class_ArrayObject_offsetSet, ZEND_ACC_PUBLIC)
- SPL_ME(Array, offsetUnset, arginfo_class_ArrayObject_offsetUnset, ZEND_ACC_PUBLIC)
- SPL_ME(Array, append, arginfo_class_ArrayObject_append, ZEND_ACC_PUBLIC)
- SPL_ME(Array, getArrayCopy, arginfo_class_ArrayObject_getArrayCopy, ZEND_ACC_PUBLIC)
- SPL_ME(Array, count, arginfo_class_ArrayObject_count, ZEND_ACC_PUBLIC)
- SPL_ME(Array, getFlags, arginfo_class_ArrayObject_getFlags, ZEND_ACC_PUBLIC)
- SPL_ME(Array, setFlags, arginfo_class_ArrayObject_setFlags, ZEND_ACC_PUBLIC)
- SPL_ME(Array, asort, arginfo_class_ArrayObject_asort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, ksort, arginfo_class_ArrayObject_ksort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, uasort, arginfo_class_ArrayObject_uasort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, uksort, arginfo_class_ArrayObject_uksort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, natsort, arginfo_class_ArrayObject_natsort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, natcasesort, arginfo_class_ArrayObject_natcasesort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, unserialize, arginfo_class_ArrayObject_unserialize, ZEND_ACC_PUBLIC)
- SPL_ME(Array, serialize, arginfo_class_ArrayObject_serialize, ZEND_ACC_PUBLIC)
- SPL_ME(Array, __unserialize, arginfo_class_ArrayObject___unserialize, ZEND_ACC_PUBLIC)
- SPL_ME(Array, __serialize, arginfo_class_ArrayObject___serialize, ZEND_ACC_PUBLIC)
- SPL_ME(Array, __debugInfo, arginfo_class_ArrayObject___debugInfo, ZEND_ACC_PUBLIC)
- /* ArrayObject specific */
- SPL_ME(Array, getIterator, arginfo_class_ArrayObject_getIterator, ZEND_ACC_PUBLIC)
- SPL_ME(Array, exchangeArray, arginfo_class_ArrayObject_exchangeArray, ZEND_ACC_PUBLIC)
- SPL_ME(Array, setIteratorClass, arginfo_class_ArrayObject_setIteratorClass, ZEND_ACC_PUBLIC)
- SPL_ME(Array, getIteratorClass, arginfo_class_ArrayObject_getIteratorClass, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_ArrayIterator[] = {
- SPL_ME(ArrayIterator, __construct, arginfo_class_ArrayIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(Array, offsetExists, arginfo_class_ArrayIterator_offsetExists, ZEND_ACC_PUBLIC)
- SPL_ME(Array, offsetGet, arginfo_class_ArrayIterator_offsetGet, ZEND_ACC_PUBLIC)
- SPL_ME(Array, offsetSet, arginfo_class_ArrayIterator_offsetSet, ZEND_ACC_PUBLIC)
- SPL_ME(Array, offsetUnset, arginfo_class_ArrayIterator_offsetUnset, ZEND_ACC_PUBLIC)
- SPL_ME(Array, append, arginfo_class_ArrayIterator_append, ZEND_ACC_PUBLIC)
- SPL_ME(Array, getArrayCopy, arginfo_class_ArrayIterator_getArrayCopy, ZEND_ACC_PUBLIC)
- SPL_ME(Array, count, arginfo_class_ArrayIterator_count, ZEND_ACC_PUBLIC)
- SPL_ME(Array, getFlags, arginfo_class_ArrayIterator_getFlags, ZEND_ACC_PUBLIC)
- SPL_ME(Array, setFlags, arginfo_class_ArrayIterator_setFlags, ZEND_ACC_PUBLIC)
- SPL_ME(Array, asort, arginfo_class_ArrayIterator_asort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, ksort, arginfo_class_ArrayIterator_ksort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, uasort, arginfo_class_ArrayIterator_uasort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, uksort, arginfo_class_ArrayIterator_uksort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, natsort, arginfo_class_ArrayIterator_natsort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, natcasesort, arginfo_class_ArrayIterator_natcasesort, ZEND_ACC_PUBLIC)
- SPL_ME(Array, unserialize, arginfo_class_ArrayIterator_unserialize, ZEND_ACC_PUBLIC)
- SPL_ME(Array, serialize, arginfo_class_ArrayIterator_serialize, ZEND_ACC_PUBLIC)
- SPL_ME(Array, __unserialize, arginfo_class_ArrayIterator___unserialize, ZEND_ACC_PUBLIC)
- SPL_ME(Array, __serialize, arginfo_class_ArrayIterator___serialize, ZEND_ACC_PUBLIC)
- SPL_ME(Array, __debugInfo, arginfo_class_ArrayIterator___debugInfo, ZEND_ACC_PUBLIC)
- /* ArrayIterator specific */
- SPL_ME(Array, rewind, arginfo_class_ArrayIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(Array, current, arginfo_class_ArrayIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(Array, key, arginfo_class_ArrayIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(Array, next, arginfo_class_ArrayIterator_next, ZEND_ACC_PUBLIC)
- SPL_ME(Array, valid, arginfo_class_ArrayIterator_valid, ZEND_ACC_PUBLIC)
- SPL_ME(Array, seek, arginfo_class_ArrayIterator_seek, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_RecursiveArrayIterator[] = {
- SPL_ME(Array, hasChildren, arginfo_class_RecursiveArrayIterator_hasChildren, ZEND_ACC_PUBLIC)
- SPL_ME(Array, getChildren, arginfo_class_RecursiveArrayIterator_getChildren, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-/* }}} */
-
/* {{{ PHP_MINIT_FUNCTION(spl_array) */
PHP_MINIT_FUNCTION(spl_array)
{
- REGISTER_SPL_STD_CLASS_EX(ArrayObject, spl_array_object_new, spl_funcs_ArrayObject);
+ REGISTER_SPL_STD_CLASS_EX(ArrayObject, spl_array_object_new, class_ArrayObject_methods);
REGISTER_SPL_IMPLEMENTS(ArrayObject, Aggregate);
REGISTER_SPL_IMPLEMENTS(ArrayObject, ArrayAccess);
REGISTER_SPL_IMPLEMENTS(ArrayObject, Serializable);
spl_handler_ArrayObject.dtor_obj = zend_objects_destroy_object;
spl_handler_ArrayObject.free_obj = spl_array_object_free_storage;
- REGISTER_SPL_STD_CLASS_EX(ArrayIterator, spl_array_object_new, spl_funcs_ArrayIterator);
+ REGISTER_SPL_STD_CLASS_EX(ArrayIterator, spl_array_object_new, class_ArrayIterator_methods);
REGISTER_SPL_IMPLEMENTS(ArrayIterator, Iterator);
REGISTER_SPL_IMPLEMENTS(ArrayIterator, ArrayAccess);
REGISTER_SPL_IMPLEMENTS(ArrayIterator, SeekableIterator);
REGISTER_SPL_CLASS_CONST_LONG(ArrayIterator, "STD_PROP_LIST", SPL_ARRAY_STD_PROP_LIST);
REGISTER_SPL_CLASS_CONST_LONG(ArrayIterator, "ARRAY_AS_PROPS", SPL_ARRAY_ARRAY_AS_PROPS);
- REGISTER_SPL_SUB_CLASS_EX(RecursiveArrayIterator, ArrayIterator, spl_array_object_new, spl_funcs_RecursiveArrayIterator);
+ REGISTER_SPL_SUB_CLASS_EX(RecursiveArrayIterator, ArrayIterator, spl_array_object_new, class_RecursiveArrayIterator_methods);
REGISTER_SPL_IMPLEMENTS(RecursiveArrayIterator, RecursiveIterator);
spl_ce_RecursiveArrayIterator->get_iterator = spl_array_get_iterator;
spl_ce_RecursiveArrayIterator->ce_flags |= ZEND_ACC_REUSE_GET_ITERATOR;
<?php
+/** @generate-function-entries */
+
class ArrayObject implements IteratorAggregate, ArrayAccess, Serializable, Countable
{
/** @param array|object $input */
/**
* @param mixed $index
* @return bool
+ * @alias ArrayObject::offsetExists
*/
public function offsetExists($index) {}
/**
* @param mixed $index
* @return mixed
+ * @alias ArrayObject::offsetGet
*/
public function offsetGet($index) {}
* @param mixed $index
* @param mixed $value
* @return void
+ * @alias ArrayObject::offsetSet
*/
public function offsetSet($index, $value) {}
/**
* @param mixed $index
* @return void
+ * @alias ArrayObject::offsetUnset
*/
public function offsetUnset($index) {}
/**
* @param mixed $value
* @return void
+ * @alias ArrayObject::append
*/
public function append($value) {}
- /** @return array */
+ /**
+ * @return array
+ * @alias ArrayObject::getArrayCopy
+ */
public function getArrayCopy() {}
- /** @return int */
+ /**
+ * @return int
+ * @alias ArrayObject::count
+ */
public function count() {}
- /** @return int */
+ /**
+ * @return int
+ * @alias ArrayObject::getFlags
+ */
public function getFlags() {}
- /** @return void */
+ /**
+ * @return void
+ * @alias ArrayObject::setFlags
+ */
public function setFlags(int $flags) {}
/**
* @param int $sort_flags
* @return bool
+ * @alias ArrayObject::asort
*/
public function asort($sort_flags = SORT_REGULAR) {}
/**
* @param int $sort_flags
* @return bool
+ * @alias ArrayObject::offsetExists
*/
public function ksort($sort_flags = SORT_REGULAR) {}
/**
* @param callback $cmp_function
* @return bool
+ * @alias ArrayObject::uasort
*/
public function uasort($cmp_function) {}
/**
* @param callback $cmp_function
* @return bool
+ * @alias ArrayObject::uksort
*/
public function uksort($cmp_function) {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias ArrayObject::natsort
+ */
public function natsort() {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias ArrayObject::natcasesort
+ */
public function natcasesort() {}
- /** @return void */
+ /**
+ * @return void
+ * @alias ArrayObject::unserialize
+ */
public function unserialize(string $serialized) {}
- /** @return string */
+ /**
+ * @return string
+ * @alias ArrayObject::serialize
+ */
public function serialize() {}
- /** @return array */
+ /**
+ * @return array
+ * @alias ArrayObject::__serialize
+ */
public function __serialize() {}
- /** @return void */
+ /**
+ * @return void
+ * @alias ArrayObject::__unserialize
+ */
public function __unserialize(array $data) {}
/** @return void */
/** @return void */
public function seek(int $position) {}
- /** @return array */
+ /**
+ * @return array
+ * @alias ArrayObject::__debugInfo
+ */
public function __debugInfo() {}
}
#define arginfo_class_RecursiveArrayIterator_hasChildren arginfo_class_ArrayObject_getArrayCopy
#define arginfo_class_RecursiveArrayIterator_getChildren arginfo_class_ArrayObject_getArrayCopy
+
+
+ZEND_METHOD(ArrayObject, __construct);
+ZEND_METHOD(ArrayObject, offsetExists);
+ZEND_METHOD(ArrayObject, offsetGet);
+ZEND_METHOD(ArrayObject, offsetSet);
+ZEND_METHOD(ArrayObject, offsetUnset);
+ZEND_METHOD(ArrayObject, append);
+ZEND_METHOD(ArrayObject, getArrayCopy);
+ZEND_METHOD(ArrayObject, count);
+ZEND_METHOD(ArrayObject, getFlags);
+ZEND_METHOD(ArrayObject, setFlags);
+ZEND_METHOD(ArrayObject, asort);
+ZEND_METHOD(ArrayObject, ksort);
+ZEND_METHOD(ArrayObject, uasort);
+ZEND_METHOD(ArrayObject, uksort);
+ZEND_METHOD(ArrayObject, natsort);
+ZEND_METHOD(ArrayObject, natcasesort);
+ZEND_METHOD(ArrayObject, unserialize);
+ZEND_METHOD(ArrayObject, serialize);
+ZEND_METHOD(ArrayObject, __serialize);
+ZEND_METHOD(ArrayObject, __unserialize);
+ZEND_METHOD(ArrayObject, getIterator);
+ZEND_METHOD(ArrayObject, exchangeArray);
+ZEND_METHOD(ArrayObject, setIteratorClass);
+ZEND_METHOD(ArrayObject, getIteratorClass);
+ZEND_METHOD(ArrayObject, __debugInfo);
+ZEND_METHOD(ArrayIterator, __construct);
+ZEND_METHOD(ArrayIterator, rewind);
+ZEND_METHOD(ArrayIterator, current);
+ZEND_METHOD(ArrayIterator, key);
+ZEND_METHOD(ArrayIterator, next);
+ZEND_METHOD(ArrayIterator, valid);
+ZEND_METHOD(ArrayIterator, seek);
+ZEND_METHOD(RecursiveArrayIterator, hasChildren);
+ZEND_METHOD(RecursiveArrayIterator, getChildren);
+
+
+static const zend_function_entry class_ArrayObject_methods[] = {
+ ZEND_ME(ArrayObject, __construct, arginfo_class_ArrayObject___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, offsetExists, arginfo_class_ArrayObject_offsetExists, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, offsetGet, arginfo_class_ArrayObject_offsetGet, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, offsetSet, arginfo_class_ArrayObject_offsetSet, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, offsetUnset, arginfo_class_ArrayObject_offsetUnset, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, append, arginfo_class_ArrayObject_append, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, getArrayCopy, arginfo_class_ArrayObject_getArrayCopy, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, count, arginfo_class_ArrayObject_count, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, getFlags, arginfo_class_ArrayObject_getFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, setFlags, arginfo_class_ArrayObject_setFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, asort, arginfo_class_ArrayObject_asort, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, ksort, arginfo_class_ArrayObject_ksort, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, uasort, arginfo_class_ArrayObject_uasort, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, uksort, arginfo_class_ArrayObject_uksort, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, natsort, arginfo_class_ArrayObject_natsort, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, natcasesort, arginfo_class_ArrayObject_natcasesort, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, unserialize, arginfo_class_ArrayObject_unserialize, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, serialize, arginfo_class_ArrayObject_serialize, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, __serialize, arginfo_class_ArrayObject___serialize, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, __unserialize, arginfo_class_ArrayObject___unserialize, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, getIterator, arginfo_class_ArrayObject_getIterator, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, exchangeArray, arginfo_class_ArrayObject_exchangeArray, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, setIteratorClass, arginfo_class_ArrayObject_setIteratorClass, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, getIteratorClass, arginfo_class_ArrayObject_getIteratorClass, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayObject, __debugInfo, arginfo_class_ArrayObject___debugInfo, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ArrayIterator_methods[] = {
+ ZEND_ME(ArrayIterator, __construct, arginfo_class_ArrayIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, offsetExists, offsetExists, arginfo_class_ArrayIterator_offsetExists, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, offsetGet, offsetGet, arginfo_class_ArrayIterator_offsetGet, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, offsetSet, offsetSet, arginfo_class_ArrayIterator_offsetSet, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, offsetUnset, offsetUnset, arginfo_class_ArrayIterator_offsetUnset, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, append, append, arginfo_class_ArrayIterator_append, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, getArrayCopy, getArrayCopy, arginfo_class_ArrayIterator_getArrayCopy, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, count, count, arginfo_class_ArrayIterator_count, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, getFlags, getFlags, arginfo_class_ArrayIterator_getFlags, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, setFlags, setFlags, arginfo_class_ArrayIterator_setFlags, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, asort, asort, arginfo_class_ArrayIterator_asort, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, ksort, offsetExists, arginfo_class_ArrayIterator_ksort, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, uasort, uasort, arginfo_class_ArrayIterator_uasort, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, uksort, uksort, arginfo_class_ArrayIterator_uksort, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, natsort, natsort, arginfo_class_ArrayIterator_natsort, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, natcasesort, natcasesort, arginfo_class_ArrayIterator_natcasesort, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, unserialize, unserialize, arginfo_class_ArrayIterator_unserialize, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, serialize, serialize, arginfo_class_ArrayIterator_serialize, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, __serialize, __serialize, arginfo_class_ArrayIterator___serialize, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, __unserialize, __unserialize, arginfo_class_ArrayIterator___unserialize, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayIterator, rewind, arginfo_class_ArrayIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayIterator, current, arginfo_class_ArrayIterator_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayIterator, key, arginfo_class_ArrayIterator_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayIterator, next, arginfo_class_ArrayIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayIterator, valid, arginfo_class_ArrayIterator_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(ArrayIterator, seek, arginfo_class_ArrayIterator_seek, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(ArrayObject, __debugInfo, __debugInfo, arginfo_class_ArrayIterator___debugInfo, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RecursiveArrayIterator_methods[] = {
+ ZEND_ME(RecursiveArrayIterator, hasChildren, arginfo_class_RecursiveArrayIterator_hasChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveArrayIterator, getChildren, arginfo_class_RecursiveArrayIterator_getChildren, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
/* {{{ proto DirectoryIterator::__construct(string path)
Cronstructs a new dir iterator from a path. */
-SPL_METHOD(DirectoryIterator, __construct)
+PHP_METHOD(DirectoryIterator, __construct)
{
spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* {{{ proto void DirectoryIterator::rewind()
Rewind dir back to the start */
-SPL_METHOD(DirectoryIterator, rewind)
+PHP_METHOD(DirectoryIterator, rewind)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto string DirectoryIterator::key()
Return current dir entry */
-SPL_METHOD(DirectoryIterator, key)
+PHP_METHOD(DirectoryIterator, key)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto DirectoryIterator DirectoryIterator::current()
Return this (needed for Iterator interface) */
-SPL_METHOD(DirectoryIterator, current)
+PHP_METHOD(DirectoryIterator, current)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto void DirectoryIterator::next()
Move to next entry */
-SPL_METHOD(DirectoryIterator, next)
+PHP_METHOD(DirectoryIterator, next)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
int skip_dots = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_SKIPDOTS);
/* {{{ proto void DirectoryIterator::seek(int position)
Seek to the given position */
-SPL_METHOD(DirectoryIterator, seek)
+PHP_METHOD(DirectoryIterator, seek)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zval retval;
/* {{{ proto string DirectoryIterator::valid()
Check whether dir contains more entries */
-SPL_METHOD(DirectoryIterator, valid)
+PHP_METHOD(DirectoryIterator, valid)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto string SplFileInfo::getPath()
Return the path */
-SPL_METHOD(SplFileInfo, getPath)
+PHP_METHOD(SplFileInfo, getPath)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char *path;
/* {{{ proto string SplFileInfo::getFilename()
Return filename only */
-SPL_METHOD(SplFileInfo, getFilename)
+PHP_METHOD(SplFileInfo, getFilename)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
size_t path_len;
/* {{{ proto string DirectoryIterator::getFilename()
Return filename of current dir entry */
-SPL_METHOD(DirectoryIterator, getFilename)
+PHP_METHOD(DirectoryIterator, getFilename)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto string SplFileInfo::getExtension()
Returns file extension component of path */
-SPL_METHOD(SplFileInfo, getExtension)
+PHP_METHOD(SplFileInfo, getExtension)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char *fname = NULL;
/* {{{ proto string DirectoryIterator::getExtension()
Returns the file extension component of path */
-SPL_METHOD(DirectoryIterator, getExtension)
+PHP_METHOD(DirectoryIterator, getExtension)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
const char *p;
/* {{{ proto string SplFileInfo::getBasename([string $suffix])
Returns filename component of path */
-SPL_METHOD(SplFileInfo, getBasename)
+PHP_METHOD(SplFileInfo, getBasename)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char *fname, *suffix = 0;
/* {{{ proto string DirectoryIterator::getBasename([string $suffix])
Returns filename component of current dir entry */
-SPL_METHOD(DirectoryIterator, getBasename)
+PHP_METHOD(DirectoryIterator, getBasename)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char *suffix = 0;
/* {{{ proto string SplFileInfo::getPathname()
Return path and filename */
-SPL_METHOD(SplFileInfo, getPathname)
+PHP_METHOD(SplFileInfo, getPathname)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char *path;
/* {{{ proto string FilesystemIterator::key()
Return getPathname() or getFilename() depending on flags */
-SPL_METHOD(FilesystemIterator, key)
+PHP_METHOD(FilesystemIterator, key)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto string FilesystemIterator::current()
Return getFilename(), getFileInfo() or $this depending on flags */
-SPL_METHOD(FilesystemIterator, current)
+PHP_METHOD(FilesystemIterator, current)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto bool DirectoryIterator::isDot()
Returns true if current entry is '.' or '..' */
-SPL_METHOD(DirectoryIterator, isDot)
+PHP_METHOD(DirectoryIterator, isDot)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* When the constructor gets called the object is already created
by the engine, so we must only call 'additional' initializations.
*/
-SPL_METHOD(SplFileInfo, __construct)
+PHP_METHOD(SplFileInfo, __construct)
{
spl_filesystem_object *intern;
char *path;
/* {{{ FileInfoFunction */
#define FileInfoFunction(func_name, func_num) \
-SPL_METHOD(SplFileInfo, func_name) \
+PHP_METHOD(SplFileInfo, func_name) \
{ \
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS); \
zend_error_handling error_handling; \
/* {{{ proto string SplFileInfo::getLinkTarget()
Return the target of a symbolic link */
-SPL_METHOD(SplFileInfo, getLinkTarget)
+PHP_METHOD(SplFileInfo, getLinkTarget)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
ssize_t ret;
/* {{{ proto string SplFileInfo::getRealPath()
Return the resolved path */
-SPL_METHOD(SplFileInfo, getRealPath)
+PHP_METHOD(SplFileInfo, getRealPath)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char buff[MAXPATHLEN];
/* {{{ proto SplFileObject SplFileInfo::openFile([string mode = 'r' [, bool use_include_path [, resource context]]])
Open the current file */
-SPL_METHOD(SplFileInfo, openFile)
+PHP_METHOD(SplFileInfo, openFile)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto void SplFileInfo::setFileClass([string class_name])
Class to use in openFile() */
-SPL_METHOD(SplFileInfo, setFileClass)
+PHP_METHOD(SplFileInfo, setFileClass)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zend_class_entry *ce = spl_ce_SplFileObject;
/* {{{ proto void SplFileInfo::setInfoClass([string class_name])
Class to use in getFileInfo(), getPathInfo() */
-SPL_METHOD(SplFileInfo, setInfoClass)
+PHP_METHOD(SplFileInfo, setInfoClass)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zend_class_entry *ce = spl_ce_SplFileInfo;
/* {{{ proto SplFileInfo SplFileInfo::getFileInfo([string $class_name])
Get/copy file info */
-SPL_METHOD(SplFileInfo, getFileInfo)
+PHP_METHOD(SplFileInfo, getFileInfo)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zend_class_entry *ce = intern->info_class;
/* {{{ proto SplFileInfo SplFileInfo::getPathInfo([string $class_name])
Get/copy file info */
-SPL_METHOD(SplFileInfo, getPathInfo)
+PHP_METHOD(SplFileInfo, getPathInfo)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zend_class_entry *ce = intern->info_class;
/* }}} */
/* {{{ proto void SplFileInfo::__debugInfo() */
-SPL_METHOD(SplFileInfo, __debugInfo)
+PHP_METHOD(SplFileInfo, __debugInfo)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
} /* }}} */
/* {{{ proto SplFileInfo::_bad_state_ex(void) */
-SPL_METHOD(SplFileInfo, _bad_state_ex)
+PHP_METHOD(SplFileInfo, _bad_state_ex)
{
zend_throw_exception_ex(spl_ce_LogicException, 0,
"The parent constructor was not called: the object is in an "
/* {{{ proto FilesystemIterator::__construct(string path [, int flags])
Cronstructs a new dir iterator from a path. */
-SPL_METHOD(FilesystemIterator, __construct)
+PHP_METHOD(FilesystemIterator, __construct)
{
spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, DIT_CTOR_FLAGS | SPL_FILE_DIR_SKIPDOTS);
}
/* {{{ proto void FilesystemIterator::rewind()
Rewind dir back to the start */
-SPL_METHOD(FilesystemIterator, rewind)
+PHP_METHOD(FilesystemIterator, rewind)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
int skip_dots = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_SKIPDOTS);
/* {{{ proto int FilesystemIterator::getFlags()
Get handling flags */
-SPL_METHOD(FilesystemIterator, getFlags)
+PHP_METHOD(FilesystemIterator, getFlags)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto void FilesystemIterator::setFlags(long $flags)
Set handling flags */
-SPL_METHOD(FilesystemIterator, setFlags)
+PHP_METHOD(FilesystemIterator, setFlags)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zend_long flags;
/* {{{ proto bool RecursiveDirectoryIterator::hasChildren([bool $allow_links = false])
Returns whether current entry is a directory and not '.' or '..' */
-SPL_METHOD(RecursiveDirectoryIterator, hasChildren)
+PHP_METHOD(RecursiveDirectoryIterator, hasChildren)
{
zend_bool allow_links = 0;
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto RecursiveDirectoryIterator DirectoryIterator::getChildren()
Returns an iterator for the current entry if it is a directory */
-SPL_METHOD(RecursiveDirectoryIterator, getChildren)
+PHP_METHOD(RecursiveDirectoryIterator, getChildren)
{
zval zpath, zflags;
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto void RecursiveDirectoryIterator::getSubPath()
Get sub path */
-SPL_METHOD(RecursiveDirectoryIterator, getSubPath)
+PHP_METHOD(RecursiveDirectoryIterator, getSubPath)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto void RecursiveDirectoryIterator::getSubPathname()
Get sub path and file name */
-SPL_METHOD(RecursiveDirectoryIterator, getSubPathname)
+PHP_METHOD(RecursiveDirectoryIterator, getSubPathname)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char slash = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_UNIXPATHS) ? '/' : DEFAULT_SLASH;
/* {{{ proto RecursiveDirectoryIterator::__construct(string path [, int flags])
Cronstructs a new dir iterator from a path. */
-SPL_METHOD(RecursiveDirectoryIterator, __construct)
+PHP_METHOD(RecursiveDirectoryIterator, __construct)
{
spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, DIT_CTOR_FLAGS);
}
#ifdef HAVE_GLOB
/* {{{ proto GlobIterator::__construct(string path [, int flags])
Cronstructs a new dir iterator from a glob expression (no glob:// needed). */
-SPL_METHOD(GlobIterator, __construct)
+PHP_METHOD(GlobIterator, __construct)
{
spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, DIT_CTOR_FLAGS|DIT_CTOR_GLOB);
}
/* {{{ proto int GlobIterator::count()
Return the number of directories and files found by globbing */
-SPL_METHOD(GlobIterator, count)
+PHP_METHOD(GlobIterator, count)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
}
/* }}} */
-/* the method table */
-/* each method can have its own parameters and visibility */
-static const zend_function_entry spl_SplFileInfo_functions[] = {
- SPL_ME(SplFileInfo, __construct, arginfo_class_SplFileInfo___construct, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getPath, arginfo_class_SplFileInfo_getPath, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getFilename, arginfo_class_SplFileInfo_getFilename, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getExtension, arginfo_class_SplFileInfo_getExtension, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getBasename, arginfo_class_SplFileInfo_getBasename, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getPathname, arginfo_class_SplFileInfo_getPathname, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getPerms, arginfo_class_SplFileInfo_getPerms, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getInode, arginfo_class_SplFileInfo_getInode, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getSize, arginfo_class_SplFileInfo_getSize, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getOwner, arginfo_class_SplFileInfo_getOwner, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getGroup, arginfo_class_SplFileInfo_getGroup, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getATime, arginfo_class_SplFileInfo_getATime, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getMTime, arginfo_class_SplFileInfo_getMTime, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getCTime, arginfo_class_SplFileInfo_getCTime, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getType, arginfo_class_SplFileInfo_getType, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, isWritable, arginfo_class_SplFileInfo_isWritable, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, isReadable, arginfo_class_SplFileInfo_isReadable, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, isExecutable, arginfo_class_SplFileInfo_isExecutable, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, isFile, arginfo_class_SplFileInfo_isFile, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, isDir, arginfo_class_SplFileInfo_isDir, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, isLink, arginfo_class_SplFileInfo_isLink, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getLinkTarget, arginfo_class_SplFileInfo_getLinkTarget, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getRealPath, arginfo_class_SplFileInfo_getRealPath, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getFileInfo, arginfo_class_SplFileInfo_getFileInfo, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, getPathInfo, arginfo_class_SplFileInfo_getPathInfo, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, openFile, arginfo_class_SplFileInfo_openFile, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, setFileClass, arginfo_class_SplFileInfo_setFileClass, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, setInfoClass, arginfo_class_SplFileInfo_setInfoClass, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, __debugInfo, arginfo_class_SplFileInfo___debugInfo, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileInfo, _bad_state_ex, arginfo_class_SplFileInfo__bad_state_ex, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
- SPL_MA(SplFileInfo, __toString, SplFileInfo, getPathname, arginfo_class_SplFileInfo___toString, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-/* the method table */
-/* each method can have its own parameters and visibility */
-static const zend_function_entry spl_DirectoryIterator_functions[] = {
- SPL_ME(DirectoryIterator, __construct, arginfo_class_DirectoryIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(DirectoryIterator, getFilename, arginfo_class_DirectoryIterator_getFilename, ZEND_ACC_PUBLIC)
- SPL_ME(DirectoryIterator, getExtension, arginfo_class_DirectoryIterator_getExtension, ZEND_ACC_PUBLIC)
- SPL_ME(DirectoryIterator, getBasename, arginfo_class_DirectoryIterator_getBasename, ZEND_ACC_PUBLIC)
- SPL_ME(DirectoryIterator, isDot, arginfo_class_DirectoryIterator_isDot, ZEND_ACC_PUBLIC)
- SPL_ME(DirectoryIterator, rewind, arginfo_class_DirectoryIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(DirectoryIterator, valid, arginfo_class_DirectoryIterator_valid, ZEND_ACC_PUBLIC)
- SPL_ME(DirectoryIterator, key, arginfo_class_DirectoryIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(DirectoryIterator, current, arginfo_class_DirectoryIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(DirectoryIterator, next, arginfo_class_DirectoryIterator_next, ZEND_ACC_PUBLIC)
- SPL_ME(DirectoryIterator, seek, arginfo_class_DirectoryIterator_seek, ZEND_ACC_PUBLIC)
- SPL_MA(DirectoryIterator, __toString, DirectoryIterator, getFilename, arginfo_class_DirectoryIterator___toString, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_FilesystemIterator_functions[] = {
- SPL_ME(FilesystemIterator, __construct, arginfo_class_FilesystemIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(FilesystemIterator, rewind, arginfo_class_FilesystemIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(DirectoryIterator, next, arginfo_class_FilesystemIterator_next, ZEND_ACC_PUBLIC)
- SPL_ME(FilesystemIterator, key, arginfo_class_FilesystemIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(FilesystemIterator, current, arginfo_class_FilesystemIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(FilesystemIterator, getFlags, arginfo_class_FilesystemIterator_getFlags, ZEND_ACC_PUBLIC)
- SPL_ME(FilesystemIterator, setFlags, arginfo_class_FilesystemIterator_setFlags, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_RecursiveDirectoryIterator_functions[] = {
- SPL_ME(RecursiveDirectoryIterator, __construct, arginfo_class_RecursiveDirectoryIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveDirectoryIterator, hasChildren, arginfo_class_RecursiveDirectoryIterator_hasChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveDirectoryIterator, getChildren, arginfo_class_RecursiveDirectoryIterator_getChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveDirectoryIterator, getSubPath, arginfo_class_RecursiveDirectoryIterator_getSubPath, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveDirectoryIterator, getSubPathname,arginfo_class_RecursiveDirectoryIterator_getSubPathname, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-#ifdef HAVE_GLOB
-static const zend_function_entry spl_GlobIterator_functions[] = {
- SPL_ME(GlobIterator, __construct, arginfo_class_GlobIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(GlobIterator, count, arginfo_class_GlobIterator_count, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-#endif
-/* }}} */
-
static int spl_filesystem_file_read(spl_filesystem_object *intern, int silent) /* {{{ */
{
char *buf;
/* {{{ proto SplFileObject::__construct(string filename [, string mode = 'r' [, bool use_include_path [, resource context]]]])
Construct a new file object */
-SPL_METHOD(SplFileObject, __construct)
+PHP_METHOD(SplFileObject, __construct)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zend_bool use_include_path = 0;
/* {{{ proto SplTempFileObject::__construct([int max_memory])
Construct a new temp file object */
-SPL_METHOD(SplTempFileObject, __construct)
+PHP_METHOD(SplTempFileObject, __construct)
{
zend_long max_memory = PHP_STREAM_MAX_MEM;
char tmp_fname[48];
/* {{{ proto void SplFileObject::rewind()
Rewind the file and read the first line */
-SPL_METHOD(SplFileObject, rewind)
+PHP_METHOD(SplFileObject, rewind)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto void SplFileObject::eof()
Return whether end of file is reached */
-SPL_METHOD(SplFileObject, eof)
+PHP_METHOD(SplFileObject, eof)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto void SplFileObject::valid()
Return !eof() */
-SPL_METHOD(SplFileObject, valid)
+PHP_METHOD(SplFileObject, valid)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto string SplFileObject::fgets()
Rturn next line from file */
-SPL_METHOD(SplFileObject, fgets)
+PHP_METHOD(SplFileObject, fgets)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto string SplFileObject::current()
Return current line from file */
-SPL_METHOD(SplFileObject, current)
+PHP_METHOD(SplFileObject, current)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto int SplFileObject::key()
Return line number */
-SPL_METHOD(SplFileObject, key)
+PHP_METHOD(SplFileObject, key)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto void SplFileObject::next()
Read next line */
-SPL_METHOD(SplFileObject, next)
+PHP_METHOD(SplFileObject, next)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto void SplFileObject::setFlags(int flags)
Set file handling flags */
-SPL_METHOD(SplFileObject, setFlags)
+PHP_METHOD(SplFileObject, setFlags)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto int SplFileObject::getFlags()
Get file handling flags */
-SPL_METHOD(SplFileObject, getFlags)
+PHP_METHOD(SplFileObject, getFlags)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto void SplFileObject::setMaxLineLen(int max_len)
Set maximum line length */
-SPL_METHOD(SplFileObject, setMaxLineLen)
+PHP_METHOD(SplFileObject, setMaxLineLen)
{
zend_long max_len;
/* {{{ proto int SplFileObject::getMaxLineLen()
Get maximum line length */
-SPL_METHOD(SplFileObject, getMaxLineLen)
+PHP_METHOD(SplFileObject, getMaxLineLen)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto bool SplFileObject::hasChildren()
Return false */
-SPL_METHOD(SplFileObject, hasChildren)
+PHP_METHOD(SplFileObject, hasChildren)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto bool SplFileObject::getChildren()
Read NULL */
-SPL_METHOD(SplFileObject, getChildren)
+PHP_METHOD(SplFileObject, getChildren)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ FileFunction */
#define FileFunction(func_name) \
-SPL_METHOD(SplFileObject, func_name) \
+PHP_METHOD(SplFileObject, func_name) \
{ \
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS); \
FileFunctionCall(func_name, ZEND_NUM_ARGS(), NULL); \
/* {{{ proto array SplFileObject::fgetcsv([string delimiter [, string enclosure [, escape = '\\']]])
Return current line as csv */
-SPL_METHOD(SplFileObject, fgetcsv)
+PHP_METHOD(SplFileObject, fgetcsv)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char delimiter = intern->u.file.delimiter, enclosure = intern->u.file.enclosure;
/* {{{ proto int SplFileObject::fputcsv(array fields, [string delimiter [, string enclosure [, string escape]]])
Output a field array as a CSV line */
-SPL_METHOD(SplFileObject, fputcsv)
+PHP_METHOD(SplFileObject, fputcsv)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char delimiter = intern->u.file.delimiter, enclosure = intern->u.file.enclosure;
/* {{{ proto void SplFileObject::setCsvControl([string delimiter [, string enclosure [, string escape ]]])
Set the delimiter, enclosure and escape character used in fgetcsv */
-SPL_METHOD(SplFileObject, setCsvControl)
+PHP_METHOD(SplFileObject, setCsvControl)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char delimiter = ',', enclosure = '"';
/* {{{ proto array SplFileObject::getCsvControl()
Get the delimiter, enclosure and escape character used in fgetcsv */
-SPL_METHOD(SplFileObject, getCsvControl)
+PHP_METHOD(SplFileObject, getCsvControl)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char delimiter[2], enclosure[2], escape[2];
/* {{{ proto bool SplFileObject::fflush()
Flush the file */
-SPL_METHOD(SplFileObject, fflush)
+PHP_METHOD(SplFileObject, fflush)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto int SplFileObject::ftell()
Return current file position */
-SPL_METHOD(SplFileObject, ftell)
+PHP_METHOD(SplFileObject, ftell)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zend_long ret;
/* {{{ proto int SplFileObject::fseek(int pos [, int whence = SEEK_SET])
Return current file position */
-SPL_METHOD(SplFileObject, fseek)
+PHP_METHOD(SplFileObject, fseek)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zend_long pos, whence = SEEK_SET;
/* {{{ proto int SplFileObject::fgetc()
Get a character form the file */
-SPL_METHOD(SplFileObject, fgetc)
+PHP_METHOD(SplFileObject, fgetc)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char buf[2];
/* {{{ proto int SplFileObject::fpassthru()
Output all remaining data from a file pointer */
-SPL_METHOD(SplFileObject, fpassthru)
+PHP_METHOD(SplFileObject, fpassthru)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto bool SplFileObject::fscanf(string format [, string ...])
Implements a mostly ANSI compatible fscanf() */
-SPL_METHOD(SplFileObject, fscanf)
+PHP_METHOD(SplFileObject, fscanf)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
/* {{{ proto int|false SplFileObject::fwrite(string str [, int length])
Binary-safe file write */
-SPL_METHOD(SplFileObject, fwrite)
+PHP_METHOD(SplFileObject, fwrite)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
char *str;
RETURN_LONG(written);
} /* }}} */
-SPL_METHOD(SplFileObject, fread)
+PHP_METHOD(SplFileObject, fread)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zend_long length = 0;
/* {{{ proto bool SplFileObject::ftruncate(int size)
Truncate file to 'size' length */
-SPL_METHOD(SplFileObject, ftruncate)
+PHP_METHOD(SplFileObject, ftruncate)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zend_long size;
/* {{{ proto void SplFileObject::seek(int line_pos)
Seek to specified line */
-SPL_METHOD(SplFileObject, seek)
+PHP_METHOD(SplFileObject, seek)
{
spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(ZEND_THIS);
zend_long line_pos;
}
} /* }}} */
-static const zend_function_entry spl_SplFileObject_functions[] = {
- SPL_ME(SplFileObject, __construct, arginfo_class_SplFileObject___construct, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, rewind, arginfo_class_SplFileObject_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, eof, arginfo_class_SplFileObject_eof, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, valid, arginfo_class_SplFileObject_valid, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, fgets, arginfo_class_SplFileObject_fgets, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, fgetcsv, arginfo_class_SplFileObject_fgetcsv, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, fputcsv, arginfo_class_SplFileObject_fputcsv, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, setCsvControl, arginfo_class_SplFileObject_setCsvControl, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, getCsvControl, arginfo_class_SplFileObject_getCsvControl, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, flock, arginfo_class_SplFileObject_flock, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, fflush, arginfo_class_SplFileObject_fflush, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, ftell, arginfo_class_SplFileObject_ftell, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, fseek, arginfo_class_SplFileObject_fseek, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, fgetc, arginfo_class_SplFileObject_fgetc, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, fpassthru, arginfo_class_SplFileObject_fpassthru, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, fscanf, arginfo_class_SplFileObject_fscanf, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, fwrite, arginfo_class_SplFileObject_fwrite, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, fread, arginfo_class_SplFileObject_fread, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, fstat, arginfo_class_SplFileObject_fstat, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, ftruncate, arginfo_class_SplFileObject_ftruncate, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, current, arginfo_class_SplFileObject_current, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, key, arginfo_class_SplFileObject_key, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, next, arginfo_class_SplFileObject_next, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, setFlags, arginfo_class_SplFileObject_setFlags, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, getFlags, arginfo_class_SplFileObject_getFlags, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, setMaxLineLen, arginfo_class_SplFileObject_setMaxLineLen, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, getMaxLineLen, arginfo_class_SplFileObject_getMaxLineLen, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, hasChildren, arginfo_class_SplFileObject_hasChildren, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, getChildren, arginfo_class_SplFileObject_getChildren, ZEND_ACC_PUBLIC)
- SPL_ME(SplFileObject, seek, arginfo_class_SplFileObject_seek, ZEND_ACC_PUBLIC)
- /* mappings */
- SPL_MA(SplFileObject, getCurrentLine, SplFileObject, fgets, arginfo_class_SplFileObject_getCurrentLine, ZEND_ACC_PUBLIC)
- SPL_MA(SplFileObject, __toString, SplFileObject, fgets, arginfo_class_SplFileObject___toString, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_SplTempFileObject_functions[] = {
- SPL_ME(SplTempFileObject, __construct, arginfo_class_SplTempFileObject___construct, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-/* }}} */
-
/* {{{ PHP_MINIT_FUNCTION(spl_directory)
*/
PHP_MINIT_FUNCTION(spl_directory)
{
- REGISTER_SPL_STD_CLASS_EX(SplFileInfo, spl_filesystem_object_new, spl_SplFileInfo_functions);
+ REGISTER_SPL_STD_CLASS_EX(SplFileInfo, spl_filesystem_object_new, class_SplFileInfo_methods);
memcpy(&spl_filesystem_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
spl_filesystem_object_handlers.offset = XtOffsetOf(spl_filesystem_object, std);
spl_filesystem_object_handlers.clone_obj = spl_filesystem_object_clone;
REGISTER_SPL_IMPLEMENTS(SplFileInfo, Stringable);
- REGISTER_SPL_SUB_CLASS_EX(DirectoryIterator, SplFileInfo, spl_filesystem_object_new, spl_DirectoryIterator_functions);
+ REGISTER_SPL_SUB_CLASS_EX(DirectoryIterator, SplFileInfo, spl_filesystem_object_new, class_DirectoryIterator_methods);
zend_class_implements(spl_ce_DirectoryIterator, 1, zend_ce_iterator);
REGISTER_SPL_IMPLEMENTS(DirectoryIterator, SeekableIterator);
spl_ce_DirectoryIterator->get_iterator = spl_filesystem_dir_get_iterator;
- REGISTER_SPL_SUB_CLASS_EX(FilesystemIterator, DirectoryIterator, spl_filesystem_object_new, spl_FilesystemIterator_functions);
+ REGISTER_SPL_SUB_CLASS_EX(FilesystemIterator, DirectoryIterator, spl_filesystem_object_new, class_FilesystemIterator_methods);
REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_MODE_MASK", SPL_FILE_DIR_CURRENT_MODE_MASK);
REGISTER_SPL_CLASS_CONST_LONG(FilesystemIterator, "CURRENT_AS_PATHNAME", SPL_FILE_DIR_CURRENT_AS_PATHNAME);
spl_ce_FilesystemIterator->get_iterator = spl_filesystem_tree_get_iterator;
- REGISTER_SPL_SUB_CLASS_EX(RecursiveDirectoryIterator, FilesystemIterator, spl_filesystem_object_new, spl_RecursiveDirectoryIterator_functions);
+ REGISTER_SPL_SUB_CLASS_EX(RecursiveDirectoryIterator, FilesystemIterator, spl_filesystem_object_new, class_RecursiveDirectoryIterator_methods);
REGISTER_SPL_IMPLEMENTS(RecursiveDirectoryIterator, RecursiveIterator);
memcpy(&spl_filesystem_object_check_handlers, &spl_filesystem_object_handlers, sizeof(zend_object_handlers));
spl_filesystem_object_check_handlers.get_method = spl_filesystem_object_get_method_check;
#ifdef HAVE_GLOB
- REGISTER_SPL_SUB_CLASS_EX(GlobIterator, FilesystemIterator, spl_filesystem_object_new_check, spl_GlobIterator_functions);
+ REGISTER_SPL_SUB_CLASS_EX(GlobIterator, FilesystemIterator, spl_filesystem_object_new_check, class_GlobIterator_methods);
REGISTER_SPL_IMPLEMENTS(GlobIterator, Countable);
#endif
- REGISTER_SPL_SUB_CLASS_EX(SplFileObject, SplFileInfo, spl_filesystem_object_new_check, spl_SplFileObject_functions);
+ REGISTER_SPL_SUB_CLASS_EX(SplFileObject, SplFileInfo, spl_filesystem_object_new_check, class_SplFileObject_methods);
REGISTER_SPL_IMPLEMENTS(SplFileObject, RecursiveIterator);
REGISTER_SPL_IMPLEMENTS(SplFileObject, SeekableIterator);
REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "SKIP_EMPTY", SPL_FILE_OBJECT_SKIP_EMPTY);
REGISTER_SPL_CLASS_CONST_LONG(SplFileObject, "READ_CSV", SPL_FILE_OBJECT_READ_CSV);
- REGISTER_SPL_SUB_CLASS_EX(SplTempFileObject, SplFileObject, spl_filesystem_object_new_check, spl_SplTempFileObject_functions);
+ REGISTER_SPL_SUB_CLASS_EX(SplTempFileObject, SplFileObject, spl_filesystem_object_new_check, class_SplTempFileObject_methods);
return SUCCESS;
}
/* }}} */
<?php
+/** @generate-function-entries */
+
class SplFileInfo
{
public function __construct(string $file_name) {}
/** @return void */
public function setInfoClass(string $class_name = SplFileInfo::class) {}
+ /** @alias SplFileInfo::getPathname */
public function __toString(): string {}
/** @return array */
/** @return void */
public function seek(int $position) {}
+ /** @alias DirectoryIterator::getFilename */
public function __toString(): string {}
}
/** @return void */
public function rewind() {}
- /** @return void */
- public function next() {}
-
/** @return string */
public function key() {}
public function getSubPathname() {}
}
+#ifdef HAVE_GLOB
class GlobIterator extends FilesystemIterator implements Countable
{
public function __construct(string $path, int $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO) {}
/** @return int */
public function count() {}
}
+#endif
class SplFileObject extends SplFileInfo implements RecursiveIterator, SeekableIterator
{
/** @return void */
public function seek(int $line_pos) {}
- /** @return string|false */
+ /**
+ * @return string|false
+ * @alias SplFileObject::fgets
+ */
public function getCurrentLine() {}
+ /** @alias SplFileObject::fgets */
public function __toString(): string {}
}
#define arginfo_class_FilesystemIterator_rewind arginfo_class_SplFileInfo_getPath
-#define arginfo_class_FilesystemIterator_next arginfo_class_SplFileInfo_getPath
-
#define arginfo_class_FilesystemIterator_key arginfo_class_SplFileInfo_getPath
#define arginfo_class_FilesystemIterator_current arginfo_class_SplFileInfo_getPath
#define arginfo_class_RecursiveDirectoryIterator_getSubPathname arginfo_class_SplFileInfo_getPath
-#define arginfo_class_GlobIterator___construct arginfo_class_RecursiveDirectoryIterator___construct
+#if defined(HAVE_GLOB)
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_GlobIterator___construct, 0, 0, 1)
+ ZEND_ARG_TYPE_INFO(0, path, IS_STRING, 0)
+ ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO")
+ZEND_END_ARG_INFO()
+#endif
-#define arginfo_class_GlobIterator_count arginfo_class_SplFileInfo_getPath
+#if defined(HAVE_GLOB)
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_GlobIterator_count, 0, 0, 0)
+ZEND_END_ARG_INFO()
+#endif
ZEND_BEGIN_ARG_INFO_EX(arginfo_class_SplFileObject___construct, 0, 0, 1)
ZEND_ARG_TYPE_INFO(0, file_name, IS_STRING, 0)
ZEND_BEGIN_ARG_INFO_EX(arginfo_class_SplTempFileObject___construct, 0, 0, 0)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, max_memory, IS_LONG, 0, "2 * 1024 * 1024")
ZEND_END_ARG_INFO()
+
+
+ZEND_METHOD(SplFileInfo, __construct);
+ZEND_METHOD(SplFileInfo, getPath);
+ZEND_METHOD(SplFileInfo, getFilename);
+ZEND_METHOD(SplFileInfo, getExtension);
+ZEND_METHOD(SplFileInfo, getBasename);
+ZEND_METHOD(SplFileInfo, getPathname);
+ZEND_METHOD(SplFileInfo, getPerms);
+ZEND_METHOD(SplFileInfo, getInode);
+ZEND_METHOD(SplFileInfo, getSize);
+ZEND_METHOD(SplFileInfo, getOwner);
+ZEND_METHOD(SplFileInfo, getGroup);
+ZEND_METHOD(SplFileInfo, getATime);
+ZEND_METHOD(SplFileInfo, getMTime);
+ZEND_METHOD(SplFileInfo, getCTime);
+ZEND_METHOD(SplFileInfo, getType);
+ZEND_METHOD(SplFileInfo, isWritable);
+ZEND_METHOD(SplFileInfo, isReadable);
+ZEND_METHOD(SplFileInfo, isExecutable);
+ZEND_METHOD(SplFileInfo, isFile);
+ZEND_METHOD(SplFileInfo, isDir);
+ZEND_METHOD(SplFileInfo, isLink);
+ZEND_METHOD(SplFileInfo, getLinkTarget);
+ZEND_METHOD(SplFileInfo, getRealPath);
+ZEND_METHOD(SplFileInfo, getFileInfo);
+ZEND_METHOD(SplFileInfo, getPathInfo);
+ZEND_METHOD(SplFileInfo, openFile);
+ZEND_METHOD(SplFileInfo, setFileClass);
+ZEND_METHOD(SplFileInfo, setInfoClass);
+ZEND_METHOD(SplFileInfo, __debugInfo);
+ZEND_METHOD(SplFileInfo, _bad_state_ex);
+ZEND_METHOD(DirectoryIterator, __construct);
+ZEND_METHOD(DirectoryIterator, getFilename);
+ZEND_METHOD(DirectoryIterator, getExtension);
+ZEND_METHOD(DirectoryIterator, getBasename);
+ZEND_METHOD(DirectoryIterator, isDot);
+ZEND_METHOD(DirectoryIterator, rewind);
+ZEND_METHOD(DirectoryIterator, valid);
+ZEND_METHOD(DirectoryIterator, key);
+ZEND_METHOD(DirectoryIterator, current);
+ZEND_METHOD(DirectoryIterator, next);
+ZEND_METHOD(DirectoryIterator, seek);
+ZEND_METHOD(FilesystemIterator, __construct);
+ZEND_METHOD(FilesystemIterator, rewind);
+ZEND_METHOD(FilesystemIterator, key);
+ZEND_METHOD(FilesystemIterator, current);
+ZEND_METHOD(FilesystemIterator, getFlags);
+ZEND_METHOD(FilesystemIterator, setFlags);
+ZEND_METHOD(RecursiveDirectoryIterator, __construct);
+ZEND_METHOD(RecursiveDirectoryIterator, hasChildren);
+ZEND_METHOD(RecursiveDirectoryIterator, getChildren);
+ZEND_METHOD(RecursiveDirectoryIterator, getSubPath);
+ZEND_METHOD(RecursiveDirectoryIterator, getSubPathname);
+#if defined(HAVE_GLOB)
+ZEND_METHOD(GlobIterator, __construct);
+#endif
+#if defined(HAVE_GLOB)
+ZEND_METHOD(GlobIterator, count);
+#endif
+ZEND_METHOD(SplFileObject, __construct);
+ZEND_METHOD(SplFileObject, rewind);
+ZEND_METHOD(SplFileObject, eof);
+ZEND_METHOD(SplFileObject, valid);
+ZEND_METHOD(SplFileObject, fgets);
+ZEND_METHOD(SplFileObject, fread);
+ZEND_METHOD(SplFileObject, fgetcsv);
+ZEND_METHOD(SplFileObject, fputcsv);
+ZEND_METHOD(SplFileObject, setCsvControl);
+ZEND_METHOD(SplFileObject, getCsvControl);
+ZEND_METHOD(SplFileObject, flock);
+ZEND_METHOD(SplFileObject, fflush);
+ZEND_METHOD(SplFileObject, ftell);
+ZEND_METHOD(SplFileObject, fseek);
+ZEND_METHOD(SplFileObject, fgetc);
+ZEND_METHOD(SplFileObject, fpassthru);
+ZEND_METHOD(SplFileObject, fscanf);
+ZEND_METHOD(SplFileObject, fwrite);
+ZEND_METHOD(SplFileObject, fstat);
+ZEND_METHOD(SplFileObject, ftruncate);
+ZEND_METHOD(SplFileObject, current);
+ZEND_METHOD(SplFileObject, key);
+ZEND_METHOD(SplFileObject, next);
+ZEND_METHOD(SplFileObject, setFlags);
+ZEND_METHOD(SplFileObject, getFlags);
+ZEND_METHOD(SplFileObject, setMaxLineLen);
+ZEND_METHOD(SplFileObject, getMaxLineLen);
+ZEND_METHOD(SplFileObject, hasChildren);
+ZEND_METHOD(SplFileObject, getChildren);
+ZEND_METHOD(SplFileObject, seek);
+ZEND_METHOD(SplTempFileObject, __construct);
+
+
+static const zend_function_entry class_SplFileInfo_methods[] = {
+ ZEND_ME(SplFileInfo, __construct, arginfo_class_SplFileInfo___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getPath, arginfo_class_SplFileInfo_getPath, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getFilename, arginfo_class_SplFileInfo_getFilename, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getExtension, arginfo_class_SplFileInfo_getExtension, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getBasename, arginfo_class_SplFileInfo_getBasename, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getPathname, arginfo_class_SplFileInfo_getPathname, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getPerms, arginfo_class_SplFileInfo_getPerms, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getInode, arginfo_class_SplFileInfo_getInode, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getSize, arginfo_class_SplFileInfo_getSize, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getOwner, arginfo_class_SplFileInfo_getOwner, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getGroup, arginfo_class_SplFileInfo_getGroup, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getATime, arginfo_class_SplFileInfo_getATime, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getMTime, arginfo_class_SplFileInfo_getMTime, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getCTime, arginfo_class_SplFileInfo_getCTime, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getType, arginfo_class_SplFileInfo_getType, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, isWritable, arginfo_class_SplFileInfo_isWritable, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, isReadable, arginfo_class_SplFileInfo_isReadable, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, isExecutable, arginfo_class_SplFileInfo_isExecutable, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, isFile, arginfo_class_SplFileInfo_isFile, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, isDir, arginfo_class_SplFileInfo_isDir, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, isLink, arginfo_class_SplFileInfo_isLink, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getLinkTarget, arginfo_class_SplFileInfo_getLinkTarget, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getRealPath, arginfo_class_SplFileInfo_getRealPath, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getFileInfo, arginfo_class_SplFileInfo_getFileInfo, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, getPathInfo, arginfo_class_SplFileInfo_getPathInfo, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, openFile, arginfo_class_SplFileInfo_openFile, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, setFileClass, arginfo_class_SplFileInfo_setFileClass, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, setInfoClass, arginfo_class_SplFileInfo_setInfoClass, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplFileInfo, __toString, getPathname, arginfo_class_SplFileInfo___toString, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, __debugInfo, arginfo_class_SplFileInfo___debugInfo, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileInfo, _bad_state_ex, arginfo_class_SplFileInfo__bad_state_ex, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_DirectoryIterator_methods[] = {
+ ZEND_ME(DirectoryIterator, __construct, arginfo_class_DirectoryIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(DirectoryIterator, getFilename, arginfo_class_DirectoryIterator_getFilename, ZEND_ACC_PUBLIC)
+ ZEND_ME(DirectoryIterator, getExtension, arginfo_class_DirectoryIterator_getExtension, ZEND_ACC_PUBLIC)
+ ZEND_ME(DirectoryIterator, getBasename, arginfo_class_DirectoryIterator_getBasename, ZEND_ACC_PUBLIC)
+ ZEND_ME(DirectoryIterator, isDot, arginfo_class_DirectoryIterator_isDot, ZEND_ACC_PUBLIC)
+ ZEND_ME(DirectoryIterator, rewind, arginfo_class_DirectoryIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(DirectoryIterator, valid, arginfo_class_DirectoryIterator_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(DirectoryIterator, key, arginfo_class_DirectoryIterator_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(DirectoryIterator, current, arginfo_class_DirectoryIterator_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(DirectoryIterator, next, arginfo_class_DirectoryIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(DirectoryIterator, seek, arginfo_class_DirectoryIterator_seek, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(DirectoryIterator, __toString, getFilename, arginfo_class_DirectoryIterator___toString, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_FilesystemIterator_methods[] = {
+ ZEND_ME(FilesystemIterator, __construct, arginfo_class_FilesystemIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(FilesystemIterator, rewind, arginfo_class_FilesystemIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(FilesystemIterator, key, arginfo_class_FilesystemIterator_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(FilesystemIterator, current, arginfo_class_FilesystemIterator_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(FilesystemIterator, getFlags, arginfo_class_FilesystemIterator_getFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(FilesystemIterator, setFlags, arginfo_class_FilesystemIterator_setFlags, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RecursiveDirectoryIterator_methods[] = {
+ ZEND_ME(RecursiveDirectoryIterator, __construct, arginfo_class_RecursiveDirectoryIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveDirectoryIterator, hasChildren, arginfo_class_RecursiveDirectoryIterator_hasChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveDirectoryIterator, getChildren, arginfo_class_RecursiveDirectoryIterator_getChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveDirectoryIterator, getSubPath, arginfo_class_RecursiveDirectoryIterator_getSubPath, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveDirectoryIterator, getSubPathname, arginfo_class_RecursiveDirectoryIterator_getSubPathname, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_GlobIterator_methods[] = {
+#if defined(HAVE_GLOB)
+ ZEND_ME(GlobIterator, __construct, arginfo_class_GlobIterator___construct, ZEND_ACC_PUBLIC)
+#endif
+#if defined(HAVE_GLOB)
+ ZEND_ME(GlobIterator, count, arginfo_class_GlobIterator_count, ZEND_ACC_PUBLIC)
+#endif
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SplFileObject_methods[] = {
+ ZEND_ME(SplFileObject, __construct, arginfo_class_SplFileObject___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, rewind, arginfo_class_SplFileObject_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, eof, arginfo_class_SplFileObject_eof, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, valid, arginfo_class_SplFileObject_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, fgets, arginfo_class_SplFileObject_fgets, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, fread, arginfo_class_SplFileObject_fread, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, fgetcsv, arginfo_class_SplFileObject_fgetcsv, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, fputcsv, arginfo_class_SplFileObject_fputcsv, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, setCsvControl, arginfo_class_SplFileObject_setCsvControl, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, getCsvControl, arginfo_class_SplFileObject_getCsvControl, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, flock, arginfo_class_SplFileObject_flock, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, fflush, arginfo_class_SplFileObject_fflush, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, ftell, arginfo_class_SplFileObject_ftell, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, fseek, arginfo_class_SplFileObject_fseek, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, fgetc, arginfo_class_SplFileObject_fgetc, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, fpassthru, arginfo_class_SplFileObject_fpassthru, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, fscanf, arginfo_class_SplFileObject_fscanf, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, fwrite, arginfo_class_SplFileObject_fwrite, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, fstat, arginfo_class_SplFileObject_fstat, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, ftruncate, arginfo_class_SplFileObject_ftruncate, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, current, arginfo_class_SplFileObject_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, key, arginfo_class_SplFileObject_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, next, arginfo_class_SplFileObject_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, setFlags, arginfo_class_SplFileObject_setFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, getFlags, arginfo_class_SplFileObject_getFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, setMaxLineLen, arginfo_class_SplFileObject_setMaxLineLen, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, getMaxLineLen, arginfo_class_SplFileObject_getMaxLineLen, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, hasChildren, arginfo_class_SplFileObject_hasChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, getChildren, arginfo_class_SplFileObject_getChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFileObject, seek, arginfo_class_SplFileObject_seek, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplFileObject, getCurrentLine, fgets, arginfo_class_SplFileObject_getCurrentLine, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplFileObject, __toString, fgets, arginfo_class_SplFileObject___toString, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SplTempFileObject_methods[] = {
+ ZEND_ME(SplTempFileObject, __construct, arginfo_class_SplTempFileObject___construct, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
/* {{{ proto bool SplDoublyLinkedList::push(mixed value)
Push $value on the SplDoublyLinkedList */
-SPL_METHOD(SplDoublyLinkedList, push)
+PHP_METHOD(SplDoublyLinkedList, push)
{
zval *value;
spl_dllist_object *intern;
/* {{{ proto bool SplDoublyLinkedList::unshift(mixed value)
Unshift $value on the SplDoublyLinkedList */
-SPL_METHOD(SplDoublyLinkedList, unshift)
+PHP_METHOD(SplDoublyLinkedList, unshift)
{
zval *value;
spl_dllist_object *intern;
/* {{{ proto mixed SplDoublyLinkedList::pop()
Pop an element out of the SplDoublyLinkedList */
-SPL_METHOD(SplDoublyLinkedList, pop)
+PHP_METHOD(SplDoublyLinkedList, pop)
{
spl_dllist_object *intern;
/* {{{ proto mixed SplDoublyLinkedList::shift()
Shift an element out of the SplDoublyLinkedList */
-SPL_METHOD(SplDoublyLinkedList, shift)
+PHP_METHOD(SplDoublyLinkedList, shift)
{
spl_dllist_object *intern;
/* {{{ proto mixed SplDoublyLinkedList::top()
Peek at the top element of the SplDoublyLinkedList */
-SPL_METHOD(SplDoublyLinkedList, top)
+PHP_METHOD(SplDoublyLinkedList, top)
{
zval *value;
spl_dllist_object *intern;
/* {{{ proto mixed SplDoublyLinkedList::bottom()
Peek at the bottom element of the SplDoublyLinkedList */
-SPL_METHOD(SplDoublyLinkedList, bottom)
+PHP_METHOD(SplDoublyLinkedList, bottom)
{
zval *value;
spl_dllist_object *intern;
/* {{{ proto int SplDoublyLinkedList::count()
Return the number of elements in the datastructure. */
-SPL_METHOD(SplDoublyLinkedList, count)
+PHP_METHOD(SplDoublyLinkedList, count)
{
zend_long count;
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
/* {{{ proto int SplDoublyLinkedList::isEmpty()
Return true if the SplDoublyLinkedList is empty. */
-SPL_METHOD(SplDoublyLinkedList, isEmpty)
+PHP_METHOD(SplDoublyLinkedList, isEmpty)
{
zend_long count;
/* {{{ proto int SplDoublyLinkedList::setIteratorMode(int mode)
Set the mode of iteration */
-SPL_METHOD(SplDoublyLinkedList, setIteratorMode)
+PHP_METHOD(SplDoublyLinkedList, setIteratorMode)
{
zend_long value;
spl_dllist_object *intern;
/* {{{ proto int SplDoublyLinkedList::getIteratorMode()
Return the mode of iteration */
-SPL_METHOD(SplDoublyLinkedList, getIteratorMode)
+PHP_METHOD(SplDoublyLinkedList, getIteratorMode)
{
spl_dllist_object *intern;
/* {{{ proto bool SplDoublyLinkedList::offsetExists(mixed index)
Returns whether the requested $index exists. */
-SPL_METHOD(SplDoublyLinkedList, offsetExists)
+PHP_METHOD(SplDoublyLinkedList, offsetExists)
{
zval *zindex;
spl_dllist_object *intern;
/* {{{ proto mixed SplDoublyLinkedList::offsetGet(mixed index)
Returns the value at the specified $index. */
-SPL_METHOD(SplDoublyLinkedList, offsetGet)
+PHP_METHOD(SplDoublyLinkedList, offsetGet)
{
zval *zindex;
zend_long index;
/* {{{ proto void SplDoublyLinkedList::offsetSet(mixed index, mixed newval)
Sets the value at the specified $index to $newval. */
-SPL_METHOD(SplDoublyLinkedList, offsetSet)
+PHP_METHOD(SplDoublyLinkedList, offsetSet)
{
zval *zindex, *value;
spl_dllist_object *intern;
/* {{{ proto void SplDoublyLinkedList::offsetUnset(mixed index)
Unsets the value at the specified $index. */
-SPL_METHOD(SplDoublyLinkedList, offsetUnset)
+PHP_METHOD(SplDoublyLinkedList, offsetUnset)
{
zval *zindex;
zend_long index;
/* {{{ proto int SplDoublyLinkedList::key()
Return current array key */
-SPL_METHOD(SplDoublyLinkedList, key)
+PHP_METHOD(SplDoublyLinkedList, key)
{
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
/* {{{ proto void SplDoublyLinkedList::prev()
Move to next entry */
-SPL_METHOD(SplDoublyLinkedList, prev)
+PHP_METHOD(SplDoublyLinkedList, prev)
{
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
/* {{{ proto void SplDoublyLinkedList::next()
Move to next entry */
-SPL_METHOD(SplDoublyLinkedList, next)
+PHP_METHOD(SplDoublyLinkedList, next)
{
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
/* {{{ proto bool SplDoublyLinkedList::valid()
Check whether the datastructure contains more entries */
-SPL_METHOD(SplDoublyLinkedList, valid)
+PHP_METHOD(SplDoublyLinkedList, valid)
{
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
/* {{{ proto void SplDoublyLinkedList::rewind()
Rewind the datastructure back to the start */
-SPL_METHOD(SplDoublyLinkedList, rewind)
+PHP_METHOD(SplDoublyLinkedList, rewind)
{
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
/* {{{ proto mixed SplDoublyLinkedList::current()
Return current datastructure entry */
-SPL_METHOD(SplDoublyLinkedList, current)
+PHP_METHOD(SplDoublyLinkedList, current)
{
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_ptr_llist_element *element = intern->traverse_pointer;
/* {{{ proto string SplDoublyLinkedList::serialize()
Serializes storage */
-SPL_METHOD(SplDoublyLinkedList, serialize)
+PHP_METHOD(SplDoublyLinkedList, serialize)
{
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
smart_str buf = {0};
/* {{{ proto void SplDoublyLinkedList::unserialize(string serialized)
Unserializes storage */
-SPL_METHOD(SplDoublyLinkedList, unserialize)
+PHP_METHOD(SplDoublyLinkedList, unserialize)
{
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
zval *flags, *elem;
} /* }}} */
/* {{{ proto array SplDoublyLinkedList::__serialize() */
-SPL_METHOD(SplDoublyLinkedList, __serialize)
+PHP_METHOD(SplDoublyLinkedList, __serialize)
{
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
spl_ptr_llist_element *current = intern->llist->head;
} /* }}} */
/* {{{ proto void SplDoublyLinkedList::__unserialize(array serialized) */
-SPL_METHOD(SplDoublyLinkedList, __unserialize) {
+PHP_METHOD(SplDoublyLinkedList, __unserialize) {
spl_dllist_object *intern = Z_SPLDLLIST_P(ZEND_THIS);
HashTable *data;
zval *flags_zv, *storage_zv, *members_zv, *elem;
/* {{{ proto void SplDoublyLinkedList::add(mixed index, mixed newval)
Inserts a new entry before the specified $index consisting of $newval. */
-SPL_METHOD(SplDoublyLinkedList, add)
+PHP_METHOD(SplDoublyLinkedList, add)
{
zval *zindex, *value;
spl_dllist_object *intern;
} /* }}} */
/* {{{ proto void SplDoublyLinkedList::__debugInfo() */
-SPL_METHOD(SplDoublyLinkedList, __debugInfo)
+PHP_METHOD(SplDoublyLinkedList, __debugInfo)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
}
/* }}} */
-static const zend_function_entry spl_funcs_SplQueue[] = {
- SPL_MA(SplQueue, enqueue, SplDoublyLinkedList, push, arginfo_class_SplQueue_enqueue, ZEND_ACC_PUBLIC)
- SPL_MA(SplQueue, dequeue, SplDoublyLinkedList, shift, arginfo_class_SplQueue_dequeue, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_SplDoublyLinkedList[] = {
- SPL_ME(SplDoublyLinkedList, pop, arginfo_class_SplDoublyLinkedList_pop, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, shift, arginfo_class_SplDoublyLinkedList_shift, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, push, arginfo_class_SplDoublyLinkedList_push, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, unshift, arginfo_class_SplDoublyLinkedList_unshift, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, top, arginfo_class_SplDoublyLinkedList_top, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, bottom, arginfo_class_SplDoublyLinkedList_bottom, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, isEmpty, arginfo_class_SplDoublyLinkedList_isEmpty, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, setIteratorMode, arginfo_class_SplDoublyLinkedList_setIteratorMode, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, getIteratorMode, arginfo_class_SplDoublyLinkedList_getIteratorMode, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, __debugInfo, arginfo_class_SplDoublyLinkedList___debugInfo, ZEND_ACC_PUBLIC)
- /* Countable */
- SPL_ME(SplDoublyLinkedList, count, arginfo_class_SplDoublyLinkedList_count, ZEND_ACC_PUBLIC)
- /* ArrayAccess */
- SPL_ME(SplDoublyLinkedList, offsetExists, arginfo_class_SplDoublyLinkedList_offsetExists, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, offsetGet, arginfo_class_SplDoublyLinkedList_offsetGet, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, offsetSet, arginfo_class_SplDoublyLinkedList_offsetSet, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, offsetUnset, arginfo_class_SplDoublyLinkedList_offsetUnset, ZEND_ACC_PUBLIC)
-
- SPL_ME(SplDoublyLinkedList, add, arginfo_class_SplDoublyLinkedList_add, ZEND_ACC_PUBLIC)
-
- /* Iterator */
- SPL_ME(SplDoublyLinkedList, rewind, arginfo_class_SplDoublyLinkedList_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, current, arginfo_class_SplDoublyLinkedList_current, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, key, arginfo_class_SplDoublyLinkedList_key, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, next, arginfo_class_SplDoublyLinkedList_next, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, prev, arginfo_class_SplDoublyLinkedList_prev, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, valid, arginfo_class_SplDoublyLinkedList_valid, ZEND_ACC_PUBLIC)
- /* Serializable */
- SPL_ME(SplDoublyLinkedList, unserialize, arginfo_class_SplDoublyLinkedList_unserialize, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, serialize, arginfo_class_SplDoublyLinkedList_serialize, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, __unserialize, arginfo_class_SplDoublyLinkedList___unserialize, ZEND_ACC_PUBLIC)
- SPL_ME(SplDoublyLinkedList, __serialize, arginfo_class_SplDoublyLinkedList___serialize, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-/* }}} */
-
PHP_MINIT_FUNCTION(spl_dllist) /* {{{ */
{
- REGISTER_SPL_STD_CLASS_EX(SplDoublyLinkedList, spl_dllist_object_new, spl_funcs_SplDoublyLinkedList);
+ REGISTER_SPL_STD_CLASS_EX(SplDoublyLinkedList, spl_dllist_object_new, class_SplDoublyLinkedList_methods);
memcpy(&spl_handler_SplDoublyLinkedList, &std_object_handlers, sizeof(zend_object_handlers));
spl_handler_SplDoublyLinkedList.offset = XtOffsetOf(spl_dllist_object, std);
spl_ce_SplDoublyLinkedList->get_iterator = spl_dllist_get_iterator;
- REGISTER_SPL_SUB_CLASS_EX(SplQueue, SplDoublyLinkedList, spl_dllist_object_new, spl_funcs_SplQueue);
- REGISTER_SPL_SUB_CLASS_EX(SplStack, SplDoublyLinkedList, spl_dllist_object_new, NULL);
+ REGISTER_SPL_SUB_CLASS_EX(SplQueue, SplDoublyLinkedList, spl_dllist_object_new, class_SplQueue_methods);
+ REGISTER_SPL_SUB_CLASS_EX(SplStack, SplDoublyLinkedList, spl_dllist_object_new, class_SplStack_methods);
spl_ce_SplQueue->get_iterator = spl_dllist_get_iterator;
spl_ce_SplStack->get_iterator = spl_dllist_get_iterator;
<?php
+/** @generate-function-entries */
+
class SplDoublyLinkedList implements Iterator, Countable, ArrayAccess, Serializable
{
/**
/**
* @param mixed $value
* @return void
+ * @alias SplDoublyLinkedList::push
*/
public function enqueue($value) {}
- /** @return mixed */
+ /**
+ * @return mixed
+ * @alias SplDoublyLinkedList::shift
+ */
public function dequeue() {}
}
#define arginfo_class_SplQueue_enqueue arginfo_class_SplDoublyLinkedList_push
#define arginfo_class_SplQueue_dequeue arginfo_class_SplDoublyLinkedList_pop
+
+
+ZEND_METHOD(SplDoublyLinkedList, add);
+ZEND_METHOD(SplDoublyLinkedList, pop);
+ZEND_METHOD(SplDoublyLinkedList, shift);
+ZEND_METHOD(SplDoublyLinkedList, push);
+ZEND_METHOD(SplDoublyLinkedList, unshift);
+ZEND_METHOD(SplDoublyLinkedList, top);
+ZEND_METHOD(SplDoublyLinkedList, bottom);
+ZEND_METHOD(SplDoublyLinkedList, __debugInfo);
+ZEND_METHOD(SplDoublyLinkedList, count);
+ZEND_METHOD(SplDoublyLinkedList, isEmpty);
+ZEND_METHOD(SplDoublyLinkedList, setIteratorMode);
+ZEND_METHOD(SplDoublyLinkedList, getIteratorMode);
+ZEND_METHOD(SplDoublyLinkedList, offsetExists);
+ZEND_METHOD(SplDoublyLinkedList, offsetGet);
+ZEND_METHOD(SplDoublyLinkedList, offsetSet);
+ZEND_METHOD(SplDoublyLinkedList, offsetUnset);
+ZEND_METHOD(SplDoublyLinkedList, rewind);
+ZEND_METHOD(SplDoublyLinkedList, current);
+ZEND_METHOD(SplDoublyLinkedList, key);
+ZEND_METHOD(SplDoublyLinkedList, prev);
+ZEND_METHOD(SplDoublyLinkedList, next);
+ZEND_METHOD(SplDoublyLinkedList, valid);
+ZEND_METHOD(SplDoublyLinkedList, unserialize);
+ZEND_METHOD(SplDoublyLinkedList, serialize);
+ZEND_METHOD(SplDoublyLinkedList, __serialize);
+ZEND_METHOD(SplDoublyLinkedList, __unserialize);
+
+
+static const zend_function_entry class_SplDoublyLinkedList_methods[] = {
+ ZEND_ME(SplDoublyLinkedList, add, arginfo_class_SplDoublyLinkedList_add, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, pop, arginfo_class_SplDoublyLinkedList_pop, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, shift, arginfo_class_SplDoublyLinkedList_shift, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, push, arginfo_class_SplDoublyLinkedList_push, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, unshift, arginfo_class_SplDoublyLinkedList_unshift, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, top, arginfo_class_SplDoublyLinkedList_top, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, bottom, arginfo_class_SplDoublyLinkedList_bottom, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, __debugInfo, arginfo_class_SplDoublyLinkedList___debugInfo, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, count, arginfo_class_SplDoublyLinkedList_count, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, isEmpty, arginfo_class_SplDoublyLinkedList_isEmpty, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, setIteratorMode, arginfo_class_SplDoublyLinkedList_setIteratorMode, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, getIteratorMode, arginfo_class_SplDoublyLinkedList_getIteratorMode, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, offsetExists, arginfo_class_SplDoublyLinkedList_offsetExists, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, offsetGet, arginfo_class_SplDoublyLinkedList_offsetGet, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, offsetSet, arginfo_class_SplDoublyLinkedList_offsetSet, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, offsetUnset, arginfo_class_SplDoublyLinkedList_offsetUnset, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, rewind, arginfo_class_SplDoublyLinkedList_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, current, arginfo_class_SplDoublyLinkedList_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, key, arginfo_class_SplDoublyLinkedList_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, prev, arginfo_class_SplDoublyLinkedList_prev, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, next, arginfo_class_SplDoublyLinkedList_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, valid, arginfo_class_SplDoublyLinkedList_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, unserialize, arginfo_class_SplDoublyLinkedList_unserialize, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, serialize, arginfo_class_SplDoublyLinkedList_serialize, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, __serialize, arginfo_class_SplDoublyLinkedList___serialize, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplDoublyLinkedList, __unserialize, arginfo_class_SplDoublyLinkedList___unserialize, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SplQueue_methods[] = {
+ ZEND_MALIAS(SplDoublyLinkedList, enqueue, push, arginfo_class_SplQueue_enqueue, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplDoublyLinkedList, dequeue, shift, arginfo_class_SplQueue_dequeue, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SplStack_methods[] = {
+ ZEND_FE_END
+};
/* {{{ proto SplFixedArray::__construct([int size])
*/
-SPL_METHOD(SplFixedArray, __construct)
+PHP_METHOD(SplFixedArray, __construct)
{
zval *object = ZEND_THIS;
spl_fixedarray_object *intern;
/* {{{ proto SplFixedArray::__wakeup()
*/
-SPL_METHOD(SplFixedArray, __wakeup)
+PHP_METHOD(SplFixedArray, __wakeup)
{
spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
HashTable *intern_ht = zend_std_get_properties(Z_OBJ_P(ZEND_THIS));
/* {{{ proto int SplFixedArray::count(void)
*/
-SPL_METHOD(SplFixedArray, count)
+PHP_METHOD(SplFixedArray, count)
{
zval *object = ZEND_THIS;
spl_fixedarray_object *intern;
/* {{{ proto object SplFixedArray::toArray()
*/
-SPL_METHOD(SplFixedArray, toArray)
+PHP_METHOD(SplFixedArray, toArray)
{
spl_fixedarray_object *intern;
/* {{{ proto object SplFixedArray::fromArray(array array[, bool save_indexes])
*/
-SPL_METHOD(SplFixedArray, fromArray)
+PHP_METHOD(SplFixedArray, fromArray)
{
zval *data;
spl_fixedarray array;
/* {{{ proto int SplFixedArray::getSize(void)
*/
-SPL_METHOD(SplFixedArray, getSize)
+PHP_METHOD(SplFixedArray, getSize)
{
zval *object = ZEND_THIS;
spl_fixedarray_object *intern;
/* {{{ proto bool SplFixedArray::setSize(int size)
*/
-SPL_METHOD(SplFixedArray, setSize)
+PHP_METHOD(SplFixedArray, setSize)
{
zval *object = ZEND_THIS;
spl_fixedarray_object *intern;
/* {{{ proto bool SplFixedArray::offsetExists(mixed $index)
Returns whether the requested $index exists. */
-SPL_METHOD(SplFixedArray, offsetExists)
+PHP_METHOD(SplFixedArray, offsetExists)
{
zval *zindex;
spl_fixedarray_object *intern;
/* {{{ proto mixed SplFixedArray::offsetGet(mixed $index)
Returns the value at the specified $index. */
-SPL_METHOD(SplFixedArray, offsetGet)
+PHP_METHOD(SplFixedArray, offsetGet)
{
zval *zindex, *value;
spl_fixedarray_object *intern;
/* {{{ proto void SplFixedArray::offsetSet(mixed $index, mixed $newval)
Sets the value at the specified $index to $newval. */
-SPL_METHOD(SplFixedArray, offsetSet)
+PHP_METHOD(SplFixedArray, offsetSet)
{
zval *zindex, *value;
spl_fixedarray_object *intern;
/* {{{ proto void SplFixedArray::offsetUnset(mixed $index)
Unsets the value at the specified $index. */
-SPL_METHOD(SplFixedArray, offsetUnset)
+PHP_METHOD(SplFixedArray, offsetUnset)
{
zval *zindex;
spl_fixedarray_object *intern;
/* {{{ proto int SplFixedArray::key()
Return current array key */
-SPL_METHOD(SplFixedArray, key)
+PHP_METHOD(SplFixedArray, key)
{
spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
/* {{{ proto void SplFixedArray::next()
Move to next entry */
-SPL_METHOD(SplFixedArray, next)
+PHP_METHOD(SplFixedArray, next)
{
spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
/* {{{ proto bool SplFixedArray::valid()
Check whether the datastructure contains more entries */
-SPL_METHOD(SplFixedArray, valid)
+PHP_METHOD(SplFixedArray, valid)
{
spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
/* {{{ proto void SplFixedArray::rewind()
Rewind the datastructure back to the start */
-SPL_METHOD(SplFixedArray, rewind)
+PHP_METHOD(SplFixedArray, rewind)
{
spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
/* {{{ proto mixed|NULL SplFixedArray::current()
Return current datastructure entry */
-SPL_METHOD(SplFixedArray, current)
+PHP_METHOD(SplFixedArray, current)
{
zval zindex, *value;
spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(ZEND_THIS);
}
/* }}} */
-static const zend_function_entry spl_funcs_SplFixedArray[] = { /* {{{ */
- SPL_ME(SplFixedArray, __construct, arginfo_class_SplFixedArray___construct, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, __wakeup, arginfo_class_SplFixedArray___wakeup, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, count, arginfo_class_SplFixedArray_count, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, toArray, arginfo_class_SplFixedArray_toArray, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, fromArray, arginfo_class_SplFixedArray_fromArray, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
- SPL_ME(SplFixedArray, getSize, arginfo_class_SplFixedArray_getSize, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, setSize, arginfo_class_SplFixedArray_setSize, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, offsetExists, arginfo_class_SplFixedArray_offsetExists, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, offsetGet, arginfo_class_SplFixedArray_offsetGet, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, offsetSet, arginfo_class_SplFixedArray_offsetSet, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, offsetUnset, arginfo_class_SplFixedArray_offsetUnset, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, rewind, arginfo_class_SplFixedArray_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, current, arginfo_class_SplFixedArray_current, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, key, arginfo_class_SplFixedArray_key, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, next, arginfo_class_SplFixedArray_next, ZEND_ACC_PUBLIC)
- SPL_ME(SplFixedArray, valid, arginfo_class_SplFixedArray_valid, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-/* }}} */
-
/* {{{ PHP_MINIT_FUNCTION */
PHP_MINIT_FUNCTION(spl_fixedarray)
{
- REGISTER_SPL_STD_CLASS_EX(SplFixedArray, spl_fixedarray_new, spl_funcs_SplFixedArray);
+ REGISTER_SPL_STD_CLASS_EX(SplFixedArray, spl_fixedarray_new, class_SplFixedArray_methods);
memcpy(&spl_handler_SplFixedArray, &std_object_handlers, sizeof(zend_object_handlers));
spl_handler_SplFixedArray.offset = XtOffsetOf(spl_fixedarray_object, std);
<?php
+/** @generate-function-entries */
+
class SplFixedArray implements Iterator, ArrayAccess, Countable
{
public function __construct(int $size = 0) {}
#define arginfo_class_SplFixedArray_next arginfo_class_SplFixedArray___wakeup
#define arginfo_class_SplFixedArray_valid arginfo_class_SplFixedArray___wakeup
+
+
+ZEND_METHOD(SplFixedArray, __construct);
+ZEND_METHOD(SplFixedArray, __wakeup);
+ZEND_METHOD(SplFixedArray, count);
+ZEND_METHOD(SplFixedArray, toArray);
+ZEND_METHOD(SplFixedArray, fromArray);
+ZEND_METHOD(SplFixedArray, getSize);
+ZEND_METHOD(SplFixedArray, setSize);
+ZEND_METHOD(SplFixedArray, offsetExists);
+ZEND_METHOD(SplFixedArray, offsetGet);
+ZEND_METHOD(SplFixedArray, offsetSet);
+ZEND_METHOD(SplFixedArray, offsetUnset);
+ZEND_METHOD(SplFixedArray, rewind);
+ZEND_METHOD(SplFixedArray, current);
+ZEND_METHOD(SplFixedArray, key);
+ZEND_METHOD(SplFixedArray, next);
+ZEND_METHOD(SplFixedArray, valid);
+
+
+static const zend_function_entry class_SplFixedArray_methods[] = {
+ ZEND_ME(SplFixedArray, __construct, arginfo_class_SplFixedArray___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, __wakeup, arginfo_class_SplFixedArray___wakeup, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, count, arginfo_class_SplFixedArray_count, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, toArray, arginfo_class_SplFixedArray_toArray, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, fromArray, arginfo_class_SplFixedArray_fromArray, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+ ZEND_ME(SplFixedArray, getSize, arginfo_class_SplFixedArray_getSize, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, setSize, arginfo_class_SplFixedArray_setSize, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, offsetExists, arginfo_class_SplFixedArray_offsetExists, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, offsetGet, arginfo_class_SplFixedArray_offsetGet, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, offsetSet, arginfo_class_SplFixedArray_offsetSet, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, offsetUnset, arginfo_class_SplFixedArray_offsetUnset, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, rewind, arginfo_class_SplFixedArray_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, current, arginfo_class_SplFixedArray_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, key, arginfo_class_SplFixedArray_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, next, arginfo_class_SplFixedArray_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplFixedArray, valid, arginfo_class_SplFixedArray_valid, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
spl_register_sub_class(&spl_ce_ ## class_name, spl_ce_ ## parent_class_name, # class_name, obj_ctor, funcs);
#define REGISTER_SPL_INTERFACE(class_name) \
- spl_register_interface(&spl_ce_ ## class_name, # class_name, spl_funcs_ ## class_name);
+ spl_register_interface(&spl_ce_ ## class_name, # class_name, class_ ## class_name ## _methods);
#define REGISTER_SPL_IMPLEMENTS(class_name, interface_name) \
zend_class_implements(spl_ce_ ## class_name, 1, spl_ce_ ## interface_name);
/* caller must efree(return) */
zend_string *spl_gen_private_prop_name(zend_class_entry *ce, char *prop_name, int prop_len);
-#define SPL_ME(class_name, function_name, arg_info, flags) \
- PHP_ME( spl_ ## class_name, function_name, arg_info, flags)
-
-#define SPL_ABSTRACT_ME(class_name, function_name, arg_info) \
- ZEND_ABSTRACT_ME( spl_ ## class_name, function_name, arg_info)
-
-#define SPL_METHOD(class_name, function_name) \
- PHP_METHOD(spl_ ## class_name, function_name)
-
-#define SPL_MA(class_name, function_name, alias_class, alias_function, arg_info, flags) \
- PHP_MALIAS(spl_ ## alias_class, function_name, alias_function, arg_info, flags)
#endif /* PHP_FUNCTIONS_H */
/* {{{ proto int SplHeap::count()
Return the number of elements in the heap. */
-SPL_METHOD(SplHeap, count)
+PHP_METHOD(SplHeap, count)
{
zend_long count;
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
/* {{{ proto int SplHeap::isEmpty()
Return true if the heap is empty. */
-SPL_METHOD(SplHeap, isEmpty)
+PHP_METHOD(SplHeap, isEmpty)
{
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
/* {{{ proto bool SplHeap::insert(mixed value)
Push $value on the heap */
-SPL_METHOD(SplHeap, insert)
+PHP_METHOD(SplHeap, insert)
{
zval *value;
spl_heap_object *intern;
/* {{{ proto mixed SplHeap::extract()
extract the element out of the top of the heap */
-SPL_METHOD(SplHeap, extract)
+PHP_METHOD(SplHeap, extract)
{
spl_heap_object *intern;
/* {{{ proto bool SplPriorityQueue::insert(mixed value, mixed priority)
Push $value with the priority $priodiry on the priorityqueue */
-SPL_METHOD(SplPriorityQueue, insert)
+PHP_METHOD(SplPriorityQueue, insert)
{
zval *data, *priority;
spl_heap_object *intern;
/* {{{ proto mixed SplPriorityQueue::extract()
extract the element out of the top of the priority queue */
-SPL_METHOD(SplPriorityQueue, extract)
+PHP_METHOD(SplPriorityQueue, extract)
{
spl_pqueue_elem elem;
spl_heap_object *intern;
/* {{{ proto mixed SplPriorityQueue::top()
Peek at the top element of the priority queue */
-SPL_METHOD(SplPriorityQueue, top)
+PHP_METHOD(SplPriorityQueue, top)
{
spl_heap_object *intern;
spl_pqueue_elem *elem;
/* {{{ proto int SplPriorityQueue::setExtractFlags(int flags)
Set the flags of extraction*/
-SPL_METHOD(SplPriorityQueue, setExtractFlags)
+PHP_METHOD(SplPriorityQueue, setExtractFlags)
{
zend_long value;
spl_heap_object *intern;
/* {{{ proto int SplPriorityQueue::getExtractFlags()
Get the flags of extraction*/
-SPL_METHOD(SplPriorityQueue, getExtractFlags)
+PHP_METHOD(SplPriorityQueue, getExtractFlags)
{
spl_heap_object *intern;
/* {{{ proto int SplHeap::recoverFromCorruption()
Recover from a corrupted state*/
-SPL_METHOD(SplHeap, recoverFromCorruption)
+PHP_METHOD(SplHeap, recoverFromCorruption)
{
spl_heap_object *intern;
/* {{{ proto int SplHeap::isCorrupted()
Tells if the heap is in a corrupted state*/
-SPL_METHOD(SplHeap, isCorrupted)
+PHP_METHOD(SplHeap, isCorrupted)
{
spl_heap_object *intern;
/* {{{ proto bool SplPriorityQueue::compare(mixed $value1, mixed $value2)
compare the priorities */
-SPL_METHOD(SplPriorityQueue, compare)
+PHP_METHOD(SplPriorityQueue, compare)
{
zval *a, *b;
/* {{{ proto mixed SplHeap::top()
Peek at the top element of the heap */
-SPL_METHOD(SplHeap, top)
+PHP_METHOD(SplHeap, top)
{
zval *value;
spl_heap_object *intern;
/* {{{ proto bool SplMinHeap::compare(mixed $value1, mixed $value2)
compare the values */
-SPL_METHOD(SplMinHeap, compare)
+PHP_METHOD(SplMinHeap, compare)
{
zval *a, *b;
/* {{{ proto bool SplMaxHeap::compare(mixed $value1, mixed $value2)
compare the values */
-SPL_METHOD(SplMaxHeap, compare)
+PHP_METHOD(SplMaxHeap, compare)
{
zval *a, *b;
/* {{{ proto int SplHeap::key()
Return current array key */
-SPL_METHOD(SplHeap, key)
+PHP_METHOD(SplHeap, key)
{
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
/* {{{ proto void SplHeap::next()
Move to next entry */
-SPL_METHOD(SplHeap, next)
+PHP_METHOD(SplHeap, next)
{
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
/* {{{ proto bool SplHeap::valid()
Check whether the datastructure contains more entries */
-SPL_METHOD(SplHeap, valid)
+PHP_METHOD(SplHeap, valid)
{
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
/* {{{ proto void SplHeap::rewind()
Rewind the datastructure back to the start */
-SPL_METHOD(SplHeap, rewind)
+PHP_METHOD(SplHeap, rewind)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto mixed|NULL SplHeap::current()
Return current datastructure entry */
-SPL_METHOD(SplHeap, current)
+PHP_METHOD(SplHeap, current)
{
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
/* {{{ proto mixed|NULL SplPriorityQueue::current()
Return current datastructure entry */
-SPL_METHOD(SplPriorityQueue, current)
+PHP_METHOD(SplPriorityQueue, current)
{
spl_heap_object *intern = Z_SPLHEAP_P(ZEND_THIS);
/* }}} */
/* {{{ proto void SplHeap::__debugInfo() */
-SPL_METHOD(SplHeap, __debugInfo)
+PHP_METHOD(SplHeap, __debugInfo)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
} /* }}} */
/* {{{ proto void SplPriorityQueue::__debugInfo() */
-SPL_METHOD(SplPriorityQueue, __debugInfo)
+PHP_METHOD(SplPriorityQueue, __debugInfo)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
}
/* }}} */
-static const zend_function_entry spl_funcs_SplMinHeap[] = {
- SPL_ME(SplMinHeap, compare, arginfo_class_SplMinHeap_compare, ZEND_ACC_PROTECTED)
- PHP_FE_END
-};
-static const zend_function_entry spl_funcs_SplMaxHeap[] = {
- SPL_ME(SplMaxHeap, compare, arginfo_class_SplMaxHeap_compare, ZEND_ACC_PROTECTED)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_SplPriorityQueue[] = {
- SPL_ME(SplPriorityQueue, compare, arginfo_class_SplPriorityQueue_compare, ZEND_ACC_PUBLIC)
- SPL_ME(SplPriorityQueue, insert, arginfo_class_SplPriorityQueue_insert, ZEND_ACC_PUBLIC)
- SPL_ME(SplPriorityQueue, setExtractFlags, arginfo_class_SplPriorityQueue_setExtractFlags, ZEND_ACC_PUBLIC)
- SPL_ME(SplPriorityQueue, getExtractFlags, arginfo_class_SplPriorityQueue_getExtractFlags, ZEND_ACC_PUBLIC)
- SPL_ME(SplPriorityQueue, top, arginfo_class_SplPriorityQueue_top, ZEND_ACC_PUBLIC)
- SPL_ME(SplPriorityQueue, extract, arginfo_class_SplPriorityQueue_extract, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, count, arginfo_class_SplPriorityQueue_count, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, isEmpty, arginfo_class_SplPriorityQueue_isEmpty, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, rewind, arginfo_class_SplPriorityQueue_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(SplPriorityQueue, current, arginfo_class_SplPriorityQueue_current, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, key, arginfo_class_SplPriorityQueue_key, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, next, arginfo_class_SplPriorityQueue_next, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, valid, arginfo_class_SplPriorityQueue_valid, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, recoverFromCorruption, arginfo_class_SplPriorityQueue_recoverFromCorruption, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, isCorrupted, arginfo_class_SplPriorityQueue_isCorrupted, ZEND_ACC_PUBLIC)
- SPL_ME(SplPriorityQueue, __debugInfo, arginfo_class_SplPriorityQueue___debugInfo, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_SplHeap[] = {
- SPL_ME(SplHeap, extract, arginfo_class_SplHeap_extract, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, insert, arginfo_class_SplHeap_insert, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, top, arginfo_class_SplHeap_top, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, count, arginfo_class_SplHeap_count, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, isEmpty, arginfo_class_SplHeap_isEmpty, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, rewind, arginfo_class_SplHeap_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, current, arginfo_class_SplHeap_current, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, key, arginfo_class_SplHeap_key, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, next, arginfo_class_SplHeap_next, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, valid, arginfo_class_SplHeap_valid, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, recoverFromCorruption, arginfo_class_SplHeap_recoverFromCorruption, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, isCorrupted, arginfo_class_SplHeap_isCorrupted, ZEND_ACC_PUBLIC)
- SPL_ME(SplHeap, __debugInfo, arginfo_class_SplHeap___debugInfo, ZEND_ACC_PUBLIC)
- ZEND_FENTRY(compare, NULL, arginfo_class_SplHeap_compare, ZEND_ACC_PROTECTED|ZEND_ACC_ABSTRACT)
- PHP_FE_END
-};
-/* }}} */
-
PHP_MINIT_FUNCTION(spl_heap) /* {{{ */
{
- REGISTER_SPL_STD_CLASS_EX(SplHeap, spl_heap_object_new, spl_funcs_SplHeap);
+ REGISTER_SPL_STD_CLASS_EX(SplHeap, spl_heap_object_new, class_SplHeap_methods);
memcpy(&spl_handler_SplHeap, &std_object_handlers, sizeof(zend_object_handlers));
spl_handler_SplHeap.offset = XtOffsetOf(spl_heap_object, std);
spl_ce_SplHeap->get_iterator = spl_heap_get_iterator;
- REGISTER_SPL_SUB_CLASS_EX(SplMinHeap, SplHeap, spl_heap_object_new, spl_funcs_SplMinHeap);
- REGISTER_SPL_SUB_CLASS_EX(SplMaxHeap, SplHeap, spl_heap_object_new, spl_funcs_SplMaxHeap);
+ REGISTER_SPL_SUB_CLASS_EX(SplMinHeap, SplHeap, spl_heap_object_new, class_SplMinHeap_methods);
+ REGISTER_SPL_SUB_CLASS_EX(SplMaxHeap, SplHeap, spl_heap_object_new, class_SplMaxHeap_methods);
spl_ce_SplMaxHeap->get_iterator = spl_heap_get_iterator;
spl_ce_SplMinHeap->get_iterator = spl_heap_get_iterator;
- REGISTER_SPL_STD_CLASS_EX(SplPriorityQueue, spl_heap_object_new, spl_funcs_SplPriorityQueue);
+ REGISTER_SPL_STD_CLASS_EX(SplPriorityQueue, spl_heap_object_new, class_SplPriorityQueue_methods);
memcpy(&spl_handler_SplPriorityQueue, &std_object_handlers, sizeof(zend_object_handlers));
spl_handler_SplPriorityQueue.offset = XtOffsetOf(spl_heap_object, std);
<?php
+/** @generate-function-entries */
+
class SplPriorityQueue implements Iterator, Countable
{
/**
/** @return mixed */
public function extract() {}
- /** @return int */
+ /**
+ * @return int
+ * @alias SplHeap::count
+ */
public function count() {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias SplHeap::isEmpty
+ */
public function isEmpty() {}
- /** @return void */
+ /**
+ * @return void
+ * @alias SplHeap::rewind
+ */
public function rewind() {}
/** @return mixed */
public function current() {}
- /** @return int */
+ /**
+ * @return int
+ * @alias SplHeap::key
+ */
public function key() {}
- /** @return void */
+ /**
+ * @return void
+ * @alias SplHeap::next
+ */
public function next() {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias SplHeap::valid
+ */
public function valid() {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias SplHeap::recoverFromCorruption
+ */
public function recoverFromCorruption() {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias SplHeap::isCorrupted
+ */
public function isCorrupted() {}
/** @return int */
#define arginfo_class_SplMinHeap_compare arginfo_class_SplHeap_compare
#define arginfo_class_SplMaxHeap_compare arginfo_class_SplHeap_compare
+
+
+ZEND_METHOD(SplPriorityQueue, compare);
+ZEND_METHOD(SplPriorityQueue, insert);
+ZEND_METHOD(SplPriorityQueue, setExtractFlags);
+ZEND_METHOD(SplPriorityQueue, top);
+ZEND_METHOD(SplPriorityQueue, extract);
+ZEND_METHOD(SplHeap, count);
+ZEND_METHOD(SplHeap, isEmpty);
+ZEND_METHOD(SplHeap, rewind);
+ZEND_METHOD(SplPriorityQueue, current);
+ZEND_METHOD(SplHeap, key);
+ZEND_METHOD(SplHeap, next);
+ZEND_METHOD(SplHeap, valid);
+ZEND_METHOD(SplHeap, recoverFromCorruption);
+ZEND_METHOD(SplHeap, isCorrupted);
+ZEND_METHOD(SplPriorityQueue, getExtractFlags);
+ZEND_METHOD(SplPriorityQueue, __debugInfo);
+ZEND_METHOD(SplHeap, extract);
+ZEND_METHOD(SplHeap, insert);
+ZEND_METHOD(SplHeap, top);
+ZEND_METHOD(SplHeap, current);
+ZEND_METHOD(SplHeap, __debugInfo);
+ZEND_METHOD(SplMinHeap, compare);
+ZEND_METHOD(SplMaxHeap, compare);
+
+
+static const zend_function_entry class_SplPriorityQueue_methods[] = {
+ ZEND_ME(SplPriorityQueue, compare, arginfo_class_SplPriorityQueue_compare, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplPriorityQueue, insert, arginfo_class_SplPriorityQueue_insert, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplPriorityQueue, setExtractFlags, arginfo_class_SplPriorityQueue_setExtractFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplPriorityQueue, top, arginfo_class_SplPriorityQueue_top, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplPriorityQueue, extract, arginfo_class_SplPriorityQueue_extract, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplHeap, count, count, arginfo_class_SplPriorityQueue_count, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplHeap, isEmpty, isEmpty, arginfo_class_SplPriorityQueue_isEmpty, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplHeap, rewind, rewind, arginfo_class_SplPriorityQueue_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplPriorityQueue, current, arginfo_class_SplPriorityQueue_current, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplHeap, key, key, arginfo_class_SplPriorityQueue_key, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplHeap, next, next, arginfo_class_SplPriorityQueue_next, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplHeap, valid, valid, arginfo_class_SplPriorityQueue_valid, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplHeap, recoverFromCorruption, recoverFromCorruption, arginfo_class_SplPriorityQueue_recoverFromCorruption, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplHeap, isCorrupted, isCorrupted, arginfo_class_SplPriorityQueue_isCorrupted, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplPriorityQueue, getExtractFlags, arginfo_class_SplPriorityQueue_getExtractFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplPriorityQueue, __debugInfo, arginfo_class_SplPriorityQueue___debugInfo, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SplHeap_methods[] = {
+ ZEND_ME(SplHeap, extract, arginfo_class_SplHeap_extract, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplHeap, insert, arginfo_class_SplHeap_insert, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplHeap, top, arginfo_class_SplHeap_top, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplHeap, count, arginfo_class_SplHeap_count, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplHeap, isEmpty, arginfo_class_SplHeap_isEmpty, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplHeap, rewind, arginfo_class_SplHeap_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplHeap, current, arginfo_class_SplHeap_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplHeap, key, arginfo_class_SplHeap_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplHeap, next, arginfo_class_SplHeap_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplHeap, valid, arginfo_class_SplHeap_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplHeap, recoverFromCorruption, arginfo_class_SplHeap_recoverFromCorruption, ZEND_ACC_PUBLIC)
+ ZEND_ABSTRACT_ME_WITH_FLAGS(SplHeap, compare, arginfo_class_SplHeap_compare, ZEND_ACC_PROTECTED|ZEND_ACC_ABSTRACT)
+ ZEND_ME(SplHeap, isCorrupted, arginfo_class_SplHeap_isCorrupted, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplHeap, __debugInfo, arginfo_class_SplHeap___debugInfo, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SplMinHeap_methods[] = {
+ ZEND_ME(SplMinHeap, compare, arginfo_class_SplMinHeap_compare, ZEND_ACC_PROTECTED)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SplMaxHeap_methods[] = {
+ ZEND_ME(SplMaxHeap, compare, arginfo_class_SplMaxHeap_compare, ZEND_ACC_PROTECTED)
+ ZEND_FE_END
+};
PHPAPI zend_class_entry *spl_ce_RecursiveRegexIterator;
PHPAPI zend_class_entry *spl_ce_RecursiveTreeIterator;
-static const zend_function_entry spl_funcs_RecursiveIterator[] = {
- SPL_ABSTRACT_ME(RecursiveIterator, hasChildren, arginfo_class_RecursiveIterator_hasChildren)
- SPL_ABSTRACT_ME(RecursiveIterator, getChildren, arginfo_class_RecursiveIterator_getChildren)
- PHP_FE_END
-};
-
typedef enum {
RIT_LEAVES_ONLY = 0,
RIT_SELF_FIRST = 1,
/* {{{ proto RecursiveIteratorIterator::__construct(RecursiveIterator|IteratorAggregate it [, int mode = RIT_LEAVES_ONLY [, int flags = 0]]) throws InvalidArgumentException
Creates a RecursiveIteratorIterator from a RecursiveIterator. */
-SPL_METHOD(RecursiveIteratorIterator, __construct)
+PHP_METHOD(RecursiveIteratorIterator, __construct)
{
spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveIteratorIterator, zend_ce_iterator, RIT_RecursiveIteratorIterator);
} /* }}} */
/* {{{ proto void RecursiveIteratorIterator::rewind()
Rewind the iterator to the first element of the top level inner iterator. */
-SPL_METHOD(RecursiveIteratorIterator, rewind)
+PHP_METHOD(RecursiveIteratorIterator, rewind)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
/* {{{ proto bool RecursiveIteratorIterator::valid()
Check whether the current position is valid */
-SPL_METHOD(RecursiveIteratorIterator, valid)
+PHP_METHOD(RecursiveIteratorIterator, valid)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
/* {{{ proto mixed RecursiveIteratorIterator::key()
Access the current key */
-SPL_METHOD(RecursiveIteratorIterator, key)
+PHP_METHOD(RecursiveIteratorIterator, key)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
zend_object_iterator *iterator;
/* {{{ proto mixed RecursiveIteratorIterator::current()
Access the current element value */
-SPL_METHOD(RecursiveIteratorIterator, current)
+PHP_METHOD(RecursiveIteratorIterator, current)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
zend_object_iterator *iterator;
/* {{{ proto void RecursiveIteratorIterator::next()
Move forward to the next element */
-SPL_METHOD(RecursiveIteratorIterator, next)
+PHP_METHOD(RecursiveIteratorIterator, next)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
/* {{{ proto int RecursiveIteratorIterator::getDepth()
Get the current depth of the recursive iteration */
-SPL_METHOD(RecursiveIteratorIterator, getDepth)
+PHP_METHOD(RecursiveIteratorIterator, getDepth)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
/* {{{ proto RecursiveIterator RecursiveIteratorIterator::getSubIterator([int level])
The current active sub iterator or the iterator at specified level */
-SPL_METHOD(RecursiveIteratorIterator, getSubIterator)
+PHP_METHOD(RecursiveIteratorIterator, getSubIterator)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
zend_long level = object->level;
/* {{{ proto RecursiveIterator RecursiveIteratorIterator::getInnerIterator()
The current active sub iterator */
-SPL_METHOD(RecursiveIteratorIterator, getInnerIterator)
+PHP_METHOD(RecursiveIteratorIterator, getInnerIterator)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
zval *zobject;
/* {{{ proto RecursiveIterator RecursiveIteratorIterator::beginIteration()
Called when iteration begins (after first rewind() call) */
-SPL_METHOD(RecursiveIteratorIterator, beginIteration)
+PHP_METHOD(RecursiveIteratorIterator, beginIteration)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto RecursiveIterator RecursiveIteratorIterator::endIteration()
Called when iteration ends (when valid() first returns false */
-SPL_METHOD(RecursiveIteratorIterator, endIteration)
+PHP_METHOD(RecursiveIteratorIterator, endIteration)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto bool RecursiveIteratorIterator::callHasChildren()
Called for each element to test whether it has children */
-SPL_METHOD(RecursiveIteratorIterator, callHasChildren)
+PHP_METHOD(RecursiveIteratorIterator, callHasChildren)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
zend_class_entry *ce;
/* {{{ proto RecursiveIterator RecursiveIteratorIterator::callGetChildren()
Return children of current element */
-SPL_METHOD(RecursiveIteratorIterator, callGetChildren)
+PHP_METHOD(RecursiveIteratorIterator, callGetChildren)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
zend_class_entry *ce;
/* {{{ proto void RecursiveIteratorIterator::beginChildren()
Called when recursing one level down */
-SPL_METHOD(RecursiveIteratorIterator, beginChildren)
+PHP_METHOD(RecursiveIteratorIterator, beginChildren)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto void RecursiveIteratorIterator::endChildren()
Called when end recursing one level */
-SPL_METHOD(RecursiveIteratorIterator, endChildren)
+PHP_METHOD(RecursiveIteratorIterator, endChildren)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto void RecursiveIteratorIterator::nextElement()
Called when the next element is available */
-SPL_METHOD(RecursiveIteratorIterator, nextElement)
+PHP_METHOD(RecursiveIteratorIterator, nextElement)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto void RecursiveIteratorIterator::setMaxDepth([$max_depth = -1])
Set the maximum allowed depth (or any depth if pmax_depth = -1] */
-SPL_METHOD(RecursiveIteratorIterator, setMaxDepth)
+PHP_METHOD(RecursiveIteratorIterator, setMaxDepth)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
zend_long max_depth = -1;
/* {{{ proto int|false RecursiveIteratorIterator::getMaxDepth()
Return the maximum accepted depth or false if any depth is allowed */
-SPL_METHOD(RecursiveIteratorIterator, getMaxDepth)
+PHP_METHOD(RecursiveIteratorIterator, getMaxDepth)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
}
/* }}} */
-static const zend_function_entry spl_funcs_RecursiveIteratorIterator[] = {
- SPL_ME(RecursiveIteratorIterator, __construct, arginfo_class_RecursiveIteratorIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, rewind, arginfo_class_RecursiveIteratorIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, valid, arginfo_class_RecursiveIteratorIterator_valid, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, key, arginfo_class_RecursiveIteratorIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, current, arginfo_class_RecursiveIteratorIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, next, arginfo_class_RecursiveIteratorIterator_next, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, getDepth, arginfo_class_RecursiveIteratorIterator_getDepth, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, getSubIterator, arginfo_class_RecursiveIteratorIterator_getSubIterator, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, getInnerIterator, arginfo_class_RecursiveIteratorIterator_getInnerIterator, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, beginIteration, arginfo_class_RecursiveIteratorIterator_beginIteration, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, endIteration, arginfo_class_RecursiveIteratorIterator_endIteration, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, callHasChildren, arginfo_class_RecursiveIteratorIterator_callHasChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, callGetChildren, arginfo_class_RecursiveIteratorIterator_callGetChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, beginChildren, arginfo_class_RecursiveIteratorIterator_beginChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, endChildren, arginfo_class_RecursiveIteratorIterator_endChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, nextElement, arginfo_class_RecursiveIteratorIterator_nextElement, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, setMaxDepth, arginfo_class_RecursiveIteratorIterator_setMaxDepth, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, getMaxDepth, arginfo_class_RecursiveIteratorIterator_getMaxDepth, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
static void spl_recursive_tree_iterator_get_prefix(spl_recursive_it_object *object, zval *return_value)
{
smart_str str = {0};
/* {{{ proto RecursiveTreeIterator::__construct(RecursiveIterator|IteratorAggregate it [, int flags = RTIT_BYPASS_KEY [, int cit_flags = CIT_CATCH_GET_CHILD [, mode = RIT_SELF_FIRST ]]]) throws InvalidArgumentException
RecursiveIteratorIterator to generate ASCII graphic trees for the entries in a RecursiveIterator */
-SPL_METHOD(RecursiveTreeIterator, __construct)
+PHP_METHOD(RecursiveTreeIterator, __construct)
{
spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveTreeIterator, zend_ce_iterator, RIT_RecursiveTreeIterator);
} /* }}} */
/* {{{ proto void RecursiveTreeIterator::setPrefixPart(int part, string prefix) throws OutOfRangeException
Sets prefix parts as used in getPrefix() */
-SPL_METHOD(RecursiveTreeIterator, setPrefixPart)
+PHP_METHOD(RecursiveTreeIterator, setPrefixPart)
{
zend_long part;
char* prefix;
/* {{{ proto string RecursiveTreeIterator::getPrefix()
Returns the string to place in front of current element */
-SPL_METHOD(RecursiveTreeIterator, getPrefix)
+PHP_METHOD(RecursiveTreeIterator, getPrefix)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
/* {{{ proto void RecursiveTreeIterator::setPostfix(string prefix)
Sets postfix as used in getPostfix() */
-SPL_METHOD(RecursiveTreeIterator, setPostfix)
+PHP_METHOD(RecursiveTreeIterator, setPostfix)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
char* postfix;
/* {{{ proto string RecursiveTreeIterator::getEntry()
Returns the string presentation built for current element */
-SPL_METHOD(RecursiveTreeIterator, getEntry)
+PHP_METHOD(RecursiveTreeIterator, getEntry)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
/* {{{ proto string RecursiveTreeIterator::getPostfix()
Returns the string to place after the current element */
-SPL_METHOD(RecursiveTreeIterator, getPostfix)
+PHP_METHOD(RecursiveTreeIterator, getPostfix)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
/* {{{ proto mixed RecursiveTreeIterator::current()
Returns the current element prefixed and postfixed */
-SPL_METHOD(RecursiveTreeIterator, current)
+PHP_METHOD(RecursiveTreeIterator, current)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
zval prefix, entry, postfix;
/* {{{ proto mixed RecursiveTreeIterator::key()
Returns the current key prefixed and postfixed */
-SPL_METHOD(RecursiveTreeIterator, key)
+PHP_METHOD(RecursiveTreeIterator, key)
{
spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(ZEND_THIS);
zend_object_iterator *iterator;
RETURN_NEW_STR(str);
} /* }}} */
-static const zend_function_entry spl_funcs_RecursiveTreeIterator[] = {
- SPL_ME(RecursiveTreeIterator, __construct, arginfo_class_RecursiveTreeIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, rewind, arginfo_class_RecursiveTreeIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, valid, arginfo_class_RecursiveTreeIterator_valid, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveTreeIterator, key, arginfo_class_RecursiveTreeIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveTreeIterator, current, arginfo_class_RecursiveTreeIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, next, arginfo_class_RecursiveTreeIterator_next, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, beginIteration, arginfo_class_RecursiveTreeIterator_beginIteration, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, endIteration, arginfo_class_RecursiveTreeIterator_endIteration, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, callHasChildren, arginfo_class_RecursiveTreeIterator_callHasChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, callGetChildren, arginfo_class_RecursiveTreeIterator_callGetChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, beginChildren, arginfo_class_RecursiveTreeIterator_beginChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, endChildren, arginfo_class_RecursiveTreeIterator_endChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveIteratorIterator, nextElement, arginfo_class_RecursiveTreeIterator_nextElement, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveTreeIterator, getPrefix, arginfo_class_RecursiveTreeIterator_getPrefix, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveTreeIterator, setPrefixPart, arginfo_class_RecursiveTreeIterator_setPrefixPart, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveTreeIterator, getEntry, arginfo_class_RecursiveTreeIterator_getEntry, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveTreeIterator, setPostfix, arginfo_class_RecursiveTreeIterator_setPostfix, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveTreeIterator, getPostfix, arginfo_class_RecursiveTreeIterator_getPostfix, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
static zend_function *spl_dual_it_get_method(zend_object **object, zend_string *method, const zval *key)
{
zend_function *function_handler;
/* {{{ proto FilterIterator::__construct(Iterator it)
Create an Iterator from another iterator */
-SPL_METHOD(FilterIterator, __construct)
+PHP_METHOD(FilterIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_FilterIterator, zend_ce_iterator, DIT_FilterIterator);
} /* }}} */
/* {{{ proto CallbackFilterIterator::__construct(Iterator it, callback func)
Create an Iterator from another iterator */
-SPL_METHOD(CallbackFilterIterator, __construct)
+PHP_METHOD(CallbackFilterIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_CallbackFilterIterator, zend_ce_iterator, DIT_CallbackFilterIterator);
} /* }}} */
proto Iterator LimitIterator::getInnerIterator()
proto Iterator ParentIterator::getInnerIterator()
Get the inner iterator */
-SPL_METHOD(dual_it, getInnerIterator)
+PHP_METHOD(IteratorIterator, getInnerIterator)
{
spl_dual_it_object *intern;
proto void IteratorIterator::rewind()
Rewind the iterator
*/
-SPL_METHOD(dual_it, rewind)
+PHP_METHOD(IteratorIterator, rewind)
{
spl_dual_it_object *intern;
proto bool IteratorIterator::valid()
proto bool NoRewindIterator::valid()
Check whether the current element is valid */
-SPL_METHOD(dual_it, valid)
+PHP_METHOD(IteratorIterator, valid)
{
spl_dual_it_object *intern;
proto mixed NoRewindIterator::key()
proto mixed AppendIterator::key()
Get the current key */
-SPL_METHOD(dual_it, key)
+PHP_METHOD(IteratorIterator, key)
{
spl_dual_it_object *intern;
proto mixed IteratorIterator::current()
proto mixed NoRewindIterator::current()
Get the current element value */
-SPL_METHOD(dual_it, current)
+PHP_METHOD(IteratorIterator, current)
{
spl_dual_it_object *intern;
proto void IteratorIterator::next()
proto void NoRewindIterator::next()
Move the iterator forward */
-SPL_METHOD(dual_it, next)
+PHP_METHOD(IteratorIterator, next)
{
spl_dual_it_object *intern;
/* {{{ proto void FilterIterator::rewind()
Rewind the iterator */
-SPL_METHOD(FilterIterator, rewind)
+PHP_METHOD(FilterIterator, rewind)
{
spl_dual_it_object *intern;
/* {{{ proto void FilterIterator::next()
Move the iterator forward */
-SPL_METHOD(FilterIterator, next)
+PHP_METHOD(FilterIterator, next)
{
spl_dual_it_object *intern;
/* {{{ proto RecursiveCallbackFilterIterator::__construct(RecursiveIterator it, callback func)
Create a RecursiveCallbackFilterIterator from a RecursiveIterator */
-SPL_METHOD(RecursiveCallbackFilterIterator, __construct)
+PHP_METHOD(RecursiveCallbackFilterIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveCallbackFilterIterator, spl_ce_RecursiveIterator, DIT_RecursiveCallbackFilterIterator);
} /* }}} */
/* {{{ proto RecursiveFilterIterator::__construct(RecursiveIterator it)
Create a RecursiveFilterIterator from a RecursiveIterator */
-SPL_METHOD(RecursiveFilterIterator, __construct)
+PHP_METHOD(RecursiveFilterIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveFilterIterator, spl_ce_RecursiveIterator, DIT_RecursiveFilterIterator);
} /* }}} */
/* {{{ proto bool RecursiveFilterIterator::hasChildren()
Check whether the inner iterator's current element has children */
-SPL_METHOD(RecursiveFilterIterator, hasChildren)
+PHP_METHOD(RecursiveFilterIterator, hasChildren)
{
spl_dual_it_object *intern;
/* {{{ proto RecursiveFilterIterator RecursiveFilterIterator::getChildren()
Return the inner iterator's children contained in a RecursiveFilterIterator */
-SPL_METHOD(RecursiveFilterIterator, getChildren)
+PHP_METHOD(RecursiveFilterIterator, getChildren)
{
spl_dual_it_object *intern;
zval retval;
/* {{{ proto RecursiveCallbackFilterIterator RecursiveCallbackFilterIterator::getChildren()
Return the inner iterator's children contained in a RecursiveCallbackFilterIterator */
-SPL_METHOD(RecursiveCallbackFilterIterator, getChildren)
+PHP_METHOD(RecursiveCallbackFilterIterator, getChildren)
{
spl_dual_it_object *intern;
zval retval;
} /* }}} */
/* {{{ proto ParentIterator::__construct(RecursiveIterator it)
Create a ParentIterator from a RecursiveIterator */
-SPL_METHOD(ParentIterator, __construct)
+PHP_METHOD(ParentIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_ParentIterator, spl_ce_RecursiveIterator, DIT_ParentIterator);
} /* }}} */
/* {{{ proto RegexIterator::__construct(Iterator it, string regex [, int mode [, int flags [, int preg_flags]]])
Create an RegexIterator from another iterator and a regular expression */
-SPL_METHOD(RegexIterator, __construct)
+PHP_METHOD(RegexIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RegexIterator, zend_ce_iterator, DIT_RegexIterator);
} /* }}} */
/* {{{ proto bool CallbackFilterIterator::accept()
Calls the callback with the current value, the current key and the inner iterator as arguments */
-SPL_METHOD(CallbackFilterIterator, accept)
+PHP_METHOD(CallbackFilterIterator, accept)
{
spl_dual_it_object *intern = Z_SPLDUAL_IT_P(ZEND_THIS);
zend_fcall_info *fci = &intern->u.cbfilter->fci;
/* {{{ proto bool RegexIterator::accept()
Match (string)current() against regular expression */
-SPL_METHOD(RegexIterator, accept)
+PHP_METHOD(RegexIterator, accept)
{
spl_dual_it_object *intern;
zend_string *result, *subject;
/* {{{ proto string RegexIterator::getRegex()
Returns current regular expression */
-SPL_METHOD(RegexIterator, getRegex)
+PHP_METHOD(RegexIterator, getRegex)
{
spl_dual_it_object *intern = Z_SPLDUAL_IT_P(ZEND_THIS);
/* {{{ proto bool RegexIterator::getMode()
Returns current operation mode */
-SPL_METHOD(RegexIterator, getMode)
+PHP_METHOD(RegexIterator, getMode)
{
spl_dual_it_object *intern;
/* {{{ proto bool RegexIterator::setMode(int new_mode)
Set new operation mode */
-SPL_METHOD(RegexIterator, setMode)
+PHP_METHOD(RegexIterator, setMode)
{
spl_dual_it_object *intern;
zend_long mode;
/* {{{ proto bool RegexIterator::getFlags()
Returns current operation flags */
-SPL_METHOD(RegexIterator, getFlags)
+PHP_METHOD(RegexIterator, getFlags)
{
spl_dual_it_object *intern;
/* {{{ proto bool RegexIterator::setFlags(int new_flags)
Set operation flags */
-SPL_METHOD(RegexIterator, setFlags)
+PHP_METHOD(RegexIterator, setFlags)
{
spl_dual_it_object *intern;
zend_long flags;
/* {{{ proto bool RegexIterator::getFlags()
Returns current PREG flags (if in use or NULL) */
-SPL_METHOD(RegexIterator, getPregFlags)
+PHP_METHOD(RegexIterator, getPregFlags)
{
spl_dual_it_object *intern;
/* {{{ proto bool RegexIterator::setPregFlags(int new_flags)
Set PREG flags */
-SPL_METHOD(RegexIterator, setPregFlags)
+PHP_METHOD(RegexIterator, setPregFlags)
{
spl_dual_it_object *intern;
zend_long preg_flags;
/* {{{ proto RecursiveRegexIterator::__construct(RecursiveIterator it, string regex [, int mode [, int flags [, int preg_flags]]])
Create an RecursiveRegexIterator from another recursive iterator and a regular expression */
-SPL_METHOD(RecursiveRegexIterator, __construct)
+PHP_METHOD(RecursiveRegexIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveRegexIterator, spl_ce_RecursiveIterator, DIT_RecursiveRegexIterator);
} /* }}} */
/* {{{ proto RecursiveRegexIterator RecursiveRegexIterator::getChildren()
Return the inner iterator's children contained in a RecursiveRegexIterator */
-SPL_METHOD(RecursiveRegexIterator, getChildren)
+PHP_METHOD(RecursiveRegexIterator, getChildren)
{
spl_dual_it_object *intern;
zval retval;
zval_ptr_dtor(&retval);
} /* }}} */
-SPL_METHOD(RecursiveRegexIterator, accept)
+PHP_METHOD(RecursiveRegexIterator, accept)
{
spl_dual_it_object *intern;
}
/* }}} */
-static const zend_function_entry spl_funcs_FilterIterator[] = {
- SPL_ME(FilterIterator, __construct, arginfo_class_FilterIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(FilterIterator, rewind, arginfo_class_FilterIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, valid, arginfo_class_FilterIterator_valid, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, key, arginfo_class_FilterIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, current, arginfo_class_FilterIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(FilterIterator, next, arginfo_class_FilterIterator_next, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, getInnerIterator, arginfo_class_FilterIterator_getInnerIterator, ZEND_ACC_PUBLIC)
- SPL_ABSTRACT_ME(FilterIterator, accept, arginfo_class_FilterIterator_accept)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_CallbackFilterIterator[] = {
- SPL_ME(CallbackFilterIterator, __construct, arginfo_class_CallbackFilterIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(CallbackFilterIterator, accept, arginfo_class_CallbackFilterIterator_accept, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_RecursiveCallbackFilterIterator[] = {
- SPL_ME(RecursiveCallbackFilterIterator, __construct, arginfo_class_RecursiveCallbackFilterIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveFilterIterator, hasChildren, arginfo_class_RecursiveCallbackFilterIterator_hasChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveCallbackFilterIterator, getChildren, arginfo_class_RecursiveCallbackFilterIterator_getChildren, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_RecursiveFilterIterator[] = {
- SPL_ME(RecursiveFilterIterator, __construct, arginfo_class_RecursiveFilterIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveFilterIterator, hasChildren, arginfo_class_RecursiveFilterIterator_hasChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveFilterIterator, getChildren, arginfo_class_RecursiveFilterIterator_getChildren, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_ParentIterator[] = {
- SPL_ME(ParentIterator, __construct, arginfo_class_ParentIterator___construct, ZEND_ACC_PUBLIC)
- SPL_MA(ParentIterator, accept, RecursiveFilterIterator, hasChildren, arginfo_class_ParentIterator_accept, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_RegexIterator[] = {
- SPL_ME(RegexIterator, __construct, arginfo_class_RegexIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(RegexIterator, accept, arginfo_class_RegexIterator_accept, ZEND_ACC_PUBLIC)
- SPL_ME(RegexIterator, getMode, arginfo_class_RegexIterator_getMode, ZEND_ACC_PUBLIC)
- SPL_ME(RegexIterator, setMode, arginfo_class_RegexIterator_setMode, ZEND_ACC_PUBLIC)
- SPL_ME(RegexIterator, getFlags, arginfo_class_RegexIterator_getFlags, ZEND_ACC_PUBLIC)
- SPL_ME(RegexIterator, setFlags, arginfo_class_RegexIterator_setFlags, ZEND_ACC_PUBLIC)
- SPL_ME(RegexIterator, getPregFlags, arginfo_class_RegexIterator_getPregFlags, ZEND_ACC_PUBLIC)
- SPL_ME(RegexIterator, setPregFlags, arginfo_class_RegexIterator_setPregFlags, ZEND_ACC_PUBLIC)
- SPL_ME(RegexIterator, getRegex, arginfo_class_RegexIterator_getRegex, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_RecursiveRegexIterator[] = {
- SPL_ME(RecursiveRegexIterator, __construct, arginfo_class_RecursiveRegexIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveRegexIterator, accept, arginfo_class_RecursiveRegexIterator_accept, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveFilterIterator, hasChildren, arginfo_class_RecursiveRegexIterator_hasChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveRegexIterator, getChildren, arginfo_class_RecursiveRegexIterator_getChildren, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
static inline int spl_limit_it_valid(spl_dual_it_object *intern)
{
/* FAILURE / SUCCESS */
/* {{{ proto LimitIterator::__construct(Iterator it [, int offset, int count])
Construct a LimitIterator from an Iterator with a given starting offset and optionally a maximum count */
-SPL_METHOD(LimitIterator, __construct)
+PHP_METHOD(LimitIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_LimitIterator, zend_ce_iterator, DIT_LimitIterator);
} /* }}} */
/* {{{ proto void LimitIterator::rewind()
Rewind the iterator to the specified starting offset */
-SPL_METHOD(LimitIterator, rewind)
+PHP_METHOD(LimitIterator, rewind)
{
spl_dual_it_object *intern;
/* {{{ proto bool LimitIterator::valid()
Check whether the current element is valid */
-SPL_METHOD(LimitIterator, valid)
+PHP_METHOD(LimitIterator, valid)
{
spl_dual_it_object *intern;
/* {{{ proto void LimitIterator::next()
Move the iterator forward */
-SPL_METHOD(LimitIterator, next)
+PHP_METHOD(LimitIterator, next)
{
spl_dual_it_object *intern;
/* {{{ proto void LimitIterator::seek(int position)
Seek to the given position */
-SPL_METHOD(LimitIterator, seek)
+PHP_METHOD(LimitIterator, seek)
{
spl_dual_it_object *intern;
zend_long pos;
/* {{{ proto int LimitIterator::getPosition()
Return the current position */
-SPL_METHOD(LimitIterator, getPosition)
+PHP_METHOD(LimitIterator, getPosition)
{
spl_dual_it_object *intern;
RETURN_LONG(intern->current.pos);
} /* }}} */
-static const zend_function_entry spl_funcs_SeekableIterator[] = {
- SPL_ABSTRACT_ME(SeekableIterator, seek, arginfo_class_SeekableIterator_seek)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_LimitIterator[] = {
- SPL_ME(LimitIterator, __construct, arginfo_class_LimitIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(LimitIterator, rewind, arginfo_class_LimitIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(LimitIterator, valid, arginfo_class_LimitIterator_valid, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, key, arginfo_class_LimitIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, current, arginfo_class_LimitIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(LimitIterator, next, arginfo_class_LimitIterator_next, ZEND_ACC_PUBLIC)
- SPL_ME(LimitIterator, seek, arginfo_class_LimitIterator_seek, ZEND_ACC_PUBLIC)
- SPL_ME(LimitIterator, getPosition, arginfo_class_LimitIterator_getPosition, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, getInnerIterator, arginfo_class_LimitIterator_getInnerIterator, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
static inline int spl_caching_it_valid(spl_dual_it_object *intern)
{
return intern->u.caching.flags & CIT_VALID ? SUCCESS : FAILURE;
/* {{{ proto CachingIterator::__construct(Iterator it [, flags = CIT_CALL_TOSTRING])
Construct a CachingIterator from an Iterator */
-SPL_METHOD(CachingIterator, __construct)
+PHP_METHOD(CachingIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_CachingIterator, zend_ce_iterator, DIT_CachingIterator);
} /* }}} */
/* {{{ proto void CachingIterator::rewind()
Rewind the iterator */
-SPL_METHOD(CachingIterator, rewind)
+PHP_METHOD(CachingIterator, rewind)
{
spl_dual_it_object *intern;
/* {{{ proto bool CachingIterator::valid()
Check whether the current element is valid */
-SPL_METHOD(CachingIterator, valid)
+PHP_METHOD(CachingIterator, valid)
{
spl_dual_it_object *intern;
/* {{{ proto void CachingIterator::next()
Move the iterator forward */
-SPL_METHOD(CachingIterator, next)
+PHP_METHOD(CachingIterator, next)
{
spl_dual_it_object *intern;
/* {{{ proto bool CachingIterator::hasNext()
Check whether the inner iterator has a valid next element */
-SPL_METHOD(CachingIterator, hasNext)
+PHP_METHOD(CachingIterator, hasNext)
{
spl_dual_it_object *intern;
/* {{{ proto string CachingIterator::__toString()
Return the string representation of the current element */
-SPL_METHOD(CachingIterator, __toString)
+PHP_METHOD(CachingIterator, __toString)
{
spl_dual_it_object *intern;
/* {{{ proto void CachingIterator::offsetSet(mixed index, mixed newval)
Set given index in cache */
-SPL_METHOD(CachingIterator, offsetSet)
+PHP_METHOD(CachingIterator, offsetSet)
{
spl_dual_it_object *intern;
zend_string *key;
/* {{{ proto string CachingIterator::offsetGet(mixed index)
Return the internal cache if used */
-SPL_METHOD(CachingIterator, offsetGet)
+PHP_METHOD(CachingIterator, offsetGet)
{
spl_dual_it_object *intern;
zend_string *key;
/* {{{ proto void CachingIterator::offsetUnset(mixed index)
Unset given index in cache */
-SPL_METHOD(CachingIterator, offsetUnset)
+PHP_METHOD(CachingIterator, offsetUnset)
{
spl_dual_it_object *intern;
zend_string *key;
/* {{{ proto bool CachingIterator::offsetExists(mixed index)
Return whether the requested index exists */
-SPL_METHOD(CachingIterator, offsetExists)
+PHP_METHOD(CachingIterator, offsetExists)
{
spl_dual_it_object *intern;
zend_string *key;
/* {{{ proto array CachingIterator::getCache()
Return the cache */
-SPL_METHOD(CachingIterator, getCache)
+PHP_METHOD(CachingIterator, getCache)
{
spl_dual_it_object *intern;
/* {{{ proto int CachingIterator::getFlags()
Return the internal flags */
-SPL_METHOD(CachingIterator, getFlags)
+PHP_METHOD(CachingIterator, getFlags)
{
spl_dual_it_object *intern;
/* {{{ proto void CachingIterator::setFlags(int flags)
Set the internal flags */
-SPL_METHOD(CachingIterator, setFlags)
+PHP_METHOD(CachingIterator, setFlags)
{
spl_dual_it_object *intern;
zend_long flags;
/* {{{ proto void CachingIterator::count()
Number of cached elements */
-SPL_METHOD(CachingIterator, count)
+PHP_METHOD(CachingIterator, count)
{
spl_dual_it_object *intern;
}
/* }}} */
-static const zend_function_entry spl_funcs_CachingIterator[] = {
- SPL_ME(CachingIterator, __construct, arginfo_class_CachingIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, rewind, arginfo_class_CachingIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, valid, arginfo_class_CachingIterator_valid, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, key, arginfo_class_CachingIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, current, arginfo_class_CachingIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, next, arginfo_class_CachingIterator_next, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, hasNext, arginfo_class_CachingIterator_hasNext, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, __toString, arginfo_class_CachingIterator___toString, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, getInnerIterator, arginfo_class_CachingIterator_getInnerIterator, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, getFlags, arginfo_class_CachingIterator_getFlags, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, setFlags, arginfo_class_CachingIterator_setFlags, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, offsetGet, arginfo_class_CachingIterator_offsetGet, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, offsetSet, arginfo_class_CachingIterator_offsetSet, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, offsetUnset, arginfo_class_CachingIterator_offsetUnset, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, offsetExists, arginfo_class_CachingIterator_offsetExists, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, getCache, arginfo_class_CachingIterator_getCache, ZEND_ACC_PUBLIC)
- SPL_ME(CachingIterator, count, arginfo_class_CachingIterator_count, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
/* {{{ proto RecursiveCachingIterator::__construct(RecursiveIterator it [, flags = CIT_CALL_TOSTRING])
Create an iterator from a RecursiveIterator */
-SPL_METHOD(RecursiveCachingIterator, __construct)
+PHP_METHOD(RecursiveCachingIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveCachingIterator, spl_ce_RecursiveIterator, DIT_RecursiveCachingIterator);
} /* }}} */
/* {{{ proto bool RecursiveCachingIterator::hasChildren()
Check whether the current element of the inner iterator has children */
-SPL_METHOD(RecursiveCachingIterator, hasChildren)
+PHP_METHOD(RecursiveCachingIterator, hasChildren)
{
spl_dual_it_object *intern;
/* {{{ proto RecursiveCachingIterator RecursiveCachingIterator::getChildren()
Return the inner iterator's children as a RecursiveCachingIterator */
-SPL_METHOD(RecursiveCachingIterator, getChildren)
+PHP_METHOD(RecursiveCachingIterator, getChildren)
{
spl_dual_it_object *intern;
}
} /* }}} */
-static const zend_function_entry spl_funcs_RecursiveCachingIterator[] = {
- SPL_ME(RecursiveCachingIterator, __construct, arginfo_class_RecursiveCachingIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveCachingIterator, hasChildren, arginfo_class_RecursiveCachingIterator_hasChildren, ZEND_ACC_PUBLIC)
- SPL_ME(RecursiveCachingIterator, getChildren, arginfo_class_RecursiveCachingIterator_getChildren, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
/* {{{ proto IteratorIterator::__construct(Traversable it)
Create an iterator from anything that is traversable */
-SPL_METHOD(IteratorIterator, __construct)
+PHP_METHOD(IteratorIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_IteratorIterator, zend_ce_traversable, DIT_IteratorIterator);
} /* }}} */
-static const zend_function_entry spl_funcs_IteratorIterator[] = {
- SPL_ME(IteratorIterator, __construct, arginfo_class_IteratorIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, rewind, arginfo_class_IteratorIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, valid, arginfo_class_IteratorIterator_valid, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, key, arginfo_class_IteratorIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, current, arginfo_class_IteratorIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, next, arginfo_class_IteratorIterator_next, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, getInnerIterator, arginfo_class_IteratorIterator_getInnerIterator, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
/* {{{ proto NoRewindIterator::__construct(Iterator it)
Create an iterator from another iterator */
-SPL_METHOD(NoRewindIterator, __construct)
+PHP_METHOD(NoRewindIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_NoRewindIterator, zend_ce_iterator, DIT_NoRewindIterator);
} /* }}} */
/* {{{ proto void NoRewindIterator::rewind()
Prevent a call to inner iterators rewind() */
-SPL_METHOD(NoRewindIterator, rewind)
+PHP_METHOD(NoRewindIterator, rewind)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto bool NoRewindIterator::valid()
Return inner iterators valid() */
-SPL_METHOD(NoRewindIterator, valid)
+PHP_METHOD(NoRewindIterator, valid)
{
spl_dual_it_object *intern;
/* {{{ proto mixed NoRewindIterator::key()
Return inner iterators key() */
-SPL_METHOD(NoRewindIterator, key)
+PHP_METHOD(NoRewindIterator, key)
{
spl_dual_it_object *intern;
/* {{{ proto mixed NoRewindIterator::current()
Return inner iterators current() */
-SPL_METHOD(NoRewindIterator, current)
+PHP_METHOD(NoRewindIterator, current)
{
spl_dual_it_object *intern;
zval *data;
/* {{{ proto void NoRewindIterator::next()
Return inner iterators next() */
-SPL_METHOD(NoRewindIterator, next)
+PHP_METHOD(NoRewindIterator, next)
{
spl_dual_it_object *intern;
intern->inner.iterator->funcs->move_forward(intern->inner.iterator);
} /* }}} */
-static const zend_function_entry spl_funcs_NoRewindIterator[] = {
- SPL_ME(NoRewindIterator, __construct, arginfo_class_NoRewindIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(NoRewindIterator, rewind, arginfo_class_NoRewindIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(NoRewindIterator, valid, arginfo_class_NoRewindIterator_valid, ZEND_ACC_PUBLIC)
- SPL_ME(NoRewindIterator, key, arginfo_class_NoRewindIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(NoRewindIterator, current, arginfo_class_NoRewindIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(NoRewindIterator, next, arginfo_class_NoRewindIterator_next, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, getInnerIterator, arginfo_class_NoRewindIterator_getInnerIterator, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
/* {{{ proto InfiniteIterator::__construct(Iterator it)
Create an iterator from another iterator */
-SPL_METHOD(InfiniteIterator, __construct)
+PHP_METHOD(InfiniteIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_InfiniteIterator, zend_ce_iterator, DIT_InfiniteIterator);
} /* }}} */
/* {{{ proto void InfiniteIterator::next()
Prevent a call to inner iterators rewind() (internally the current data will be fetched if valid()) */
-SPL_METHOD(InfiniteIterator, next)
+PHP_METHOD(InfiniteIterator, next)
{
spl_dual_it_object *intern;
}
} /* }}} */
-static const zend_function_entry spl_funcs_InfiniteIterator[] = {
- SPL_ME(InfiniteIterator, __construct, arginfo_class_InfiniteIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(InfiniteIterator, next, arginfo_class_InfiniteIterator_next, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
/* {{{ proto void EmptyIterator::rewind()
Does nothing */
-SPL_METHOD(EmptyIterator, rewind)
+PHP_METHOD(EmptyIterator, rewind)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto false EmptyIterator::valid()
Return false */
-SPL_METHOD(EmptyIterator, valid)
+PHP_METHOD(EmptyIterator, valid)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto void EmptyIterator::key()
Throws exception BadMethodCallException */
-SPL_METHOD(EmptyIterator, key)
+PHP_METHOD(EmptyIterator, key)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto void EmptyIterator::current()
Throws exception BadMethodCallException */
-SPL_METHOD(EmptyIterator, current)
+PHP_METHOD(EmptyIterator, current)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
/* {{{ proto void EmptyIterator::next()
Does nothing */
-SPL_METHOD(EmptyIterator, next)
+PHP_METHOD(EmptyIterator, next)
{
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
}
} /* }}} */
-static const zend_function_entry spl_funcs_EmptyIterator[] = {
- SPL_ME(EmptyIterator, rewind, arginfo_class_EmptyIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(EmptyIterator, valid, arginfo_class_EmptyIterator_valid, ZEND_ACC_PUBLIC)
- SPL_ME(EmptyIterator, key, arginfo_class_EmptyIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(EmptyIterator, current, arginfo_class_EmptyIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(EmptyIterator, next, arginfo_class_EmptyIterator_next, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
int spl_append_it_next_iterator(spl_dual_it_object *intern) /* {{{*/
{
spl_dual_it_free(intern);
/* {{{ proto AppendIterator::__construct()
Create an AppendIterator */
-SPL_METHOD(AppendIterator, __construct)
+PHP_METHOD(AppendIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_AppendIterator, zend_ce_iterator, DIT_AppendIterator);
} /* }}} */
/* {{{ proto void AppendIterator::append(Iterator it)
Append an iterator */
-SPL_METHOD(AppendIterator, append)
+PHP_METHOD(AppendIterator, append)
{
spl_dual_it_object *intern;
zval *it;
/* {{{ proto mixed AppendIterator::current()
Get the current element value */
-SPL_METHOD(AppendIterator, current)
+PHP_METHOD(AppendIterator, current)
{
spl_dual_it_object *intern;
/* {{{ proto void AppendIterator::rewind()
Rewind to the first iterator and rewind the first iterator, too */
-SPL_METHOD(AppendIterator, rewind)
+PHP_METHOD(AppendIterator, rewind)
{
spl_dual_it_object *intern;
/* {{{ proto bool AppendIterator::valid()
Check if the current state is valid */
-SPL_METHOD(AppendIterator, valid)
+PHP_METHOD(AppendIterator, valid)
{
spl_dual_it_object *intern;
/* {{{ proto void AppendIterator::next()
Forward to next element */
-SPL_METHOD(AppendIterator, next)
+PHP_METHOD(AppendIterator, next)
{
spl_dual_it_object *intern;
/* {{{ proto int AppendIterator::getIteratorIndex()
Get index of iterator */
-SPL_METHOD(AppendIterator, getIteratorIndex)
+PHP_METHOD(AppendIterator, getIteratorIndex)
{
spl_dual_it_object *intern;
/* {{{ proto ArrayIterator AppendIterator::getArrayIterator()
Get access to inner ArrayIterator */
-SPL_METHOD(AppendIterator, getArrayIterator)
+PHP_METHOD(AppendIterator, getArrayIterator)
{
spl_dual_it_object *intern;
zval *value;
ZVAL_COPY_DEREF(return_value, value);
} /* }}} */
-static const zend_function_entry spl_funcs_AppendIterator[] = {
- SPL_ME(AppendIterator, __construct, arginfo_class_AppendIterator___construct, ZEND_ACC_PUBLIC)
- SPL_ME(AppendIterator, append, arginfo_class_AppendIterator_append, ZEND_ACC_PUBLIC)
- SPL_ME(AppendIterator, rewind, arginfo_class_AppendIterator_rewind, ZEND_ACC_PUBLIC)
- SPL_ME(AppendIterator, valid, arginfo_class_AppendIterator_valid, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, key, arginfo_class_AppendIterator_key, ZEND_ACC_PUBLIC)
- SPL_ME(AppendIterator, current, arginfo_class_AppendIterator_current, ZEND_ACC_PUBLIC)
- SPL_ME(AppendIterator, next, arginfo_class_AppendIterator_next, ZEND_ACC_PUBLIC)
- SPL_ME(dual_it, getInnerIterator, arginfo_class_AppendIterator_getInnerIterator, ZEND_ACC_PUBLIC)
- SPL_ME(AppendIterator, getIteratorIndex, arginfo_class_AppendIterator_getIteratorIndex, ZEND_ACC_PUBLIC)
- SPL_ME(AppendIterator, getArrayIterator, arginfo_class_AppendIterator_getArrayIterator, ZEND_ACC_PUBLIC)
- PHP_FE_END
-};
-
PHPAPI int spl_iterator_apply(zval *obj, spl_iterator_apply_func_t apply_func, void *puser)
{
zend_object_iterator *iter;
}
/* }}} */
-static const zend_function_entry spl_funcs_OuterIterator[] = {
- SPL_ABSTRACT_ME(OuterIterator, getInnerIterator, arginfo_class_OuterIterator_getInnerIterator)
- PHP_FE_END
-};
-
/* {{{ PHP_MINIT_FUNCTION(spl_iterators)
*/
PHP_MINIT_FUNCTION(spl_iterators)
REGISTER_SPL_INTERFACE(RecursiveIterator);
REGISTER_SPL_ITERATOR(RecursiveIterator);
- REGISTER_SPL_STD_CLASS_EX(RecursiveIteratorIterator, spl_RecursiveIteratorIterator_new, spl_funcs_RecursiveIteratorIterator);
+ REGISTER_SPL_STD_CLASS_EX(RecursiveIteratorIterator, spl_RecursiveIteratorIterator_new, class_RecursiveIteratorIterator_methods);
REGISTER_SPL_ITERATOR(RecursiveIteratorIterator);
memcpy(&spl_handlers_rec_it_it, &std_object_handlers, sizeof(zend_object_handlers));
REGISTER_SPL_INTERFACE(OuterIterator);
REGISTER_SPL_ITERATOR(OuterIterator);
- REGISTER_SPL_STD_CLASS_EX(IteratorIterator, spl_dual_it_new, spl_funcs_IteratorIterator);
+ REGISTER_SPL_STD_CLASS_EX(IteratorIterator, spl_dual_it_new, class_IteratorIterator_methods);
REGISTER_SPL_ITERATOR(IteratorIterator);
REGISTER_SPL_IMPLEMENTS(IteratorIterator, OuterIterator);
- REGISTER_SPL_SUB_CLASS_EX(FilterIterator, IteratorIterator, spl_dual_it_new, spl_funcs_FilterIterator);
+ REGISTER_SPL_SUB_CLASS_EX(FilterIterator, IteratorIterator, spl_dual_it_new, class_FilterIterator_methods);
spl_ce_FilterIterator->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
- REGISTER_SPL_SUB_CLASS_EX(RecursiveFilterIterator, FilterIterator, spl_dual_it_new, spl_funcs_RecursiveFilterIterator);
+ REGISTER_SPL_SUB_CLASS_EX(RecursiveFilterIterator, FilterIterator, spl_dual_it_new, class_RecursiveFilterIterator_methods);
REGISTER_SPL_IMPLEMENTS(RecursiveFilterIterator, RecursiveIterator);
- REGISTER_SPL_SUB_CLASS_EX(CallbackFilterIterator, FilterIterator, spl_dual_it_new, spl_funcs_CallbackFilterIterator);
+ REGISTER_SPL_SUB_CLASS_EX(CallbackFilterIterator, FilterIterator, spl_dual_it_new, class_CallbackFilterIterator_methods);
- REGISTER_SPL_SUB_CLASS_EX(RecursiveCallbackFilterIterator, CallbackFilterIterator, spl_dual_it_new, spl_funcs_RecursiveCallbackFilterIterator);
+ REGISTER_SPL_SUB_CLASS_EX(RecursiveCallbackFilterIterator, CallbackFilterIterator, spl_dual_it_new, class_RecursiveCallbackFilterIterator_methods);
REGISTER_SPL_IMPLEMENTS(RecursiveCallbackFilterIterator, RecursiveIterator);
- REGISTER_SPL_SUB_CLASS_EX(ParentIterator, RecursiveFilterIterator, spl_dual_it_new, spl_funcs_ParentIterator);
+ REGISTER_SPL_SUB_CLASS_EX(ParentIterator, RecursiveFilterIterator, spl_dual_it_new, class_ParentIterator_methods);
REGISTER_SPL_INTERFACE(SeekableIterator);
REGISTER_SPL_ITERATOR(SeekableIterator);
- REGISTER_SPL_SUB_CLASS_EX(LimitIterator, IteratorIterator, spl_dual_it_new, spl_funcs_LimitIterator);
+ REGISTER_SPL_SUB_CLASS_EX(LimitIterator, IteratorIterator, spl_dual_it_new, class_LimitIterator_methods);
- REGISTER_SPL_SUB_CLASS_EX(CachingIterator, IteratorIterator, spl_dual_it_new, spl_funcs_CachingIterator);
+ REGISTER_SPL_SUB_CLASS_EX(CachingIterator, IteratorIterator, spl_dual_it_new, class_CachingIterator_methods);
REGISTER_SPL_IMPLEMENTS(CachingIterator, ArrayAccess);
REGISTER_SPL_IMPLEMENTS(CachingIterator, Countable);
REGISTER_SPL_IMPLEMENTS(CachingIterator, Stringable);
REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_INNER", CIT_TOSTRING_USE_INNER);
REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "FULL_CACHE", CIT_FULL_CACHE);
- REGISTER_SPL_SUB_CLASS_EX(RecursiveCachingIterator, CachingIterator, spl_dual_it_new, spl_funcs_RecursiveCachingIterator);
+ REGISTER_SPL_SUB_CLASS_EX(RecursiveCachingIterator, CachingIterator, spl_dual_it_new, class_RecursiveCachingIterator_methods);
REGISTER_SPL_IMPLEMENTS(RecursiveCachingIterator, RecursiveIterator);
- REGISTER_SPL_SUB_CLASS_EX(NoRewindIterator, IteratorIterator, spl_dual_it_new, spl_funcs_NoRewindIterator);
+ REGISTER_SPL_SUB_CLASS_EX(NoRewindIterator, IteratorIterator, spl_dual_it_new, class_NoRewindIterator_methods);
- REGISTER_SPL_SUB_CLASS_EX(AppendIterator, IteratorIterator, spl_dual_it_new, spl_funcs_AppendIterator);
+ REGISTER_SPL_SUB_CLASS_EX(AppendIterator, IteratorIterator, spl_dual_it_new, class_AppendIterator_methods);
REGISTER_SPL_IMPLEMENTS(RecursiveIteratorIterator, OuterIterator);
- REGISTER_SPL_SUB_CLASS_EX(InfiniteIterator, IteratorIterator, spl_dual_it_new, spl_funcs_InfiniteIterator);
- REGISTER_SPL_SUB_CLASS_EX(RegexIterator, FilterIterator, spl_dual_it_new, spl_funcs_RegexIterator);
+ REGISTER_SPL_SUB_CLASS_EX(InfiniteIterator, IteratorIterator, spl_dual_it_new, class_InfiniteIterator_methods);
+ REGISTER_SPL_SUB_CLASS_EX(RegexIterator, FilterIterator, spl_dual_it_new, class_RegexIterator_methods);
REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "USE_KEY", REGIT_USE_KEY);
REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "INVERT_MATCH",REGIT_INVERTED);
REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "MATCH", REGIT_MODE_MATCH);
REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "SPLIT", REGIT_MODE_SPLIT);
REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "REPLACE", REGIT_MODE_REPLACE);
REGISTER_SPL_PROPERTY(RegexIterator, "replacement", 0);
- REGISTER_SPL_SUB_CLASS_EX(RecursiveRegexIterator, RegexIterator, spl_dual_it_new, spl_funcs_RecursiveRegexIterator);
+ REGISTER_SPL_SUB_CLASS_EX(RecursiveRegexIterator, RegexIterator, spl_dual_it_new, class_RecursiveRegexIterator_methods);
REGISTER_SPL_IMPLEMENTS(RecursiveRegexIterator, RecursiveIterator);
- REGISTER_SPL_STD_CLASS_EX(EmptyIterator, NULL, spl_funcs_EmptyIterator);
+ REGISTER_SPL_STD_CLASS_EX(EmptyIterator, NULL, class_EmptyIterator_methods);
REGISTER_SPL_ITERATOR(EmptyIterator);
- REGISTER_SPL_SUB_CLASS_EX(RecursiveTreeIterator, RecursiveIteratorIterator, spl_RecursiveTreeIterator_new, spl_funcs_RecursiveTreeIterator);
+ REGISTER_SPL_SUB_CLASS_EX(RecursiveTreeIterator, RecursiveIteratorIterator, spl_RecursiveTreeIterator_new, class_RecursiveTreeIterator_methods);
REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "BYPASS_CURRENT", RTIT_BYPASS_CURRENT);
REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "BYPASS_KEY", RTIT_BYPASS_KEY);
REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_LEFT", 0);
<?php
+/** @generate-function-entries */
+
class EmptyIterator implements Iterator
{
/** @return void */
{
public function __construct(RecursiveIterator $iterator, callable $callback) {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias RecursiveFilterIterator::hasChildren
+ */
public function hasChildren() {}
/** @return RecursiveCallbackFilterIterator */
/** @return void */
public function endIteration() {}
- /** @return bool */
+ /** @return bool|null */
public function callHasChildren() {}
/** @return RecursiveIterator|null */
/** @return void */
public function rewind() {}
- /** @return bool */
- public function valid() {}
-
- /** @return mixed */
- public function key() {}
-
- /** @return mixed */
- public function current() {}
-
/** @return void */
public function next() {}
-
- /** @return Iterator|null */
- public function getInnerIterator() {}
}
abstract class RecursiveFilterIterator extends FilterIterator implements RecursiveIterator
{
public function __construct(RecursiveIterator $iterator) {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias RecursiveFilterIterator::hasChildren
+ */
public function accept() {}
}
/** @return bool */
public function valid() {}
- /** @return mixed */
- public function key() {}
-
- /** @return mixed */
- public function current() {}
-
/** @return void */
public function next() {}
/** @return int */
public function getPosition() {}
-
- /** @return Iterator|null */
- public function getInnerIterator() {}
}
class CachingIterator extends IteratorIterator implements ArrayAccess, Countable
/** @return bool */
public function valid() {}
- /** @return mixed */
- public function key() {}
-
- /** @return mixed */
- public function current() {}
-
/** @return void */
public function next() {}
public function __toString(): string {}
- /** @return Iterator|null */
- public function getInnerIterator() {}
-
/** @return int */
public function getFlags() {}
/** @return void */
public function next() {}
-
- /** @return Iterator|null */
- public function getInnerIterator() {}
}
class AppendIterator extends IteratorIterator
/** @return bool */
public function valid() {}
- /** @return mixed */
- public function key() {}
-
/** @return mixed */
public function current() {}
/** @return void */
public function next() {}
- /** @return Iterator|null */
- public function getInnerIterator() {}
-
/** @return int */
public function getIteratorIndex() {}
/** @return bool */
public function accept() {}
- /** @return bool */
+ /**
+ * @return bool
+ * @alias RecursiveFilterIterator::hasChildren
+ */
public function hasChildren() {}
/** @return RecursiveRegexIterator */
int $mode = self::SELF_FIRST
) {}
- /** @return void */
- public function rewind() {}
-
- /** @return bool */
- public function valid() {}
-
/** @return mixed */
public function key() {}
/** @return mixed */
public function current() {}
- /** @return void */
- public function next() {}
-
- /** @return void */
- public function beginIteration() {}
-
- /** @return void */
- public function endIteration() {}
-
- /** @return bool|null */
- public function callHasChildren() {}
-
- /** @return RecursiveIterator|null */
- public function callGetChildren() {}
-
- /** @return void */
- public function beginChildren() {}
-
- /** @return void */
- public function endChildren() {}
-
- /** @return void */
- public function nextElement() {}
-
/** @return string */
public function getPrefix() {}
#define arginfo_class_FilterIterator_rewind arginfo_class_EmptyIterator_current
-#define arginfo_class_FilterIterator_valid arginfo_class_EmptyIterator_current
-
-#define arginfo_class_FilterIterator_key arginfo_class_EmptyIterator_current
-
-#define arginfo_class_FilterIterator_current arginfo_class_EmptyIterator_current
-
#define arginfo_class_FilterIterator_next arginfo_class_EmptyIterator_current
-#define arginfo_class_FilterIterator_getInnerIterator arginfo_class_EmptyIterator_current
-
ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RecursiveFilterIterator___construct, 0, 0, 1)
ZEND_ARG_OBJ_INFO(0, iterator, RecursiveIterator, 0)
ZEND_END_ARG_INFO()
#define arginfo_class_LimitIterator_valid arginfo_class_EmptyIterator_current
-#define arginfo_class_LimitIterator_key arginfo_class_EmptyIterator_current
-
-#define arginfo_class_LimitIterator_current arginfo_class_EmptyIterator_current
-
#define arginfo_class_LimitIterator_next arginfo_class_EmptyIterator_current
#define arginfo_class_LimitIterator_seek arginfo_class_SeekableIterator_seek
#define arginfo_class_LimitIterator_getPosition arginfo_class_EmptyIterator_current
-#define arginfo_class_LimitIterator_getInnerIterator arginfo_class_EmptyIterator_current
-
ZEND_BEGIN_ARG_INFO_EX(arginfo_class_CachingIterator___construct, 0, 0, 1)
ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "self::CALL_TOSTRING")
#define arginfo_class_CachingIterator_valid arginfo_class_EmptyIterator_current
-#define arginfo_class_CachingIterator_key arginfo_class_EmptyIterator_current
-
-#define arginfo_class_CachingIterator_current arginfo_class_EmptyIterator_current
-
#define arginfo_class_CachingIterator_next arginfo_class_EmptyIterator_current
#define arginfo_class_CachingIterator_hasNext arginfo_class_EmptyIterator_current
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_CachingIterator___toString, 0, 0, IS_STRING, 0)
ZEND_END_ARG_INFO()
-#define arginfo_class_CachingIterator_getInnerIterator arginfo_class_EmptyIterator_current
-
#define arginfo_class_CachingIterator_getFlags arginfo_class_EmptyIterator_current
ZEND_BEGIN_ARG_INFO_EX(arginfo_class_CachingIterator_setFlags, 0, 0, 1)
#define arginfo_class_NoRewindIterator_next arginfo_class_EmptyIterator_current
-#define arginfo_class_NoRewindIterator_getInnerIterator arginfo_class_EmptyIterator_current
-
#define arginfo_class_AppendIterator___construct arginfo_class_EmptyIterator_current
#define arginfo_class_AppendIterator_append arginfo_class_FilterIterator___construct
#define arginfo_class_AppendIterator_valid arginfo_class_EmptyIterator_current
-#define arginfo_class_AppendIterator_key arginfo_class_EmptyIterator_current
-
#define arginfo_class_AppendIterator_current arginfo_class_EmptyIterator_current
#define arginfo_class_AppendIterator_next arginfo_class_EmptyIterator_current
-#define arginfo_class_AppendIterator_getInnerIterator arginfo_class_EmptyIterator_current
-
#define arginfo_class_AppendIterator_getIteratorIndex arginfo_class_EmptyIterator_current
#define arginfo_class_AppendIterator_getArrayIterator arginfo_class_EmptyIterator_current
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, mode, IS_LONG, 0, "self::SELF_FIRST")
ZEND_END_ARG_INFO()
-#define arginfo_class_RecursiveTreeIterator_rewind arginfo_class_EmptyIterator_current
-
-#define arginfo_class_RecursiveTreeIterator_valid arginfo_class_EmptyIterator_current
-
#define arginfo_class_RecursiveTreeIterator_key arginfo_class_EmptyIterator_current
#define arginfo_class_RecursiveTreeIterator_current arginfo_class_EmptyIterator_current
-#define arginfo_class_RecursiveTreeIterator_next arginfo_class_EmptyIterator_current
-
-#define arginfo_class_RecursiveTreeIterator_beginIteration arginfo_class_EmptyIterator_current
-
-#define arginfo_class_RecursiveTreeIterator_endIteration arginfo_class_EmptyIterator_current
-
-#define arginfo_class_RecursiveTreeIterator_callHasChildren arginfo_class_EmptyIterator_current
-
-#define arginfo_class_RecursiveTreeIterator_callGetChildren arginfo_class_EmptyIterator_current
-
-#define arginfo_class_RecursiveTreeIterator_beginChildren arginfo_class_EmptyIterator_current
-
-#define arginfo_class_RecursiveTreeIterator_endChildren arginfo_class_EmptyIterator_current
-
-#define arginfo_class_RecursiveTreeIterator_nextElement arginfo_class_EmptyIterator_current
-
#define arginfo_class_RecursiveTreeIterator_getPrefix arginfo_class_EmptyIterator_current
ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RecursiveTreeIterator_setPostfix, 0, 0, 1)
#define arginfo_class_RecursiveTreeIterator_getEntry arginfo_class_EmptyIterator_current
#define arginfo_class_RecursiveTreeIterator_getPostfix arginfo_class_EmptyIterator_current
+
+
+ZEND_METHOD(EmptyIterator, current);
+ZEND_METHOD(EmptyIterator, next);
+ZEND_METHOD(EmptyIterator, key);
+ZEND_METHOD(EmptyIterator, valid);
+ZEND_METHOD(EmptyIterator, rewind);
+ZEND_METHOD(CallbackFilterIterator, __construct);
+ZEND_METHOD(CallbackFilterIterator, accept);
+ZEND_METHOD(RecursiveCallbackFilterIterator, __construct);
+ZEND_METHOD(RecursiveFilterIterator, hasChildren);
+ZEND_METHOD(RecursiveCallbackFilterIterator, getChildren);
+ZEND_METHOD(RecursiveIteratorIterator, __construct);
+ZEND_METHOD(RecursiveIteratorIterator, rewind);
+ZEND_METHOD(RecursiveIteratorIterator, valid);
+ZEND_METHOD(RecursiveIteratorIterator, key);
+ZEND_METHOD(RecursiveIteratorIterator, current);
+ZEND_METHOD(RecursiveIteratorIterator, next);
+ZEND_METHOD(RecursiveIteratorIterator, getDepth);
+ZEND_METHOD(RecursiveIteratorIterator, getSubIterator);
+ZEND_METHOD(RecursiveIteratorIterator, getInnerIterator);
+ZEND_METHOD(RecursiveIteratorIterator, beginIteration);
+ZEND_METHOD(RecursiveIteratorIterator, endIteration);
+ZEND_METHOD(RecursiveIteratorIterator, callHasChildren);
+ZEND_METHOD(RecursiveIteratorIterator, callGetChildren);
+ZEND_METHOD(RecursiveIteratorIterator, beginChildren);
+ZEND_METHOD(RecursiveIteratorIterator, endChildren);
+ZEND_METHOD(RecursiveIteratorIterator, nextElement);
+ZEND_METHOD(RecursiveIteratorIterator, setMaxDepth);
+ZEND_METHOD(RecursiveIteratorIterator, getMaxDepth);
+ZEND_METHOD(IteratorIterator, __construct);
+ZEND_METHOD(IteratorIterator, getInnerIterator);
+ZEND_METHOD(IteratorIterator, rewind);
+ZEND_METHOD(IteratorIterator, valid);
+ZEND_METHOD(IteratorIterator, key);
+ZEND_METHOD(IteratorIterator, current);
+ZEND_METHOD(IteratorIterator, next);
+ZEND_METHOD(FilterIterator, __construct);
+ZEND_METHOD(FilterIterator, rewind);
+ZEND_METHOD(FilterIterator, next);
+ZEND_METHOD(RecursiveFilterIterator, __construct);
+ZEND_METHOD(RecursiveFilterIterator, getChildren);
+ZEND_METHOD(ParentIterator, __construct);
+ZEND_METHOD(LimitIterator, __construct);
+ZEND_METHOD(LimitIterator, rewind);
+ZEND_METHOD(LimitIterator, valid);
+ZEND_METHOD(LimitIterator, next);
+ZEND_METHOD(LimitIterator, seek);
+ZEND_METHOD(LimitIterator, getPosition);
+ZEND_METHOD(CachingIterator, __construct);
+ZEND_METHOD(CachingIterator, rewind);
+ZEND_METHOD(CachingIterator, valid);
+ZEND_METHOD(CachingIterator, next);
+ZEND_METHOD(CachingIterator, hasNext);
+ZEND_METHOD(CachingIterator, __toString);
+ZEND_METHOD(CachingIterator, getFlags);
+ZEND_METHOD(CachingIterator, setFlags);
+ZEND_METHOD(CachingIterator, offsetGet);
+ZEND_METHOD(CachingIterator, offsetSet);
+ZEND_METHOD(CachingIterator, offsetUnset);
+ZEND_METHOD(CachingIterator, offsetExists);
+ZEND_METHOD(CachingIterator, getCache);
+ZEND_METHOD(CachingIterator, count);
+ZEND_METHOD(RecursiveCachingIterator, __construct);
+ZEND_METHOD(RecursiveCachingIterator, hasChildren);
+ZEND_METHOD(RecursiveCachingIterator, getChildren);
+ZEND_METHOD(NoRewindIterator, __construct);
+ZEND_METHOD(NoRewindIterator, rewind);
+ZEND_METHOD(NoRewindIterator, valid);
+ZEND_METHOD(NoRewindIterator, key);
+ZEND_METHOD(NoRewindIterator, current);
+ZEND_METHOD(NoRewindIterator, next);
+ZEND_METHOD(AppendIterator, __construct);
+ZEND_METHOD(AppendIterator, append);
+ZEND_METHOD(AppendIterator, rewind);
+ZEND_METHOD(AppendIterator, valid);
+ZEND_METHOD(AppendIterator, current);
+ZEND_METHOD(AppendIterator, next);
+ZEND_METHOD(AppendIterator, getIteratorIndex);
+ZEND_METHOD(AppendIterator, getArrayIterator);
+ZEND_METHOD(InfiniteIterator, __construct);
+ZEND_METHOD(InfiniteIterator, next);
+ZEND_METHOD(RegexIterator, __construct);
+ZEND_METHOD(RegexIterator, accept);
+ZEND_METHOD(RegexIterator, getMode);
+ZEND_METHOD(RegexIterator, setMode);
+ZEND_METHOD(RegexIterator, getFlags);
+ZEND_METHOD(RegexIterator, setFlags);
+ZEND_METHOD(RegexIterator, getRegex);
+ZEND_METHOD(RegexIterator, getPregFlags);
+ZEND_METHOD(RegexIterator, setPregFlags);
+ZEND_METHOD(RecursiveRegexIterator, __construct);
+ZEND_METHOD(RecursiveRegexIterator, accept);
+ZEND_METHOD(RecursiveRegexIterator, getChildren);
+ZEND_METHOD(RecursiveTreeIterator, __construct);
+ZEND_METHOD(RecursiveTreeIterator, key);
+ZEND_METHOD(RecursiveTreeIterator, current);
+ZEND_METHOD(RecursiveTreeIterator, getPrefix);
+ZEND_METHOD(RecursiveTreeIterator, setPostfix);
+ZEND_METHOD(RecursiveTreeIterator, setPrefixPart);
+ZEND_METHOD(RecursiveTreeIterator, getEntry);
+ZEND_METHOD(RecursiveTreeIterator, getPostfix);
+
+
+static const zend_function_entry class_EmptyIterator_methods[] = {
+ ZEND_ME(EmptyIterator, current, arginfo_class_EmptyIterator_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(EmptyIterator, next, arginfo_class_EmptyIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(EmptyIterator, key, arginfo_class_EmptyIterator_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(EmptyIterator, valid, arginfo_class_EmptyIterator_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(EmptyIterator, rewind, arginfo_class_EmptyIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_CallbackFilterIterator_methods[] = {
+ ZEND_ME(CallbackFilterIterator, __construct, arginfo_class_CallbackFilterIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(CallbackFilterIterator, accept, arginfo_class_CallbackFilterIterator_accept, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RecursiveCallbackFilterIterator_methods[] = {
+ ZEND_ME(RecursiveCallbackFilterIterator, __construct, arginfo_class_RecursiveCallbackFilterIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(RecursiveFilterIterator, hasChildren, hasChildren, arginfo_class_RecursiveCallbackFilterIterator_hasChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveCallbackFilterIterator, getChildren, arginfo_class_RecursiveCallbackFilterIterator_getChildren, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RecursiveIterator_methods[] = {
+ ZEND_ABSTRACT_ME_WITH_FLAGS(RecursiveIterator, hasChildren, arginfo_class_RecursiveIterator_hasChildren, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+ ZEND_ABSTRACT_ME_WITH_FLAGS(RecursiveIterator, getChildren, arginfo_class_RecursiveIterator_getChildren, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RecursiveIteratorIterator_methods[] = {
+ ZEND_ME(RecursiveIteratorIterator, __construct, arginfo_class_RecursiveIteratorIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, rewind, arginfo_class_RecursiveIteratorIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, valid, arginfo_class_RecursiveIteratorIterator_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, key, arginfo_class_RecursiveIteratorIterator_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, current, arginfo_class_RecursiveIteratorIterator_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, next, arginfo_class_RecursiveIteratorIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, getDepth, arginfo_class_RecursiveIteratorIterator_getDepth, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, getSubIterator, arginfo_class_RecursiveIteratorIterator_getSubIterator, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, getInnerIterator, arginfo_class_RecursiveIteratorIterator_getInnerIterator, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, beginIteration, arginfo_class_RecursiveIteratorIterator_beginIteration, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, endIteration, arginfo_class_RecursiveIteratorIterator_endIteration, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, callHasChildren, arginfo_class_RecursiveIteratorIterator_callHasChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, callGetChildren, arginfo_class_RecursiveIteratorIterator_callGetChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, beginChildren, arginfo_class_RecursiveIteratorIterator_beginChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, endChildren, arginfo_class_RecursiveIteratorIterator_endChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, nextElement, arginfo_class_RecursiveIteratorIterator_nextElement, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, setMaxDepth, arginfo_class_RecursiveIteratorIterator_setMaxDepth, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveIteratorIterator, getMaxDepth, arginfo_class_RecursiveIteratorIterator_getMaxDepth, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_OuterIterator_methods[] = {
+ ZEND_ABSTRACT_ME_WITH_FLAGS(OuterIterator, getInnerIterator, arginfo_class_OuterIterator_getInnerIterator, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_IteratorIterator_methods[] = {
+ ZEND_ME(IteratorIterator, __construct, arginfo_class_IteratorIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(IteratorIterator, getInnerIterator, arginfo_class_IteratorIterator_getInnerIterator, ZEND_ACC_PUBLIC)
+ ZEND_ME(IteratorIterator, rewind, arginfo_class_IteratorIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(IteratorIterator, valid, arginfo_class_IteratorIterator_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(IteratorIterator, key, arginfo_class_IteratorIterator_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(IteratorIterator, current, arginfo_class_IteratorIterator_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(IteratorIterator, next, arginfo_class_IteratorIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_FilterIterator_methods[] = {
+ ZEND_ABSTRACT_ME_WITH_FLAGS(FilterIterator, accept, arginfo_class_FilterIterator_accept, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+ ZEND_ME(FilterIterator, __construct, arginfo_class_FilterIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(FilterIterator, rewind, arginfo_class_FilterIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(FilterIterator, next, arginfo_class_FilterIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RecursiveFilterIterator_methods[] = {
+ ZEND_ME(RecursiveFilterIterator, __construct, arginfo_class_RecursiveFilterIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveFilterIterator, hasChildren, arginfo_class_RecursiveFilterIterator_hasChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveFilterIterator, getChildren, arginfo_class_RecursiveFilterIterator_getChildren, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_ParentIterator_methods[] = {
+ ZEND_ME(ParentIterator, __construct, arginfo_class_ParentIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(RecursiveFilterIterator, accept, hasChildren, arginfo_class_ParentIterator_accept, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SeekableIterator_methods[] = {
+ ZEND_ABSTRACT_ME_WITH_FLAGS(SeekableIterator, seek, arginfo_class_SeekableIterator_seek, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_LimitIterator_methods[] = {
+ ZEND_ME(LimitIterator, __construct, arginfo_class_LimitIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(LimitIterator, rewind, arginfo_class_LimitIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(LimitIterator, valid, arginfo_class_LimitIterator_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(LimitIterator, next, arginfo_class_LimitIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(LimitIterator, seek, arginfo_class_LimitIterator_seek, ZEND_ACC_PUBLIC)
+ ZEND_ME(LimitIterator, getPosition, arginfo_class_LimitIterator_getPosition, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_CachingIterator_methods[] = {
+ ZEND_ME(CachingIterator, __construct, arginfo_class_CachingIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, rewind, arginfo_class_CachingIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, valid, arginfo_class_CachingIterator_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, next, arginfo_class_CachingIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, hasNext, arginfo_class_CachingIterator_hasNext, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, __toString, arginfo_class_CachingIterator___toString, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, getFlags, arginfo_class_CachingIterator_getFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, setFlags, arginfo_class_CachingIterator_setFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, offsetGet, arginfo_class_CachingIterator_offsetGet, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, offsetSet, arginfo_class_CachingIterator_offsetSet, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, offsetUnset, arginfo_class_CachingIterator_offsetUnset, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, offsetExists, arginfo_class_CachingIterator_offsetExists, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, getCache, arginfo_class_CachingIterator_getCache, ZEND_ACC_PUBLIC)
+ ZEND_ME(CachingIterator, count, arginfo_class_CachingIterator_count, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RecursiveCachingIterator_methods[] = {
+ ZEND_ME(RecursiveCachingIterator, __construct, arginfo_class_RecursiveCachingIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveCachingIterator, hasChildren, arginfo_class_RecursiveCachingIterator_hasChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveCachingIterator, getChildren, arginfo_class_RecursiveCachingIterator_getChildren, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_NoRewindIterator_methods[] = {
+ ZEND_ME(NoRewindIterator, __construct, arginfo_class_NoRewindIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(NoRewindIterator, rewind, arginfo_class_NoRewindIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(NoRewindIterator, valid, arginfo_class_NoRewindIterator_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(NoRewindIterator, key, arginfo_class_NoRewindIterator_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(NoRewindIterator, current, arginfo_class_NoRewindIterator_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(NoRewindIterator, next, arginfo_class_NoRewindIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_AppendIterator_methods[] = {
+ ZEND_ME(AppendIterator, __construct, arginfo_class_AppendIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(AppendIterator, append, arginfo_class_AppendIterator_append, ZEND_ACC_PUBLIC)
+ ZEND_ME(AppendIterator, rewind, arginfo_class_AppendIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(AppendIterator, valid, arginfo_class_AppendIterator_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(AppendIterator, current, arginfo_class_AppendIterator_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(AppendIterator, next, arginfo_class_AppendIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(AppendIterator, getIteratorIndex, arginfo_class_AppendIterator_getIteratorIndex, ZEND_ACC_PUBLIC)
+ ZEND_ME(AppendIterator, getArrayIterator, arginfo_class_AppendIterator_getArrayIterator, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_InfiniteIterator_methods[] = {
+ ZEND_ME(InfiniteIterator, __construct, arginfo_class_InfiniteIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(InfiniteIterator, next, arginfo_class_InfiniteIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RegexIterator_methods[] = {
+ ZEND_ME(RegexIterator, __construct, arginfo_class_RegexIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(RegexIterator, accept, arginfo_class_RegexIterator_accept, ZEND_ACC_PUBLIC)
+ ZEND_ME(RegexIterator, getMode, arginfo_class_RegexIterator_getMode, ZEND_ACC_PUBLIC)
+ ZEND_ME(RegexIterator, setMode, arginfo_class_RegexIterator_setMode, ZEND_ACC_PUBLIC)
+ ZEND_ME(RegexIterator, getFlags, arginfo_class_RegexIterator_getFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(RegexIterator, setFlags, arginfo_class_RegexIterator_setFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(RegexIterator, getRegex, arginfo_class_RegexIterator_getRegex, ZEND_ACC_PUBLIC)
+ ZEND_ME(RegexIterator, getPregFlags, arginfo_class_RegexIterator_getPregFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(RegexIterator, setPregFlags, arginfo_class_RegexIterator_setPregFlags, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RecursiveRegexIterator_methods[] = {
+ ZEND_ME(RecursiveRegexIterator, __construct, arginfo_class_RecursiveRegexIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveRegexIterator, accept, arginfo_class_RecursiveRegexIterator_accept, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(RecursiveFilterIterator, hasChildren, hasChildren, arginfo_class_RecursiveRegexIterator_hasChildren, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveRegexIterator, getChildren, arginfo_class_RecursiveRegexIterator_getChildren, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RecursiveTreeIterator_methods[] = {
+ ZEND_ME(RecursiveTreeIterator, __construct, arginfo_class_RecursiveTreeIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveTreeIterator, key, arginfo_class_RecursiveTreeIterator_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveTreeIterator, current, arginfo_class_RecursiveTreeIterator_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveTreeIterator, getPrefix, arginfo_class_RecursiveTreeIterator_getPrefix, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveTreeIterator, setPostfix, arginfo_class_RecursiveTreeIterator_setPostfix, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveTreeIterator, setPrefixPart, arginfo_class_RecursiveTreeIterator_setPrefixPart, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveTreeIterator, getEntry, arginfo_class_RecursiveTreeIterator_getEntry, ZEND_ACC_PUBLIC)
+ ZEND_ME(RecursiveTreeIterator, getPostfix, arginfo_class_RecursiveTreeIterator_getPostfix, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
#include "spl_array.h"
#include "spl_exceptions.h"
-SPL_METHOD(SplObserver, update);
-SPL_METHOD(SplSubject, attach);
-SPL_METHOD(SplSubject, detach);
-SPL_METHOD(SplSubject, notify);
-
-static const zend_function_entry spl_funcs_SplObserver[] = {
- SPL_ABSTRACT_ME(SplObserver, update, arginfo_class_SplObserver_update)
- PHP_FE_END
-};
-
-static const zend_function_entry spl_funcs_SplSubject[] = {
- SPL_ABSTRACT_ME(SplSubject, attach, arginfo_class_SplSubject_attach)
- SPL_ABSTRACT_ME(SplSubject, detach, arginfo_class_SplSubject_detach)
- SPL_ABSTRACT_ME(SplSubject, notify, arginfo_class_SplSubject_notify)
- PHP_FE_END
-};
-
PHPAPI zend_class_entry *spl_ce_SplObserver;
PHPAPI zend_class_entry *spl_ce_SplSubject;
PHPAPI zend_class_entry *spl_ce_SplObjectStorage;
/* {{{ proto void SplObjectStorage::attach(object obj, mixed data = NULL)
Attaches an object to the storage if not yet contained */
-SPL_METHOD(SplObjectStorage, attach)
+PHP_METHOD(SplObjectStorage, attach)
{
zval *obj, *inf = NULL;
/* {{{ proto void SplObjectStorage::detach(object obj)
Detaches an object from the storage */
-SPL_METHOD(SplObjectStorage, detach)
+PHP_METHOD(SplObjectStorage, detach)
{
zval *obj;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto string SplObjectStorage::getHash(object obj)
Returns the hash of an object */
-SPL_METHOD(SplObjectStorage, getHash)
+PHP_METHOD(SplObjectStorage, getHash)
{
zval *obj;
/* {{{ proto mixed SplObjectStorage::offsetGet(object obj)
Returns associated information for a stored object */
-SPL_METHOD(SplObjectStorage, offsetGet)
+PHP_METHOD(SplObjectStorage, offsetGet)
{
zval *obj;
spl_SplObjectStorageElement *element;
/* {{{ proto bool SplObjectStorage::addAll(SplObjectStorage $os)
Add all elements contained in $os */
-SPL_METHOD(SplObjectStorage, addAll)
+PHP_METHOD(SplObjectStorage, addAll)
{
zval *obj;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto bool SplObjectStorage::removeAll(SplObjectStorage $os)
Remove all elements contained in $os */
-SPL_METHOD(SplObjectStorage, removeAll)
+PHP_METHOD(SplObjectStorage, removeAll)
{
zval *obj;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto bool SplObjectStorage::removeAllExcept(SplObjectStorage $os)
Remove elements not common to both this SplObjectStorage instance and $os */
-SPL_METHOD(SplObjectStorage, removeAllExcept)
+PHP_METHOD(SplObjectStorage, removeAllExcept)
{
zval *obj;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto bool SplObjectStorage::contains(object obj)
Determine whether an object is contained in the storage */
-SPL_METHOD(SplObjectStorage, contains)
+PHP_METHOD(SplObjectStorage, contains)
{
zval *obj;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto int SplObjectStorage::count()
Determine number of objects in storage */
-SPL_METHOD(SplObjectStorage, count)
+PHP_METHOD(SplObjectStorage, count)
{
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
zend_long mode = COUNT_NORMAL;
/* {{{ proto void SplObjectStorage::rewind()
Rewind to first position */
-SPL_METHOD(SplObjectStorage, rewind)
+PHP_METHOD(SplObjectStorage, rewind)
{
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto bool SplObjectStorage::valid()
Returns whether current position is valid */
-SPL_METHOD(SplObjectStorage, valid)
+PHP_METHOD(SplObjectStorage, valid)
{
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto mixed SplObjectStorage::key()
Returns current key */
-SPL_METHOD(SplObjectStorage, key)
+PHP_METHOD(SplObjectStorage, key)
{
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto mixed SplObjectStorage::current()
Returns current element */
-SPL_METHOD(SplObjectStorage, current)
+PHP_METHOD(SplObjectStorage, current)
{
spl_SplObjectStorageElement *element;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto mixed SplObjectStorage::getInfo()
Returns associated information to current element */
-SPL_METHOD(SplObjectStorage, getInfo)
+PHP_METHOD(SplObjectStorage, getInfo)
{
spl_SplObjectStorageElement *element;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto mixed SplObjectStorage::setInfo(mixed $inf)
Sets associated information of current element to $inf */
-SPL_METHOD(SplObjectStorage, setInfo)
+PHP_METHOD(SplObjectStorage, setInfo)
{
spl_SplObjectStorageElement *element;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto void SplObjectStorage::next()
Moves position forward */
-SPL_METHOD(SplObjectStorage, next)
+PHP_METHOD(SplObjectStorage, next)
{
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto string SplObjectStorage::serialize()
Serializes storage */
-SPL_METHOD(SplObjectStorage, serialize)
+PHP_METHOD(SplObjectStorage, serialize)
{
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto void SplObjectStorage::unserialize(string serialized)
Unserializes storage */
-SPL_METHOD(SplObjectStorage, unserialize)
+PHP_METHOD(SplObjectStorage, unserialize)
{
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
} /* }}} */
/* {{{ proto auto SplObjectStorage::__serialize() */
-SPL_METHOD(SplObjectStorage, __serialize)
+PHP_METHOD(SplObjectStorage, __serialize)
{
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
spl_SplObjectStorageElement *elem;
} /* }}} */
/* {{{ proto void SplObjectStorage::__unserialize(array serialized) */
-SPL_METHOD(SplObjectStorage, __unserialize)
+PHP_METHOD(SplObjectStorage, __unserialize)
{
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
HashTable *data;
}
/* {{{ proto array SplObjectStorage::__debugInfo() */
-SPL_METHOD(SplObjectStorage, __debugInfo)
+PHP_METHOD(SplObjectStorage, __debugInfo)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
}
/* }}} */
-static const zend_function_entry spl_funcs_SplObjectStorage[] = {
- SPL_ME(SplObjectStorage, attach, arginfo_class_SplObjectStorage_attach, 0)
- SPL_ME(SplObjectStorage, detach, arginfo_class_SplObjectStorage_detach, 0)
- SPL_ME(SplObjectStorage, contains, arginfo_class_SplObjectStorage_contains, 0)
- SPL_ME(SplObjectStorage, addAll, arginfo_class_SplObjectStorage_addAll, 0)
- SPL_ME(SplObjectStorage, removeAll, arginfo_class_SplObjectStorage_removeAll, 0)
- SPL_ME(SplObjectStorage, removeAllExcept, arginfo_class_SplObjectStorage_removeAllExcept, 0)
- SPL_ME(SplObjectStorage, getInfo, arginfo_class_SplObjectStorage_getInfo,0)
- SPL_ME(SplObjectStorage, setInfo, arginfo_class_SplObjectStorage_setInfo, 0)
- SPL_ME(SplObjectStorage, getHash, arginfo_class_SplObjectStorage_getHash, 0)
- SPL_ME(SplObjectStorage, __debugInfo, arginfo_class_SplObjectStorage___debugInfo, 0)
- /* Countable */
- SPL_ME(SplObjectStorage, count, arginfo_class_SplObjectStorage_count,0)
- /* Iterator */
- SPL_ME(SplObjectStorage, rewind, arginfo_class_SplObjectStorage_rewind,0)
- SPL_ME(SplObjectStorage, valid, arginfo_class_SplObjectStorage_valid,0)
- SPL_ME(SplObjectStorage, key, arginfo_class_SplObjectStorage_key,0)
- SPL_ME(SplObjectStorage, current, arginfo_class_SplObjectStorage_current,0)
- SPL_ME(SplObjectStorage, next, arginfo_class_SplObjectStorage_next,0)
- /* Serializable */
- SPL_ME(SplObjectStorage, unserialize, arginfo_class_SplObjectStorage_unserialize, 0)
- SPL_ME(SplObjectStorage, serialize, arginfo_class_SplObjectStorage_serialize,0)
- SPL_ME(SplObjectStorage, __unserialize, arginfo_class_SplObjectStorage___unserialize, 0)
- SPL_ME(SplObjectStorage, __serialize, arginfo_class_SplObjectStorage___serialize,0)
- /* ArrayAccess */
- SPL_MA(SplObjectStorage, offsetExists, SplObjectStorage, contains, arginfo_class_SplObjectStorage_offsetExists, 0)
- SPL_MA(SplObjectStorage, offsetSet, SplObjectStorage, attach, arginfo_class_SplObjectStorage_offsetSet, 0)
- SPL_MA(SplObjectStorage, offsetUnset, SplObjectStorage, detach, arginfo_class_SplObjectStorage_offsetUnset, 0)
- SPL_ME(SplObjectStorage, offsetGet, arginfo_class_SplObjectStorage_offsetGet, 0)
- PHP_FE_END
-};
-
typedef enum {
MIT_NEED_ANY = 0,
MIT_NEED_ALL = 1,
/* {{{ proto MultipleIterator::__construct([int flags = MIT_NEED_ALL|MIT_KEYS_NUMERIC])
Iterator that iterates over several iterators one after the other */
-SPL_METHOD(MultipleIterator, __construct)
+PHP_METHOD(MultipleIterator, __construct)
{
spl_SplObjectStorage *intern;
zend_long flags = MIT_NEED_ALL|MIT_KEYS_NUMERIC;
/* {{{ proto int MultipleIterator::getFlags()
Return current flags */
-SPL_METHOD(MultipleIterator, getFlags)
+PHP_METHOD(MultipleIterator, getFlags)
{
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto int MultipleIterator::setFlags(int flags)
Set flags */
-SPL_METHOD(MultipleIterator, setFlags)
+PHP_METHOD(MultipleIterator, setFlags)
{
spl_SplObjectStorage *intern;
intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto void attachIterator(Iterator iterator[, mixed info]) throws InvalidArgumentException
Attach a new iterator */
-SPL_METHOD(MultipleIterator, attachIterator)
+PHP_METHOD(MultipleIterator, attachIterator)
{
spl_SplObjectStorage *intern;
zval *iterator = NULL, *info = NULL;
/* {{{ proto void MultipleIterator::detachIterator(Iterator iterator)
Detaches an iterator */
-SPL_METHOD(MultipleIterator, detachIterator)
+PHP_METHOD(MultipleIterator, detachIterator)
{
zval *iterator;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto bool MultipleIterator::containsIterator(Iterator iterator)
Determine whether the iterator exists */
-SPL_METHOD(MultipleIterator, containsIterator)
+PHP_METHOD(MultipleIterator, containsIterator)
{
zval *iterator;
spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto void MultipleIterator::rewind()
Rewind all attached iterator instances */
-SPL_METHOD(MultipleIterator, rewind)
+PHP_METHOD(MultipleIterator, rewind)
{
spl_SplObjectStorage *intern;
spl_SplObjectStorageElement *element;
/* {{{ proto void MultipleIterator::next()
Move all attached iterator instances forward */
-SPL_METHOD(MultipleIterator, next)
+PHP_METHOD(MultipleIterator, next)
{
spl_SplObjectStorage *intern;
spl_SplObjectStorageElement *element;
/* {{{ proto bool MultipleIterator::valid()
Return whether all or one sub iterator is valid depending on flags */
-SPL_METHOD(MultipleIterator, valid)
+PHP_METHOD(MultipleIterator, valid)
{
spl_SplObjectStorage *intern;
spl_SplObjectStorageElement *element;
/* {{{ proto array current() throws RuntimeException throws InvalidArgumentException
Return an array of all registered Iterator instances current() result */
-SPL_METHOD(MultipleIterator, current)
+PHP_METHOD(MultipleIterator, current)
{
spl_SplObjectStorage *intern;
intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
/* {{{ proto array MultipleIterator::key()
Return an array of all registered Iterator instances key() result */
-SPL_METHOD(MultipleIterator, key)
+PHP_METHOD(MultipleIterator, key)
{
spl_SplObjectStorage *intern;
intern = Z_SPLOBJSTORAGE_P(ZEND_THIS);
}
/* }}} */
-static const zend_function_entry spl_funcs_MultipleIterator[] = {
- SPL_ME(MultipleIterator, __construct, arginfo_class_MultipleIterator___construct, 0)
- SPL_ME(MultipleIterator, getFlags, arginfo_class_MultipleIterator_getFlags, 0)
- SPL_ME(MultipleIterator, setFlags, arginfo_class_MultipleIterator_setFlags, 0)
- SPL_ME(MultipleIterator, attachIterator, arginfo_class_MultipleIterator_attachIterator, 0)
- SPL_ME(MultipleIterator, detachIterator, arginfo_class_MultipleIterator_detachIterator, 0)
- SPL_ME(MultipleIterator, containsIterator, arginfo_class_MultipleIterator_containsIterator, 0)
- SPL_MA(MultipleIterator, countIterators, SplObjectStorage, count, arginfo_class_MultipleIterator_countIterators, 0)
- SPL_MA(MultipleIterator, __debugInfo, SplObjectStorage, __debugInfo, arginfo_class_MultipleIterator___debugInfo, 0)
- /* Iterator */
- SPL_ME(MultipleIterator, rewind, arginfo_class_MultipleIterator_rewind, 0)
- SPL_ME(MultipleIterator, valid, arginfo_class_MultipleIterator_valid, 0)
- SPL_ME(MultipleIterator, key, arginfo_class_MultipleIterator_key, 0)
- SPL_ME(MultipleIterator, current, arginfo_class_MultipleIterator_current, 0)
- SPL_ME(MultipleIterator, next, arginfo_class_MultipleIterator_next, 0)
- PHP_FE_END
-};
-
/* {{{ PHP_MINIT_FUNCTION(spl_observer) */
PHP_MINIT_FUNCTION(spl_observer)
{
REGISTER_SPL_INTERFACE(SplObserver);
REGISTER_SPL_INTERFACE(SplSubject);
- REGISTER_SPL_STD_CLASS_EX(SplObjectStorage, spl_SplObjectStorage_new, spl_funcs_SplObjectStorage);
+ REGISTER_SPL_STD_CLASS_EX(SplObjectStorage, spl_SplObjectStorage_new, class_SplObjectStorage_methods);
memcpy(&spl_handler_SplObjectStorage, &std_object_handlers, sizeof(zend_object_handlers));
spl_handler_SplObjectStorage.offset = XtOffsetOf(spl_SplObjectStorage, std);
REGISTER_SPL_IMPLEMENTS(SplObjectStorage, Serializable);
REGISTER_SPL_IMPLEMENTS(SplObjectStorage, ArrayAccess);
- REGISTER_SPL_STD_CLASS_EX(MultipleIterator, spl_SplObjectStorage_new, spl_funcs_MultipleIterator);
+ REGISTER_SPL_STD_CLASS_EX(MultipleIterator, spl_SplObjectStorage_new, class_MultipleIterator_methods);
REGISTER_SPL_ITERATOR(MultipleIterator);
REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_NEED_ANY", MIT_NEED_ANY);
<?php
+/** @generate-function-entries */
+
interface SplObserver
{
/** @return void */
/**
* @param object $object
* @return bool
+ * @alias SplObjectStorage::contains
*/
public function offsetExists($object) {}
* @param object $object
* @param mixed $info
* @return void
+ * @alias SplObjectStorage::attach
*/
public function offsetSet($object, $info = null) {}
/**
* @param object $object
* @return void
+ * @alias SplObjectStorage::detach
*/
public function offsetUnset($object) {}
/** @return bool */
public function containsIterator(Iterator $iterator) {}
- /** @return int */
+ /**
+ * @return int
+ * @alias SplObjectStorage::count
+ */
public function countIterators() {}
/** @return void */
/** @return void */
public function next() {}
- /** @return array */
+ /**
+ * @return array
+ * @alias SplObjectStorage::__debugInfo
+ */
public function __debugInfo() {}
}
#define arginfo_class_MultipleIterator_next arginfo_class_SplSubject_notify
#define arginfo_class_MultipleIterator___debugInfo arginfo_class_SplSubject_notify
+
+
+ZEND_METHOD(SplObjectStorage, attach);
+ZEND_METHOD(SplObjectStorage, detach);
+ZEND_METHOD(SplObjectStorage, contains);
+ZEND_METHOD(SplObjectStorage, addAll);
+ZEND_METHOD(SplObjectStorage, removeAll);
+ZEND_METHOD(SplObjectStorage, removeAllExcept);
+ZEND_METHOD(SplObjectStorage, getInfo);
+ZEND_METHOD(SplObjectStorage, setInfo);
+ZEND_METHOD(SplObjectStorage, count);
+ZEND_METHOD(SplObjectStorage, rewind);
+ZEND_METHOD(SplObjectStorage, valid);
+ZEND_METHOD(SplObjectStorage, key);
+ZEND_METHOD(SplObjectStorage, current);
+ZEND_METHOD(SplObjectStorage, next);
+ZEND_METHOD(SplObjectStorage, unserialize);
+ZEND_METHOD(SplObjectStorage, serialize);
+ZEND_METHOD(SplObjectStorage, offsetGet);
+ZEND_METHOD(SplObjectStorage, getHash);
+ZEND_METHOD(SplObjectStorage, __serialize);
+ZEND_METHOD(SplObjectStorage, __unserialize);
+ZEND_METHOD(SplObjectStorage, __debugInfo);
+ZEND_METHOD(MultipleIterator, __construct);
+ZEND_METHOD(MultipleIterator, getFlags);
+ZEND_METHOD(MultipleIterator, setFlags);
+ZEND_METHOD(MultipleIterator, attachIterator);
+ZEND_METHOD(MultipleIterator, detachIterator);
+ZEND_METHOD(MultipleIterator, containsIterator);
+ZEND_METHOD(MultipleIterator, rewind);
+ZEND_METHOD(MultipleIterator, valid);
+ZEND_METHOD(MultipleIterator, key);
+ZEND_METHOD(MultipleIterator, current);
+ZEND_METHOD(MultipleIterator, next);
+
+
+static const zend_function_entry class_SplObserver_methods[] = {
+ ZEND_ABSTRACT_ME_WITH_FLAGS(SplObserver, update, arginfo_class_SplObserver_update, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SplSubject_methods[] = {
+ ZEND_ABSTRACT_ME_WITH_FLAGS(SplSubject, attach, arginfo_class_SplSubject_attach, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+ ZEND_ABSTRACT_ME_WITH_FLAGS(SplSubject, detach, arginfo_class_SplSubject_detach, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+ ZEND_ABSTRACT_ME_WITH_FLAGS(SplSubject, notify, arginfo_class_SplSubject_notify, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_SplObjectStorage_methods[] = {
+ ZEND_ME(SplObjectStorage, attach, arginfo_class_SplObjectStorage_attach, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, detach, arginfo_class_SplObjectStorage_detach, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, contains, arginfo_class_SplObjectStorage_contains, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, addAll, arginfo_class_SplObjectStorage_addAll, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, removeAll, arginfo_class_SplObjectStorage_removeAll, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, removeAllExcept, arginfo_class_SplObjectStorage_removeAllExcept, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, getInfo, arginfo_class_SplObjectStorage_getInfo, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, setInfo, arginfo_class_SplObjectStorage_setInfo, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, count, arginfo_class_SplObjectStorage_count, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, rewind, arginfo_class_SplObjectStorage_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, valid, arginfo_class_SplObjectStorage_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, key, arginfo_class_SplObjectStorage_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, current, arginfo_class_SplObjectStorage_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, next, arginfo_class_SplObjectStorage_next, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, unserialize, arginfo_class_SplObjectStorage_unserialize, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, serialize, arginfo_class_SplObjectStorage_serialize, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplObjectStorage, offsetExists, contains, arginfo_class_SplObjectStorage_offsetExists, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, offsetGet, arginfo_class_SplObjectStorage_offsetGet, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplObjectStorage, offsetSet, attach, arginfo_class_SplObjectStorage_offsetSet, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplObjectStorage, offsetUnset, detach, arginfo_class_SplObjectStorage_offsetUnset, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, getHash, arginfo_class_SplObjectStorage_getHash, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, __serialize, arginfo_class_SplObjectStorage___serialize, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, __unserialize, arginfo_class_SplObjectStorage___unserialize, ZEND_ACC_PUBLIC)
+ ZEND_ME(SplObjectStorage, __debugInfo, arginfo_class_SplObjectStorage___debugInfo, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_MultipleIterator_methods[] = {
+ ZEND_ME(MultipleIterator, __construct, arginfo_class_MultipleIterator___construct, ZEND_ACC_PUBLIC)
+ ZEND_ME(MultipleIterator, getFlags, arginfo_class_MultipleIterator_getFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(MultipleIterator, setFlags, arginfo_class_MultipleIterator_setFlags, ZEND_ACC_PUBLIC)
+ ZEND_ME(MultipleIterator, attachIterator, arginfo_class_MultipleIterator_attachIterator, ZEND_ACC_PUBLIC)
+ ZEND_ME(MultipleIterator, detachIterator, arginfo_class_MultipleIterator_detachIterator, ZEND_ACC_PUBLIC)
+ ZEND_ME(MultipleIterator, containsIterator, arginfo_class_MultipleIterator_containsIterator, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplObjectStorage, countIterators, count, arginfo_class_MultipleIterator_countIterators, ZEND_ACC_PUBLIC)
+ ZEND_ME(MultipleIterator, rewind, arginfo_class_MultipleIterator_rewind, ZEND_ACC_PUBLIC)
+ ZEND_ME(MultipleIterator, valid, arginfo_class_MultipleIterator_valid, ZEND_ACC_PUBLIC)
+ ZEND_ME(MultipleIterator, key, arginfo_class_MultipleIterator_key, ZEND_ACC_PUBLIC)
+ ZEND_ME(MultipleIterator, current, arginfo_class_MultipleIterator_current, ZEND_ACC_PUBLIC)
+ ZEND_ME(MultipleIterator, next, arginfo_class_MultipleIterator_next, ZEND_ACC_PUBLIC)
+ ZEND_MALIAS(SplObjectStorage, __debugInfo, __debugInfo, arginfo_class_MultipleIterator___debugInfo, ZEND_ACC_PUBLIC)
+ ZEND_FE_END
+};
projects / php / commitdiff