diff --git a/ext/config.m4 b/ext/config.m4 index dda7050b10..7f8438210c 100644 --- a/ext/config.m4 +++ b/ext/config.m4 @@ -9,12 +9,17 @@ if test "$PHP_STUB" = "yes"; then fi AC_DEFINE(HAVE_STUB, 1, [Whether you have Stub]) - stub_sources="stub.c kernel/main.c kernel/memory.c kernel/exception.c kernel/debug.c kernel/backtrace.c kernel/object.c kernel/array.c kernel/string.c kernel/fcall.c kernel/require.c kernel/file.c kernel/operators.c kernel/math.c kernel/concat.c kernel/variables.c kernel/filter.c kernel/iterator.c kernel/time.c kernel/exit.c stub/testinterface.zep.c + stub_sources="stub.c kernel/main.c kernel/memory.c kernel/exception.c kernel/debug.c kernel/backtrace.c kernel/object.c kernel/array.c kernel/string.c kernel/fcall.c kernel/require.c kernel/file.c kernel/operators.c kernel/math.c kernel/concat.c kernel/variables.c kernel/filter.c kernel/iterator.c kernel/time.c kernel/exit.c stub/invokes/abstractprotected.zep.c + stub/testinterface.zep.c stub/oo/extend/exception.zep.c stub/oo/extend/db/exception.zep.c stub/scallparent.zep.c stub/constantsparent.zep.c stub/globals/session/base.zep.c + stub/interfaces/interfaceint.zep.c + stub/interfaces/interfaceintsignature.zep.c + stub/invokes/abstractinvoker.zep.c + stub/invokes/abstractinvokercomplex.zep.c stub/methodinterface.zep.c stub/oo/abstractstatic.zep.c stub/oo/extend/db/query/exception.zep.c @@ -69,6 +74,7 @@ if test "$PHP_STUB" = "yes"; then stub/fortytwo.zep.c stub/functional.zep.c stub/functionexists.zep.c + stub/functions.zep.c stub/geometry.zep.c stub/globals.zep.c stub/globals/env.zep.c @@ -79,9 +85,13 @@ if test "$PHP_STUB" = "yes"; then stub/instance.zep.c stub/instanceoff.zep.c stub/integration/psr/http/message/messageinterfaceex.zep.c + stub/interfaces/implementint.zep.c + stub/interfaces/implementinterface.zep.c stub/internalclasses.zep.c stub/internalinterfaces.zep.c stub/invoke.zep.c + stub/invokes/invokeprotected.zep.c + stub/invokes/invokeprotectedcomplex.zep.c stub/issettest.zep.c stub/issue1404.zep.c stub/issue1521.zep.c @@ -172,6 +182,7 @@ if test "$PHP_STUB" = "yes"; then stub/scall.zep.c stub/scalldynamic.zep.c stub/scallexternal.zep.c + stub/scalllateconstruct.zep.c stub/scope.zep.c stub/sort.zep.c stub/spectralnorm.zep.c @@ -203,7 +214,9 @@ if test "$PHP_STUB" = "yes"; then stub/12__closure.zep.c " PHP_NEW_EXTENSION(stub, $stub_sources, $ext_shared,, ) PHP_ADD_BUILD_DIR([$ext_builddir/kernel/]) - PHP_ADD_BUILD_DIR([$ext_builddir/stub/]) + for dir in "stub stub/bench stub/builtin stub/flow stub/globals stub/globals/session stub/integration/psr/http/message stub/interfaces stub/invokes stub/mcall stub/oo stub/oo/extend stub/oo/extend/db stub/oo/extend/db/query stub/oo/extend/db/query/placeholder stub/oo/extend/spl stub/oo/scopes stub/ooimpl stub/optimizers stub/properties stub/requires stub/router stub/typehinting"; do + PHP_ADD_BUILD_DIR([$ext_builddir/$dir]) + done PHP_SUBST(STUB_SHARED_LIBADD) old_CPPFLAGS=$CPPFLAGS diff --git a/ext/config.w32 b/ext/config.w32 index 93692ad805..f2b20df504 100644 --- a/ext/config.w32 +++ b/ext/config.w32 @@ -10,10 +10,12 @@ if (PHP_STUB != "no") { AC_DEFINE("ZEPHIR_USE_PHP_JSON", 1, "Whether PHP json extension is present at compile time"); } - ADD_SOURCES(configure_module_dirname + "/stub", "testinterface.zep.c scallparent.zep.c constantsparent.zep.c methodinterface.zep.c arithmetic.zep.c arrayaccessobj.zep.c arrayaccesstest.zep.c arrayiterator.zep.c arrayiteratortest.zep.c arrayobject.zep.c arraysearch.zep.c assign.zep.c bitwise.zep.c branchprediction.zep.c cast.zep.c cblock.zep.c chars.zep.c closures.zep.c compare.zep.c concat.zep.c constants.zep.c constantsinterface.zep.c constantsinterfacea.zep.c constantsinterfaceb.zep.c declaretest.zep.c diinterface.zep.c echoes.zep.c emptytest.zep.c evaltest.zep.c exception.zep.c exceptions.zep.c exists.zep.c exitdie.zep.c extendedinterface.zep.c factorial.zep.c fannkuch.zep.c fasta.zep.c fcall.zep.c fetchtest.zep.c fibonnaci.zep.c flow.zep.c fortytwo.zep.c functional.zep.c functionexists.zep.c geometry.zep.c globals.zep.c instance.zep.c instanceoff.zep.c internalclasses.zep.c internalinterfaces.zep.c invoke.zep.c issettest.zep.c issue1404.zep.c issue1521.zep.c issues.zep.c json.zep.c logical.zep.c mcall.zep.c mcallchained.zep.c mcalldynamic.zep.c mcallinternal.zep.c methodabstract.zep.c methodargs.zep.c nativearray.zep.c oo.zep.c operator.zep.c pdostatement.zep.c pregmatch.zep.c quantum.zep.c range.zep.c references.zep.c regexdna.zep.c requires.zep.c resourcetest.zep.c returns.zep.c router.zep.c scall.zep.c scalldynamic.zep.c scallexternal.zep.c scope.zep.c sort.zep.c spectralnorm.zep.c spropertyaccess.zep.c statements.zep.c strings.zep.c stubs.zep.c ternary.zep.c trytest.zep.c typeinstances.zep.c typeoff.zep.c unknownclass.zep.c unsettest.zep.c usetest.zep.c vars.zep.c 0__closure.zep.c 1__closure.zep.c 2__closure.zep.c 3__closure.zep.c 4__closure.zep.c 5__closure.zep.c 6__closure.zep.c 7__closure.zep.c 8__closure.zep.c 9__closure.zep.c 10__closure.zep.c 11__closure.zep.c 12__closure.zep.c", "stub"); + ADD_SOURCES(configure_module_dirname + "/stub/invokes", "abstractprotected.zep.c abstractinvoker.zep.c abstractinvokercomplex.zep.c invokeprotected.zep.c invokeprotectedcomplex.zep.c", "stub"); + ADD_SOURCES(configure_module_dirname + "/stub", "testinterface.zep.c scallparent.zep.c constantsparent.zep.c methodinterface.zep.c arithmetic.zep.c arrayaccessobj.zep.c arrayaccesstest.zep.c arrayiterator.zep.c arrayiteratortest.zep.c arrayobject.zep.c arraysearch.zep.c assign.zep.c bitwise.zep.c branchprediction.zep.c cast.zep.c cblock.zep.c chars.zep.c closures.zep.c compare.zep.c concat.zep.c constants.zep.c constantsinterface.zep.c constantsinterfacea.zep.c constantsinterfaceb.zep.c declaretest.zep.c diinterface.zep.c echoes.zep.c emptytest.zep.c evaltest.zep.c exception.zep.c exceptions.zep.c exists.zep.c exitdie.zep.c extendedinterface.zep.c factorial.zep.c fannkuch.zep.c fasta.zep.c fcall.zep.c fetchtest.zep.c fibonnaci.zep.c flow.zep.c fortytwo.zep.c functional.zep.c functionexists.zep.c functions.zep.c geometry.zep.c globals.zep.c instance.zep.c instanceoff.zep.c internalclasses.zep.c internalinterfaces.zep.c invoke.zep.c issettest.zep.c issue1404.zep.c issue1521.zep.c issues.zep.c json.zep.c logical.zep.c mcall.zep.c mcallchained.zep.c mcalldynamic.zep.c mcallinternal.zep.c methodabstract.zep.c methodargs.zep.c nativearray.zep.c oo.zep.c operator.zep.c pdostatement.zep.c pregmatch.zep.c quantum.zep.c range.zep.c references.zep.c regexdna.zep.c requires.zep.c resourcetest.zep.c returns.zep.c router.zep.c scall.zep.c scalldynamic.zep.c scallexternal.zep.c scalllateconstruct.zep.c scope.zep.c sort.zep.c spectralnorm.zep.c spropertyaccess.zep.c statements.zep.c strings.zep.c stubs.zep.c ternary.zep.c trytest.zep.c typeinstances.zep.c typeoff.zep.c unknownclass.zep.c unsettest.zep.c usetest.zep.c vars.zep.c 0__closure.zep.c 1__closure.zep.c 2__closure.zep.c 3__closure.zep.c 4__closure.zep.c 5__closure.zep.c 6__closure.zep.c 7__closure.zep.c 8__closure.zep.c 9__closure.zep.c 10__closure.zep.c 11__closure.zep.c 12__closure.zep.c", "stub"); ADD_SOURCES(configure_module_dirname + "/stub/oo/extend", "exception.zep.c", "stub"); ADD_SOURCES(configure_module_dirname + "/stub/oo/extend/db", "exception.zep.c", "stub"); ADD_SOURCES(configure_module_dirname + "/stub/globals/session", "base.zep.c child.zep.c", "stub"); + ADD_SOURCES(configure_module_dirname + "/stub/interfaces", "interfaceint.zep.c interfaceintsignature.zep.c implementint.zep.c implementinterface.zep.c", "stub"); ADD_SOURCES(configure_module_dirname + "/stub/oo", "abstractstatic.zep.c oodynamica.zep.c abstractclass.zep.c concretestatic.zep.c constantsinterface.zep.c deprecatedmethods.zep.c dynamicprop.zep.c extendpdoclass.zep.c ooconstruct.zep.c ooconstructparams.zep.c oodestruct.zep.c oodynamicb.zep.c oonativeimplements.zep.c oonoconstruct.zep.c ooparams.zep.c param.zep.c propertyaccess.zep.c", "stub"); ADD_SOURCES(configure_module_dirname + "/stub/oo/extend/db/query", "exception.zep.c", "stub"); ADD_SOURCES(configure_module_dirname + "/stub/oo/scopes", "hasprivatemethod.zep.c scopetesterinterface.zep.c abstractclass.zep.c abstractclassmagic.zep.c privatescopetester.zep.c", "stub"); diff --git a/ext/kernel/array.c b/ext/kernel/array.c index 49267eb4df..0f64755a20 100644 --- a/ext/kernel/array.c +++ b/ext/kernel/array.c @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team @@ -1052,8 +1052,6 @@ void zephir_fast_array_merge(zval *return_value, zval *array1, zval *array2) } array_init_size(return_value, init_size); - php_array_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_P(array1)); - php_array_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_P(array2)); } diff --git a/ext/kernel/array.h b/ext/kernel/array.h index 643ba791f8..11d19b6f77 100644 --- a/ext/kernel/array.h +++ b/ext/kernel/array.h @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team diff --git a/ext/kernel/backtrace.c b/ext/kernel/backtrace.c index df59d00654..994d9fcee9 100644 --- a/ext/kernel/backtrace.c +++ b/ext/kernel/backtrace.c @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Vladimir Kolesnikov | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_RELEASE #if defined(linux) || defined(DARWIN) || defined(__APPLE__) diff --git a/ext/kernel/backtrace.h b/ext/kernel/backtrace.h index 3131224790..75444784ff 100644 --- a/ext/kernel/backtrace.h +++ b/ext/kernel/backtrace.h @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Vladimir Kolesnikov | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_BACKTRACE_H #define ZEPHIR_KERNEL_BACKTRACE_H diff --git a/ext/kernel/debug.c b/ext/kernel/debug.c index 8a68da4d11..6623a9793b 100644 --- a/ext/kernel/debug.c +++ b/ext/kernel/debug.c @@ -1,21 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifdef HAVE_CONFIG_H #include "config.h" diff --git a/ext/kernel/debug.h b/ext/kernel/debug.h index 9519fb65c9..d27e1facc6 100644 --- a/ext/kernel/debug.h +++ b/ext/kernel/debug.h @@ -1,21 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_DEBUG_H #define ZEPHIR_KERNEL_DEBUG_H diff --git a/ext/kernel/exception.c b/ext/kernel/exception.c index 42d58f5497..6d0a50ba3c 100644 --- a/ext/kernel/exception.c +++ b/ext/kernel/exception.c @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Vladimir Kolesnikov | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifdef HAVE_CONFIG_H #include "config.h" diff --git a/ext/kernel/exception.h b/ext/kernel/exception.h index f570a456da..5ae19973ad 100644 --- a/ext/kernel/exception.h +++ b/ext/kernel/exception.h @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Vladimir Kolesnikov | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_EXCEPTIONS_H #define ZEPHIR_KERNEL_EXCEPTIONS_H diff --git a/ext/kernel/exit.c b/ext/kernel/exit.c index e7996af094..a4ba9edc68 100644 --- a/ext/kernel/exit.c +++ b/ext/kernel/exit.c @@ -1,19 +1,13 @@ -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Song Yeung | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifdef HAVE_CONFIG_H #include "config.h" diff --git a/ext/kernel/exit.h b/ext/kernel/exit.h index 6a5effe6c2..1c457ef7fb 100644 --- a/ext/kernel/exit.h +++ b/ext/kernel/exit.h @@ -1,20 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Song Yeung | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_EXIT_H #define ZEPHIR_KERNEL_EXIT_H diff --git a/ext/kernel/fcall.c b/ext/kernel/fcall.c index 9a173a650d..3c6e8c52ab 100644 --- a/ext/kernel/fcall.c +++ b/ext/kernel/fcall.c @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team @@ -45,11 +45,7 @@ static int zephir_make_fcall_key(zend_string* s, zephir_call_type type, zend_cla const zend_class_entry *calling_scope; unsigned char t; -#if PHP_VERSION_ID >= 70100 calling_scope = zend_get_executed_scope(); -#else - calling_scope = EG(scope); -#endif switch (type) { case zephir_fcall_parent: @@ -205,15 +201,9 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze { zend_class_entry* calling_scope; -#if PHP_VERSION_ID < 70300 - fcic->initialized = 0; -#endif fcic->function_handler = NULL; if (type == zephir_fcall_function && Z_TYPE_P(func) == IS_STRING) { -#if PHP_VERSION_ID < 70300 - fcic->initialized = 1; -#endif fcic->called_scope = NULL; fcic->calling_scope = NULL; fcic->object = NULL; @@ -222,15 +212,30 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze fcic->called_scope = called_scope; -#if PHP_VERSION_ID >= 70100 - calling_scope = zend_get_executed_scope(); +#if PHP_VERSION_ID >= 80000 + calling_scope = zend_get_called_scope(EG(current_execute_data)); #else - calling_scope = EG(scope); + calling_scope = zend_get_executed_scope(); #endif fcic->object = this_ptr ? Z_OBJ_P(this_ptr) : NULL; switch (type) { case zephir_fcall_parent: + +#if PHP_VERSION_ID >= 80000 + if (ce && Z_TYPE_P(func) == IS_STRING) { + fcic->function_handler = zend_hash_find_ptr(&ce->parent->function_table, Z_STR_P(func)); + + fcic->calling_scope = ce->parent; + } else if (EXPECTED(calling_scope && calling_scope->parent)) { + if (Z_TYPE_P(func) == IS_STRING) { + fcic->function_handler = zend_hash_find_ptr(&calling_scope->parent->function_table, Z_STR_P(func)); + } + fcic->calling_scope = calling_scope->parent; + } else { + return; + } +#endif if (UNEXPECTED(!calling_scope || !calling_scope->parent)) { return; } @@ -239,18 +244,50 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze break; case zephir_fcall_static: - fcic->calling_scope = fcic->called_scope; +#if PHP_VERSION_ID >= 80000 + if (ce && Z_TYPE_P(func) == IS_STRING) { + fcic->function_handler = zend_hash_find_ptr(&ce->function_table, Z_STR_P(func)); + fcic->calling_scope = ce; + } else if (calling_scope && Z_TYPE_P(func) == IS_STRING) { + fcic->function_handler = zend_hash_find_ptr(&calling_scope->function_table, Z_STR_P(func)); + fcic->calling_scope = called_scope; + } +#else + fcic->calling_scope = called_scope; if (UNEXPECTED(!calling_scope)) { return; } +#endif break; case zephir_fcall_self: +#if PHP_VERSION_ID >= 80000 + if (ce && Z_TYPE_P(func) == IS_STRING) { + fcic->function_handler = zend_hash_find_ptr(&ce->function_table, Z_STR_P(func)); + + fcic->calling_scope = ce; + } else if (calling_scope && Z_TYPE_P(func) == IS_STRING) { + fcic->function_handler = zend_hash_find_ptr(&calling_scope->function_table, Z_STR_P(func)); + fcic->calling_scope = calling_scope; + } +#else fcic->calling_scope = calling_scope; +#endif break; case zephir_fcall_ce: +#if PHP_VERSION_ID >= 80000 + if (ce && Z_TYPE_P(func) == IS_STRING) { + fcic->function_handler = zend_hash_find_ptr(&ce->function_table, Z_STR_P(func)); + + fcic->calling_scope = ce; + } else if (calling_scope && Z_TYPE_P(func) == IS_STRING) { + fcic->function_handler = zend_hash_find_ptr(&calling_scope->function_table, Z_STR_P(func)); + fcic->calling_scope = calling_scope; + } +#endif + // TODO: Check for PHP 7.4 and PHP 8.0, as it rewrite from above fcic->calling_scope = ce; fcic->called_scope = ce; break; @@ -270,6 +307,11 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze return; } +#if PHP_VERSION_ID >= 80000 + if (ce && Z_TYPE_P(func) == IS_STRING) { + fcic->function_handler = zend_hash_find_ptr(&ce->function_table, Z_STR_P(func)); + } +#endif fcic->calling_scope = this_ptr ? Z_OBJCE_P(this_ptr) : NULL; fcic->called_scope = fcic->calling_scope; break; @@ -277,10 +319,6 @@ static void populate_fcic(zend_fcall_info_cache* fcic, zephir_call_type type, ze default: return; } - -#if PHP_VERSION_ID < 70300 - fcic->initialized = 1; -#endif } /** @@ -354,7 +392,14 @@ int zephir_call_user_function(zval *object_pp, zend_class_entry *obj_ce, zephir_ } else if ((cache_entry && !*cache_entry) || zephir_globals_ptr->cache_enabled) { /* The caller is interested in caching OR we have the call cache enabled */ resolve_callable(&callable, type, (object_pp && type != zephir_fcall_ce ? Z_OBJCE_P(object_pp) : obj_ce), object_pp, function_name); + +#if PHP_VERSION_ID >= 80000 + if (obj_ce || !zend_is_callable_ex(&callable, fci.object, IS_CALLABLE_CHECK_SILENT, NULL, &fcic, NULL)) { + populate_fcic(&fcic, type, obj_ce, object_pp, function_name, called_scope); + } +#else zend_is_callable_ex(&callable, fci.object, IS_CALLABLE_CHECK_SILENT, NULL, &fcic, NULL); +#endif } #ifdef _MSC_VER @@ -368,9 +413,13 @@ int zephir_call_user_function(zval *object_pp, zend_class_entry *obj_ce, zephir_ } fci.params = p; + +#if PHP_VERSION_ID >= 80000 if (!fcic.function_handler) { ZVAL_COPY_VALUE(&fci.function_name, &callable); } +#endif + status = zend_call_function(&fci, &fcic); #ifdef _MSC_VER efree(p); @@ -554,6 +603,7 @@ int zephir_call_user_func_array_noex(zval *return_value, zval *handler, zval *pa return FAILURE; } +#if PHP_VERSION_ID < 80000 zend_fcall_info_init(handler, 0, &fci, &fci_cache, NULL, &is_callable_error); if (is_callable_error) { @@ -575,6 +625,29 @@ int zephir_call_user_func_array_noex(zval *return_value, zval *handler, zval *pa if (EG(exception)) { status = SUCCESS; } +#else + zend_execute_data *frame = EG(current_execute_data); + if (!zend_is_callable_at_frame(handler, NULL, frame, 0, &fci_cache, &is_callable_error)) { + if (is_callable_error) { + zend_error(E_WARNING, "%s", is_callable_error); + efree(is_callable_error); + } + + return FAILURE; + } + + fci.size = sizeof(fci); + fci.object = fci_cache.object; + ZVAL_COPY_VALUE(&fci.function_name, handler); + fci.param_count = 0; + fci.params = NULL; + fci.retval = return_value; + fci.named_params = NULL; + + zend_fcall_info_args(&fci, params); + status = zend_call_function(&fci, &fci_cache); + zend_fcall_info_args_clear(&fci, 1); +#endif return status; } diff --git a/ext/kernel/fcall.h b/ext/kernel/fcall.h index 79e3360cca..d5cde64421 100644 --- a/ext/kernel/fcall.h +++ b/ext/kernel/fcall.h @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team @@ -69,9 +69,6 @@ typedef enum _zephir_call_type { } \ else { ZEPHIR_SET_THIS_EXPLICIT_NULL(); } \ - -#if PHP_VERSION_ID >= 70100 - #define ZEPHIR_BACKUP_SCOPE() \ zend_class_entry *old_scope = EG(fake_scope); \ zend_execute_data *old_call = execute_data; \ @@ -97,36 +94,6 @@ typedef enum _zephir_call_type { EG(fake_scope) = _scope; \ zephir_set_called_scope(EG(current_execute_data), _scope_called); \ -#else - -#define ZEPHIR_BACKUP_SCOPE() \ - zend_class_entry *old_scope = EG(scope); \ - zend_execute_data *old_call = execute_data; \ - zend_execute_data *old_execute_data = EG(current_execute_data), new_execute_data; \ - if (!EG(current_execute_data)) { \ - memset(&new_execute_data, 0, sizeof(zend_execute_data)); \ - execute_data = EG(current_execute_data) = &new_execute_data; \ - } else { \ - new_execute_data = *EG(current_execute_data); \ - new_execute_data.prev_execute_data = EG(current_execute_data); \ - new_execute_data.call = NULL; \ - new_execute_data.opline = NULL; \ - new_execute_data.func = NULL; \ - execute_data = EG(current_execute_data) = &new_execute_data; \ - } -// TODO(serghei): Deprecated -#define ZEPHIR_RESTORE_SCOPE() \ - EG(scope) = old_scope; \ - execute_data = old_call; \ - EG(current_execute_data) = old_execute_data; - -// TODO(serghei): Deprecated -#define ZEPHIR_SET_SCOPE(_scope, _scope_called) \ - EG(scope) = _scope; \ - EG(current_execute_data)->called_scope = _scope_called; - -#endif - /* End internal calls */ #define ZEPHIR_RETURN_CALL_ZVAL_FUNCTION(func_name, cache, cache_slot, ...) \ @@ -212,35 +179,18 @@ typedef enum _zephir_call_type { ZEPHIR_LAST_CALL_STATUS = zephir_return_call_class_method(return_value, class_entry, zephir_fcall_parent, this_ptr, method, strlen(method), cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \ } while (0) -#if PHP_VERSION_ID >= 80000 -#define ZEPHIR_CALL_SELF(return_value_ptr, method, cache, cache_slot, ...) \ - do { \ - zval *params_[] = {ZEPHIR_FETCH_VA_ARGS __VA_ARGS__}; \ - ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(return_value_ptr); \ - ZEPHIR_LAST_CALL_STATUS = zephir_call_class_method_aparams(return_value_ptr, getThis(), zephir_fcall_self, (getThis() ? Z_OBJCE_P(getThis()) : NULL), method, strlen(method), cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \ - } while (0) -#else #define ZEPHIR_CALL_SELF(return_value_ptr, method, cache, cache_slot, ...) \ do { \ zval *params_[] = {ZEPHIR_FETCH_VA_ARGS __VA_ARGS__}; \ ZEPHIR_OBSERVE_OR_NULLIFY_PPZV(return_value_ptr); \ ZEPHIR_LAST_CALL_STATUS = zephir_call_class_method_aparams(return_value_ptr, NULL, zephir_fcall_self, NULL, method, strlen(method), cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \ } while (0) -#endif -#if PHP_VERSION_ID >= 80000 -#define ZEPHIR_RETURN_CALL_SELF(method, cache, cache_slot, ...) \ - do { \ - zval *params_[] = {ZEPHIR_FETCH_VA_ARGS __VA_ARGS__}; \ - ZEPHIR_LAST_CALL_STATUS = zephir_return_call_class_method(return_value, (getThis() ? Z_OBJCE_P(getThis()) : NULL), zephir_fcall_self, getThis(), method, strlen(method), cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \ - } while (0) -#else #define ZEPHIR_RETURN_CALL_SELF(method, cache, cache_slot, ...) \ do { \ zval *params_[] = {ZEPHIR_FETCH_VA_ARGS __VA_ARGS__}; \ ZEPHIR_LAST_CALL_STATUS = zephir_return_call_class_method(return_value, NULL, zephir_fcall_self, NULL, method, strlen(method), cache, cache_slot, ZEPHIR_CALL_NUM_PARAMS(params_), ZEPHIR_PASS_CALL_PARAMS(params_)); \ } while (0) -#endif #define ZEPHIR_CALL_STATIC(return_value_ptr, method, cache, cache_slot, ...) \ do { \ @@ -382,12 +332,18 @@ ZEPHIR_ATTR_WARN_UNUSED_RESULT static inline int zephir_return_call_zval_functio return SUCCESS; } -ZEPHIR_ATTR_WARN_UNUSED_RESULT static inline int zephir_return_call_class_method(zval *return_value, - zend_class_entry *ce, zephir_call_type type, zval *object, - const char *method_name, uint32_t method_len, - zephir_fcall_cache_entry **cache_entry, int cache_slot, - uint32_t param_count, zval **params) -{ +ZEPHIR_ATTR_WARN_UNUSED_RESULT static inline int zephir_return_call_class_method( + zval *return_value, + zend_class_entry *ce, + zephir_call_type type, + zval *object, + const char *method_name, + uint32_t method_len, + zephir_fcall_cache_entry **cache_entry, + int cache_slot, + uint32_t param_count, + zval **params +) { zval rv, *rvp = return_value ? return_value : &rv; int status; diff --git a/ext/kernel/file.c b/ext/kernel/file.c index 96aabd071c..a0540f7d83 100644 --- a/ext/kernel/file.c +++ b/ext/kernel/file.c @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Vladimir Kolesnikov | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifdef HAVE_CONFIG_H #include "config.h" @@ -88,7 +79,6 @@ int zephir_file_exists(zval *filename) */ int zephir_compare_mtime(zval *filename1, zval *filename2) { - php_stream_statbuf statbuffer1, statbuffer2; if (Z_TYPE_P(filename1) != IS_STRING || Z_TYPE_P(filename2) != IS_STRING) { @@ -111,7 +101,6 @@ int zephir_compare_mtime(zval *filename1, zval *filename2) void zephir_fwrite(zval *return_value, zval *stream_zval, zval *data) { - int num_bytes; php_stream *stream; @@ -152,7 +141,6 @@ void zephir_fwrite(zval *return_value, zval *stream_zval, zval *data) int zephir_feof(zval *stream_zval) { - php_stream *stream; if (Z_TYPE_P(stream_zval) != IS_RESOURCE) { @@ -256,11 +244,7 @@ void zephir_file_put_contents(zval *return_value, zval *filename, zval *data) case IS_DOUBLE: case IS_TRUE: case IS_FALSE: -#if PHP_VERSION_ID < 70300 - case IS_CONSTANT: -#else case IS_CONSTANT_AST: -#endif use_copy = zend_make_printable_zval(data, ©); if (use_copy) { data = © @@ -315,7 +299,6 @@ void zephir_filemtime(zval *return_value, zval *path) */ void zephir_prepare_virtual_path(zval *return_value, zval *path, zval *virtual_separator) { - unsigned int i; unsigned char ch; smart_str virtual_str = {0}; diff --git a/ext/kernel/file.h b/ext/kernel/file.h index 924d83ca5c..90495c90f0 100644 --- a/ext/kernel/file.h +++ b/ext/kernel/file.h @@ -1,21 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_FILE_H #define ZEPHIR_KERNEL_FILE_H diff --git a/ext/kernel/filter.c b/ext/kernel/filter.c index 0cdc4faf4f..bd30aaed4d 100644 --- a/ext/kernel/filter.c +++ b/ext/kernel/filter.c @@ -1,21 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifdef HAVE_CONFIG_H #include "config.h" @@ -40,8 +32,8 @@ /** * Filter alphanum string */ -void zephir_filter_alphanum(zval *return_value, zval *param) { - +void zephir_filter_alphanum(zval *return_value, zval *param) +{ unsigned int i; unsigned char ch; smart_str filtered_str = {0}; @@ -83,7 +75,6 @@ void zephir_filter_alphanum(zval *return_value, zval *param) { */ void zephir_is_basic_charset(zval *return_value, const zval *param) { - unsigned int i; unsigned int ch; int iso88591 = 0; @@ -127,8 +118,8 @@ static long zephir_unpack(char *data, int size, int issigned, int *map) /** * Converts an unsigned long to a char* */ -static inline char *zephir_longtohex(unsigned long value) { - +static inline char *zephir_longtohex(unsigned long value) +{ static char digits[] = "0123456789abcdef"; char buf[(sizeof(unsigned long) << 3) + 1]; char *ptr, *end; @@ -148,7 +139,6 @@ static inline char *zephir_longtohex(unsigned long value) { */ void zephir_escape_multi(zval *return_value, zval *param, const char *escape_char, unsigned int escape_length, char escape_extra, int use_whitelist) { - unsigned int i; zval copy; smart_str escaped_str = {0}; diff --git a/ext/kernel/filter.h b/ext/kernel/filter.h index 951ba81a86..652d1e9040 100644 --- a/ext/kernel/filter.h +++ b/ext/kernel/filter.h @@ -1,21 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_FILTER_H #define ZEPHIR_KERNEL_FILTER_H diff --git a/ext/kernel/globals.h b/ext/kernel/globals.h index 414c21dc6c..724e2e3feb 100644 --- a/ext/kernel/globals.h +++ b/ext/kernel/globals.h @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Vladimir Kolesnikov | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_GLOBALS_H #define ZEPHIR_KERNEL_GLOBALS_H diff --git a/ext/kernel/iterator.c b/ext/kernel/iterator.c index b71e43e0c9..901f3efc2c 100644 --- a/ext/kernel/iterator.c +++ b/ext/kernel/iterator.c @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Vladimir Kolesnikov | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifdef HAVE_CONFIG_H #include "config.h" diff --git a/ext/kernel/iterator.h b/ext/kernel/iterator.h index c2fdf0e96c..48d49629c1 100644 --- a/ext/kernel/iterator.h +++ b/ext/kernel/iterator.h @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Vladimir Kolesnikov | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_ITERATOR_H #define ZEPHIR_KERNEL_ITERATOR_H diff --git a/ext/kernel/main.c b/ext/kernel/main.c index 4bc2465390..8014a65145 100644 --- a/ext/kernel/main.c +++ b/ext/kernel/main.c @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team @@ -238,7 +238,6 @@ int zephir_fast_count_int(zval *value) } if (Z_TYPE_P(value) == IS_OBJECT) { - zval retval; if (Z_OBJ_HT_P(value)->count_elements) { @@ -275,20 +274,6 @@ int zephir_fast_count_int(zval *value) return 1; } -/** - * Check if a function exists using explicit function length - * - * TODO: Deprecated. Will be removed in future - */ -int zephir_function_quick_exists_ex(const char *function_name, size_t function_len) -{ - if (zend_hash_str_exists(CG(function_table), function_name, function_len)) { - return SUCCESS; - } - - return FAILURE; -} - /** * Check if a function exists * @@ -297,7 +282,7 @@ int zephir_function_quick_exists_ex(const char *function_name, size_t function_l */ int zephir_function_exists(const zval *function_name) { - if (zend_hash_str_exists(CG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name))) { + if (zend_hash_str_exists(CG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)) != NULL) { return SUCCESS; } @@ -307,13 +292,17 @@ int zephir_function_exists(const zval *function_name) /** * Check if a function exists using explicit function length * - * TODO: Deprecated. Will be removed in future + * TODO: Check if make sense to merge all logic of IS_STRING inside zephir_function_exists() function. * @param function_name * @param function_len strlen(function_name) + 1 */ int zephir_function_exists_ex(const char *function_name, unsigned int function_len) { - return zephir_function_quick_exists_ex(function_name, function_len); + if (zend_hash_str_exists(CG(function_table), function_name, function_len) != NULL) { + return SUCCESS; + } + + return FAILURE; } /** @@ -433,7 +422,7 @@ int zephir_declare_class_constant(zend_class_entry *ce, const char *name, size_t } return SUCCESS; -#elif PHP_VERSION_ID >= 70200 +#else int ret; zend_string *key; @@ -450,20 +439,6 @@ int zephir_declare_class_constant(zend_class_entry *ce, const char *name, size_t } return ret; -#elif PHP_VERSION_ID >= 70100 - int ret; - - zend_string *key = zend_string_init(name, name_length, ce->type & ZEND_INTERNAL_CLASS); - ret = zend_declare_class_constant_ex(ce, key, value, ZEND_ACC_PUBLIC, NULL); - zend_string_release(key); - return ret; -#else - if (Z_CONSTANT_P(value)) { - ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED; - } - ZVAL_NEW_PERSISTENT_REF(value, value); - return zend_hash_str_update(&ce->constants_table, name, name_length, value) ? - SUCCESS : FAILURE; #endif } @@ -538,8 +513,7 @@ int zephir_is_php_version(unsigned int id) return ((php_major + php_minor + php_release) == id ? 1 : 0); } -void -zephir_get_args(zval *return_value) +void zephir_get_args(zval *return_value) { zend_execute_data *ex = EG(current_execute_data); uint32_t arg_count = ZEND_CALL_NUM_ARGS(ex); @@ -582,8 +556,7 @@ zephir_get_args(zval *return_value) } } -void -zephir_get_arg(zval *return_value, zend_long idx) +void zephir_get_arg(zval *return_value, zend_long idx) { zend_execute_data *ex = EG(current_execute_data); uint32_t arg_count; @@ -595,11 +568,9 @@ zephir_get_arg(zval *return_value, zend_long idx) } arg_count = ZEND_CALL_NUM_ARGS(ex); -#if PHP_VERSION_ID >= 70100 - if (zend_forbid_dynamic_call("func_get_arg()") == FAILURE) { - RETURN_FALSE; - } -#endif + if (zend_forbid_dynamic_call("func_get_arg()") == FAILURE) { + RETURN_FALSE; + } if (UNEXPECTED((zend_ulong)idx >= arg_count)) { zend_error(E_WARNING, "func_get_arg(): Argument " ZEND_LONG_FMT " not passed to function", idx); diff --git a/ext/kernel/main.h b/ext/kernel/main.h index 28d513a2e1..72278a569f 100644 --- a/ext/kernel/main.h +++ b/ext/kernel/main.h @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team diff --git a/ext/kernel/math.c b/ext/kernel/math.c index 2a71416e20..437a2596c7 100644 --- a/ext/kernel/math.c +++ b/ext/kernel/math.c @@ -1,21 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifdef HAVE_CONFIG_H #include "config.h" @@ -189,11 +181,8 @@ void zephir_round(zval *return_value, zval *op1, zval *op2, zval *op3) } } -zend_long -zephir_mt_rand(zend_long min, zend_long max) +zend_long zephir_mt_rand(zend_long min, zend_long max) { - zend_long number; - if (max < min) { php_error_docref(NULL, E_WARNING, "max(" ZEND_LONG_FMT ") is smaller than min(" ZEND_LONG_FMT ")", max, min); return 0; @@ -203,20 +192,7 @@ zephir_mt_rand(zend_long min, zend_long max) php_mt_srand(GENERATE_SEED()); } - number = (zend_long) (php_mt_rand() >> 1); - - /** - * The RAND_RANGE() macro has been removed since PHP 7.3. - * php_mt_rand_range() should be used instead. - * However, php_mt_rand_range() has been present since PHP 7.1. - */ -#if PHP_VERSION_ID < 70100 - RAND_RANGE(number, min, max, PHP_MT_RAND_MAX); -#else - number = php_mt_rand_range(min, max); -#endif - - return number; + return php_mt_rand_range(min, max); } double zephir_ldexp(zval *value, zval *expval) diff --git a/ext/kernel/math.h b/ext/kernel/math.h index d83637e09e..ba4c401664 100644 --- a/ext/kernel/math.h +++ b/ext/kernel/math.h @@ -1,21 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_MATH_H #define ZEPHIR_KERNEL_MATH_H diff --git a/ext/kernel/memory.c b/ext/kernel/memory.c index 180f5ffc36..ac1f012fd0 100644 --- a/ext/kernel/memory.c +++ b/ext/kernel/memory.c @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team diff --git a/ext/kernel/memory.h b/ext/kernel/memory.h index b7b0493a6d..269ed60920 100644 --- a/ext/kernel/memory.h +++ b/ext/kernel/memory.h @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team @@ -179,10 +179,3 @@ int zephir_set_symbol_str(char *key_name, unsigned int key_length, zval *value); } while (0) #endif - -/* Backwards compatibility for GC API change in PHP 7.3 */ -#if PHP_VERSION_ID < 70300 -# define GC_ADDREF(p) ++GC_REFCOUNT(p) -# define GC_DELREF(p) --GC_REFCOUNT(p) -# define GC_SET_REFCOUNT(p, rc) GC_REFCOUNT(p) = rc -#endif diff --git a/ext/kernel/object.c b/ext/kernel/object.c index 93496a87e5..655b2d38f6 100644 --- a/ext/kernel/object.c +++ b/ext/kernel/object.c @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team @@ -95,7 +95,6 @@ int zephir_zval_is_traversable(zval *object) */ void zephir_get_called_class(zval *return_value) { -#if PHP_VERSION_ID >= 70100 zend_class_entry *called_scope = zend_get_called_scope(EG(current_execute_data)); if (called_scope) { ZVAL_STR(return_value, zend_string_dup(called_scope->name, 0)); @@ -104,17 +103,6 @@ void zephir_get_called_class(zval *return_value) if (!zend_get_executed_scope()) { php_error_docref(NULL, E_WARNING, "zephir_get_called_class() called from outside a class"); } -#else - if (EG(current_execute_data)->called_scope) { - zend_string *ret = EG(current_execute_data)->called_scope->name; - zend_string_addref(ret); - RETURN_STR(ret); - } - - if (!EG(scope)) { - php_error_docref(NULL, E_WARNING, "zephir_get_called_class() called from outside a class"); - } -#endif } zend_class_entry *zephir_fetch_class_str_ex(const char *class_name, size_t length, int fetch_type) @@ -150,7 +138,6 @@ void zephir_get_class(zval *result, zval *object, int lower) zval *z = Z_ISREF_P(object) ? Z_REFVAL_P(object) : object; if (Z_TYPE_P(z) == IS_OBJECT) { - ce = Z_OBJCE_P(z); //zval_ptr_dtor(result); class_name = zend_string_init(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), 0); @@ -223,7 +210,6 @@ void zephir_get_class_ns(zval *result, zval *object, int lower) if (lower) { zend_str_tolower(Z_STRVAL_P(result), Z_STRLEN_P(result)); } - } /** @@ -373,19 +359,10 @@ int zephir_clone(zval *destination, zval *obj) int zephir_isset_property(zval *object, const char *property_name, unsigned int property_length) { if (Z_TYPE_P(object) == IS_OBJECT) { - /* - if (Z_OBJ_HANDLER_P(object, has_property)) { - zval member; - int retval; - ZVAL_STRINGL(&member, property_name, property_length); - retval = Z_OBJ_HT_P(object)->has_property(object, &member, 2, NULL); - zval_ptr_dtor(&member); - return retval; - } - */ if (EXPECTED(zend_hash_str_exists(&Z_OBJCE_P(object)->properties_info, property_name, property_length))) { return 1; } + #if PHP_VERSION_ID >= 80000 return zend_hash_str_exists( Z_OBJ_HT_P(object)->get_properties(Z_OBJ_P(object)), @@ -411,15 +388,9 @@ int zephir_isset_property_zval(zval *object, const zval *property) { if (Z_TYPE_P(object) == IS_OBJECT) { if (Z_TYPE_P(property) == IS_STRING) { - /* - if (Z_OBJ_HANDLER_P(object, has_property)) { - return Z_OBJ_HT_P(object)->has_property(object, property, 2, NULL); - } - */ if (EXPECTED(zend_hash_str_exists(&Z_OBJCE_P(object)->properties_info, Z_STRVAL_P(property), Z_STRLEN_P(property)))) { return 1; } else { - #if PHP_VERSION_ID >= 80000 return zend_hash_str_exists( Z_OBJ_HT_P(object)->get_properties(Z_OBJ_P(object)), @@ -443,10 +414,11 @@ int zephir_isset_property_zval(zval *object, const zval *property) /** * Lookup for the real owner of the property */ -static inline -zend_class_entry *zephir_lookup_class_ce(zend_class_entry *ce, - const char *property_name, - unsigned int property_length) { +static inline zend_class_entry *zephir_lookup_class_ce( + zend_class_entry *ce, + const char *property_name, + unsigned int property_length +) { zend_class_entry *original_ce = ce; zend_property_info *info; zend_class_entry *scope; @@ -487,9 +459,12 @@ zend_class_entry *zephir_lookup_class_ce(zend_class_entry *ce, * This function is intended to use in initializer. Do not use it for a * regular property updating. */ -int zephir_read_property_ex(zval *result, zval *object, const char *property_name, - uint32_t property_length, int flags) -{ +int zephir_read_property_ex( + zval *result, + zval *object, + const char *property_name, + uint32_t property_length, int flags +) { zend_class_entry *scope; int retval; @@ -522,9 +497,12 @@ int zephir_read_property_ex(zval *result, zval *object, const char *property_nam /** * Checks whether obj is an object and reads a property from this object */ -int zephir_read_property(zval *result, zval *object, const char *property_name, - uint32_t property_length, int flags) -{ +int zephir_read_property( + zval *result, + zval *object, + const char *property_name, + uint32_t property_length, int flags +) { zval property, tmp; zval *res; @@ -532,9 +510,7 @@ int zephir_read_property(zval *result, zval *object, const char *property_name, if (Z_TYPE_P(object) != IS_OBJECT) { if ((flags & PH_NOISY) == PH_NOISY) { - php_error_docref(NULL, E_NOTICE, - "Trying to get property '%s' of non-object", - property_name); + php_error_docref(NULL, E_NOTICE, "Trying to get property '%s' of non-object", property_name); } ZVAL_NULL(result); @@ -542,9 +518,7 @@ int zephir_read_property(zval *result, zval *object, const char *property_name, } if (!Z_OBJ_HT_P(object)->read_property) { - zend_error(E_CORE_ERROR, - "Property %s of class %s cannot be read", - property_name, ZSTR_VAL(Z_OBJCE_P(object)->name)); + zend_error(E_CORE_ERROR, "Property %s of class %s cannot be read", property_name, ZSTR_VAL(Z_OBJCE_P(object)->name)); } ZVAL_STRINGL(&property, property_name, property_length); @@ -579,7 +553,6 @@ int zephir_fetch_property(zval *result, zval *object, const char *property_name, return 1; } - //zval_ptr_dtor(result); ZVAL_NULL(result); return 0; } @@ -632,9 +605,12 @@ int zephir_read_property_zval(zval *result, zval *object, zval *property, int fl * This function is intended to use in initializer. Do not use it for a * regular property updating. */ -int zephir_update_property_zval_ex(zval *object, const char *property_name, - unsigned int property_length, zval *value) -{ +int zephir_update_property_zval_ex( + zval *object, + const char *property_name, + unsigned int property_length, + zval *value +) { zend_class_entry *scope; int retval; @@ -667,22 +643,21 @@ int zephir_update_property_zval_ex(zval *object, const char *property_name, /** * Checks whether obj is an object and updates property with another zval */ -int zephir_update_property_zval(zval *object, const char *property_name, - unsigned int property_length, zval *value) -{ +int zephir_update_property_zval( + zval *object, + const char *property_name, + unsigned int property_length, + zval *value +) { zval property, sep_value; if (Z_TYPE_P(object) != IS_OBJECT) { - php_error_docref(NULL, E_WARNING, - "Attempt to assign property '%s' of non-object", - property_name); + php_error_docref(NULL, E_WARNING, "Attempt to assign property '%s' of non-object", property_name); return FAILURE; } if (!Z_OBJ_HT_P(object)->write_property) { - zend_error(E_CORE_ERROR, - "Property %s of class %s cannot be updated", - property_name, ZSTR_VAL(Z_OBJCE_P(object)->name)); + zend_error(E_CORE_ERROR, "Property %s of class %s cannot be updated", property_name, ZSTR_VAL(Z_OBJCE_P(object)->name)); } ZVAL_STRINGL(&property, property_name, property_length); @@ -987,7 +962,6 @@ int zephir_unset_property_array(zval *object, char *property, unsigned int prope int separated = 0; if (Z_TYPE_P(object) == IS_OBJECT) { - zephir_read_property(&tmp, object, property, property_length, PH_NOISY_CC); Z_TRY_DELREF(tmp); @@ -1067,9 +1041,11 @@ int zephir_method_exists(zval *object, const zval *method_name) zend_error(E_WARNING, "method_exists expected a string"); return 0; } + char *lcname = zend_str_tolower_dup(Z_STRVAL_P(method_name), Z_STRLEN_P(method_name)); int res = zephir_method_exists_ex(object, lcname, Z_STRLEN_P(method_name)); efree(lcname); + return res; } @@ -1077,43 +1053,26 @@ int zephir_read_static_property_ce(zval *result, zend_class_entry *ce, const cha { zval *tmp = zend_read_static_property(ce, property, len, (zend_bool) ZEND_FETCH_CLASS_SILENT); - //zval_ptr_dtor(result); ZVAL_NULL(result); - if (tmp) - { + if (tmp) { if ((flags & PH_READONLY) == PH_READONLY) { ZVAL_COPY_VALUE(result, tmp); } else { ZVAL_COPY(result, tmp); } + return SUCCESS; } + return FAILURE; } +/** + * TODO: Use directly zend_update_static_property() + */ int zephir_update_static_property_ce(zend_class_entry *ce, const char *property_name, uint32_t property_length, zval *value) { -// Disabled due to: -// https://github.com/phalcon/zephir/issues/1941#issuecomment-538654340 -// -//#if PHP_VERSION_ID < 70300 -// zval *property, garbage; -// property = zend_read_static_property(ce, property_name, property_length, (zend_bool)ZEND_FETCH_CLASS_SILENT); -// if (property) { -// if (Z_ISREF_P(property)) { -// ZVAL_DEREF(property); -// } -// if (Z_ISREF_P(value)) { -// ZVAL_DEREF(value); -// } -// ZVAL_COPY_VALUE(&garbage, property); -// ZVAL_COPY(property, value); -// zval_ptr_dtor(&garbage); -// return 1; -// } -//#else return zend_update_static_property(ce, property_name, property_length, value); -//#endif } int zephir_add_static_property_ce(zend_class_entry *ce, const char *property_name, uint32_t property_length, zval *value) @@ -1135,8 +1094,16 @@ int zephir_sub_static_property_ce(zend_class_entry *ce, const char *property_nam /* * Multiple array-offset update */ -int zephir_update_static_property_array_multi_ce(zend_class_entry *ce, const char *property, uint32_t property_length, zval *value, const char *types, int types_length, int types_count, ...) -{ +int zephir_update_static_property_array_multi_ce( + zend_class_entry *ce, + const char *property, + uint32_t property_length, + zval *value, + const char *types, + int types_length, + int types_count, + ... +) { va_list ap; zval tmp_arr; int separated = 0; @@ -1173,6 +1140,7 @@ int zephir_update_static_property_array_multi_ce(zend_class_entry *ce, const cha array_init(&tmp_arr); separated = 1; } + if (Z_REFCOUNTED(tmp_arr)) { if (Z_REFCOUNT(tmp_arr) > 1) { if (!Z_ISREF(tmp_arr)) { @@ -1225,7 +1193,6 @@ int zephir_property_incr_decr(zval *object, char *property_name, unsigned int pr zephir_read_property(&tmp, object, property_name, property_length, 0); if (Z_TYPE(tmp) > IS_UNDEF) { - Z_TRY_DELREF(tmp); /** Separation only when refcount > 1 */ @@ -1267,11 +1234,7 @@ typedef struct _zend_closure { zend_function func; zval this_ptr; zend_class_entry *called_scope; -#if PHP_VERSION_ID >= 70300 zif_handler orig_internal_handler; -#else - void (*orig_internal_handler)(INTERNAL_FUNCTION_PARAMETERS); -#endif } zend_closure; /** @@ -1326,10 +1289,6 @@ int zephir_create_instance(zval *return_value, const zval *class_name) zend_class_entry* ce = Z_OBJCE_P(return_value); fci.size = sizeof(fci); -#if PHP_VERSION_ID < 70100 - fci.function_table = &ce->function_table; - fci.symbol_table = NULL; -#endif fci.object = obj; fci.retval = 0; fci.param_count = 0; @@ -1339,11 +1298,9 @@ int zephir_create_instance(zval *return_value, const zval *class_name) #else fci.named_params = NULL; #endif + ZVAL_NULL(&fci.function_name); -#if PHP_VERSION_ID < 70300 - fcc.initialized = 1; -#endif fcc.object = obj; fcc.called_scope = ce; fcc.calling_scope = ce; @@ -1394,10 +1351,6 @@ int zephir_create_instance_params(zval *return_value, const zval *class_name, zv zend_class_entry* ce = Z_OBJCE_P(return_value); fci.size = sizeof(fci); -#if PHP_VERSION_ID < 70100 - fci.function_table = &ce->function_table; - fci.symbol_table = NULL; -#endif fci.object = obj; fci.retval = 0; fci.param_count = 0; @@ -1409,9 +1362,6 @@ int zephir_create_instance_params(zval *return_value, const zval *class_name, zv #endif ZVAL_NULL(&fci.function_name); -#if PHP_VERSION_ID < 70300 - fcc.initialized = 1; -#endif fcc.object = obj; fcc.called_scope = ce; fcc.calling_scope = ce; diff --git a/ext/kernel/object.h b/ext/kernel/object.h index 36598823f3..6a24e728be 100644 --- a/ext/kernel/object.h +++ b/ext/kernel/object.h @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team @@ -19,13 +19,8 @@ #include "kernel/main.h" /* Working with scopes */ -#if PHP_VERSION_ID >= 70100 # define zephir_get_scope(e) ((e) ? zend_get_executed_scope() : EG(fake_scope)) # define zephir_set_scope(s) EG(fake_scope) = (s) -#else -# define zephir_get_scope(e) EG(scope) -# define zephir_set_scope(s) EG(scope) = (s) -#endif /** Class Retrieving/Checking */ int zephir_class_exists(zval *class_name, int autoload); diff --git a/ext/kernel/operators.c b/ext/kernel/operators.c index cd1d48035c..1cc0064ead 100644 --- a/ext/kernel/operators.c +++ b/ext/kernel/operators.c @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Vladimir Kolesnikov | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifdef HAVE_CONFIG_H #include "config.h" diff --git a/ext/kernel/operators.h b/ext/kernel/operators.h index 77c1fc1789..881f30f0b6 100644 --- a/ext/kernel/operators.h +++ b/ext/kernel/operators.h @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Vladimir Kolesnikov | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_OPERATORS_H #define ZEPHIR_KERNEL_OPERATORS_H diff --git a/ext/kernel/require.c b/ext/kernel/require.c index a0d5ccfad9..2bab5554c5 100644 --- a/ext/kernel/require.c +++ b/ext/kernel/require.c @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team @@ -45,19 +45,10 @@ int zephir_require_ret(zval *return_value_ptr, const char *require_path) } #endif -#if PHP_VERSION_ID < 70400 - file_handle.filename = require_path; - file_handle.free_filename = 0; - file_handle.type = ZEND_HANDLE_FILENAME; - file_handle.opened_path = NULL; - file_handle.handle.fp = NULL; -#else - ret = php_stream_open_for_zend_ex(require_path, &file_handle, USE_PATH|STREAM_OPEN_FOR_INCLUDE); - - if (ret != SUCCESS) { - return FAILURE; - } -#endif + ret = php_stream_open_for_zend_ex(require_path, &file_handle, USE_PATH|STREAM_OPEN_FOR_INCLUDE); + if (ret != SUCCESS) { + return FAILURE; + } new_op_array = zend_compile_file(&file_handle, ZEND_REQUIRE); if (new_op_array) { @@ -72,11 +63,7 @@ int zephir_require_ret(zval *return_value_ptr, const char *require_path) zend_destroy_file_handle(&file_handle); } -#if PHP_VERSION_ID >= 70100 new_op_array->scope = EG(fake_scope) ? EG(fake_scope) : zend_get_executed_scope(); -#else - new_op_array->scope = EG(scope); -#endif zend_execute(new_op_array, &local_retval); if (return_value_ptr) { diff --git a/ext/kernel/require.h b/ext/kernel/require.h index 6cb3f60cfd..30a2bca866 100644 --- a/ext/kernel/require.h +++ b/ext/kernel/require.h @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team diff --git a/ext/kernel/string.c b/ext/kernel/string.c index 2b2bc75368..dd5ba9d432 100644 --- a/ext/kernel/string.c +++ b/ext/kernel/string.c @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team @@ -151,7 +151,6 @@ void zephir_fast_strtoupper(zval *return_value, zval *str) */ int zephir_start_with(const zval *str, const zval *compared, zval *case_sensitive) { - int i; int sensitive = 0; char *op1_cursor, *op2_cursor; @@ -175,7 +174,6 @@ int zephir_start_with(const zval *str, const zval *compared, zval *case_sensitiv op1_cursor = Z_STRVAL_P(str); op2_cursor = Z_STRVAL_P(compared); for (i = 0; i < Z_STRLEN_P(compared); i++) { - if (tolower(*op1_cursor) != tolower(*op2_cursor)) { return 0; } @@ -217,7 +215,6 @@ int zephir_start_with_str_str(char *str, unsigned int str_length, char *compared */ int zephir_end_with(const zval *str, const zval *compared, zval *case_sensitive) { - int sensitive = 0; int i; char *op1_cursor, *op2_cursor; @@ -259,7 +256,6 @@ int zephir_end_with(const zval *str, const zval *compared, zval *case_sensitive) */ int zephir_end_with_str(const zval *str, char *compared, unsigned int compared_length) { - if (Z_TYPE_P(str) != IS_STRING) { return 0; } @@ -433,7 +429,6 @@ void zephir_append_printable_array(smart_str *implstr, const zval *value) */ void zephir_unique_key(zval *return_value, const zval *prefix, zval *value) { - smart_str implstr = {0}; if (Z_TYPE_P(prefix) == IS_STRING) { @@ -568,7 +563,6 @@ void zephir_fast_join_str(zval *return_value, char *glue, unsigned int glue_leng */ void zephir_camelize(zval *return_value, const zval *str, const zval *delimiter) { - int i, len, delim_len, pre_del = 1; smart_str camelize_str = {0}; char *marker, ch, *delim; @@ -669,7 +663,6 @@ void zephir_uncamelize(zval *return_value, const zval *str, const zval *delimite */ int zephir_memnstr(const zval *haystack, const zval *needle ZEPHIR_DEBUG_PARAMS) { - if (Z_TYPE_P(haystack) != IS_STRING || Z_TYPE_P(needle) != IS_STRING) { #ifndef ZEPHIR_RELEASE zend_error(E_WARNING, "Invalid arguments supplied for memnstr in %s on line %d", file, line); @@ -889,6 +882,7 @@ static zend_string* php_char_to_str_ex(zend_string *str, char from, char *to, si } } } + *target = 0; return result; } @@ -1071,19 +1065,11 @@ void zephir_preg_match(zval *return_value, zval *regex, zval *subject, zval *mat ZVAL_UNDEF(&tmp_matches); -#if PHP_VERSION_ID < 70400 - if (flags != 0 || offset != 0) { - php_pcre_match_impl(pce, Z_STRVAL_P(subject), Z_STRLEN_P(subject), return_value, &tmp_matches, global, 1, flags, offset); - } else { - php_pcre_match_impl(pce, Z_STRVAL_P(subject), Z_STRLEN_P(subject), return_value, &tmp_matches, global, 0, 0, 0); - } -#else if (flags != 0 || offset != 0) { php_pcre_match_impl(pce, Z_STR_P(subject), return_value, &tmp_matches, global, 1, flags, offset); } else { php_pcre_match_impl(pce, Z_STR_P(subject), return_value, &tmp_matches, global, 0, 0, 0); } -#endif if (matches) { zval *php_matches = &tmp_matches; @@ -1303,11 +1289,7 @@ void zephir_addslashes(zval *return_value, zval *str) } } -#if PHP_VERSION_ID < 70300 - ZVAL_STR(return_value, php_addslashes(Z_STR_P(str), 0)); -#else - ZVAL_STR(return_value, php_addslashes(Z_STR_P(str))); -#endif + ZVAL_STR(return_value, php_addslashes(Z_STR_P(str))); if (UNEXPECTED(use_copy)) { zval_dtor(©); diff --git a/ext/kernel/string.h b/ext/kernel/string.h index 014c246785..9d98e515ef 100644 --- a/ext/kernel/string.h +++ b/ext/kernel/string.h @@ -1,4 +1,4 @@ -/* +/** * This file is part of the Zephir. * * (c) Phalcon Team diff --git a/ext/kernel/time.c b/ext/kernel/time.c index f94c0148ce..a70760cce0 100644 --- a/ext/kernel/time.c +++ b/ext/kernel/time.c @@ -1,18 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifdef HAVE_CONFIG_H #include "config.h" diff --git a/ext/kernel/time.h b/ext/kernel/time.h index 6a282a3af0..9aab8f71e0 100644 --- a/ext/kernel/time.h +++ b/ext/kernel/time.h @@ -1,18 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_TIME_H #define ZEPHIR_KERNEL_TIME_H diff --git a/ext/kernel/variables.c b/ext/kernel/variables.c index ab6f49c631..8559d26654 100644 --- a/ext/kernel/variables.c +++ b/ext/kernel/variables.c @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Rack Lin | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifdef HAVE_CONFIG_H #include "config.h" diff --git a/ext/kernel/variables.h b/ext/kernel/variables.h index 72b943e9fa..364eeebd89 100644 --- a/ext/kernel/variables.h +++ b/ext/kernel/variables.h @@ -1,22 +1,13 @@ - -/* - +------------------------------------------------------------------------+ - | Zephir Language | - +------------------------------------------------------------------------+ - | Copyright (c) 2011-2017 Phalcon Team (http://www.zephir-lang.com) | - +------------------------------------------------------------------------+ - | This source file is subject to the New BSD License that is bundled | - | with this package in the file docs/LICENSE.txt. | - | | - | If you did not receive a copy of the license and are unable to | - | obtain it through the world-wide-web, please send an email | - | to license@zephir-lang.com so we can send you a copy immediately. | - +------------------------------------------------------------------------+ - | Authors: Andres Gutierrez | - | Eduar Carvajal | - | Rack Lin | - +------------------------------------------------------------------------+ -*/ +/** + * This file is part of the Zephir. + * + * (c) Phalcon Team + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. If you did not receive + * a copy of the license it is available through the world-wide-web at the + * following url: https://docs.zephir-lang.com/en/latest/license + */ #ifndef ZEPHIR_KERNEL_VARIABLES_H #define ZEPHIR_KERNEL_VARIABLES_H diff --git a/ext/stub.c b/ext/stub.c index 47a821b539..c2a4f8402d 100644 --- a/ext/stub.c +++ b/ext/stub.c @@ -24,6 +24,8 @@ zend_class_entry *stub_testinterface_ce; +zend_class_entry *stub_interfaces_interfaceint_ce; +zend_class_entry *stub_interfaces_interfaceintsignature_ce; zend_class_entry *stub_methodinterface_ce; zend_class_entry *stub_oo_scopes_scopetesterinterface_ce; zend_class_entry *stub_ooimpl_zbeginning_ce; @@ -31,11 +33,14 @@ zend_class_entry *stub_diinterface_ce; zend_class_entry *stub_extendedinterface_ce; zend_class_entry *stub_integration_psr_http_message_messageinterfaceex_ce; zend_class_entry *stub_ooimpl_abeginning_ce; +zend_class_entry *stub_invokes_abstractprotected_ce; zend_class_entry *stub_oo_extend_exception_ce; zend_class_entry *stub_oo_extend_db_exception_ce; zend_class_entry *stub_scallparent_ce; zend_class_entry *stub_constantsparent_ce; zend_class_entry *stub_globals_session_base_ce; +zend_class_entry *stub_invokes_abstractinvoker_ce; +zend_class_entry *stub_invokes_abstractinvokercomplex_ce; zend_class_entry *stub_oo_abstractstatic_ce; zend_class_entry *stub_oo_extend_db_query_exception_ce; zend_class_entry *stub_oo_oodynamica_ce; @@ -98,6 +103,7 @@ zend_class_entry *stub_flow_switchflow_ce; zend_class_entry *stub_fortytwo_ce; zend_class_entry *stub_functional_ce; zend_class_entry *stub_functionexists_ce; +zend_class_entry *stub_functions_ce; zend_class_entry *stub_geometry_ce; zend_class_entry *stub_globals_ce; zend_class_entry *stub_globals_env_ce; @@ -107,9 +113,13 @@ zend_class_entry *stub_globals_serverrequestfactory_ce; zend_class_entry *stub_globals_session_child_ce; zend_class_entry *stub_instance_ce; zend_class_entry *stub_instanceoff_ce; +zend_class_entry *stub_interfaces_implementint_ce; +zend_class_entry *stub_interfaces_implementinterface_ce; zend_class_entry *stub_internalclasses_ce; zend_class_entry *stub_internalinterfaces_ce; zend_class_entry *stub_invoke_ce; +zend_class_entry *stub_invokes_invokeprotected_ce; +zend_class_entry *stub_invokes_invokeprotectedcomplex_ce; zend_class_entry *stub_issettest_ce; zend_class_entry *stub_issue1404_ce; zend_class_entry *stub_issue1521_ce; @@ -199,6 +209,7 @@ zend_class_entry *stub_router_route_ce; zend_class_entry *stub_scall_ce; zend_class_entry *stub_scalldynamic_ce; zend_class_entry *stub_scallexternal_ce; +zend_class_entry *stub_scalllateconstruct_ce; zend_class_entry *stub_scope_ce; zend_class_entry *stub_sort_ce; zend_class_entry *stub_spectralnorm_ce; @@ -234,6 +245,8 @@ static PHP_MINIT_FUNCTION(stub) REGISTER_INI_ENTRIES(); zephir_module_init(); ZEPHIR_INIT(Stub_TestInterface); + ZEPHIR_INIT(Stub_Interfaces_InterfaceInt); + ZEPHIR_INIT(Stub_Interfaces_InterfaceIntSignature); ZEPHIR_INIT(Stub_MethodInterface); ZEPHIR_INIT(Stub_OoImpl_ZBeginning); ZEPHIR_INIT(Stub_Oo_Scopes_ScopeTesterInterface); @@ -241,11 +254,14 @@ static PHP_MINIT_FUNCTION(stub) ZEPHIR_INIT(Stub_ExtendedInterface); ZEPHIR_INIT(Stub_Integration_Psr_Http_Message_MessageInterfaceEx); ZEPHIR_INIT(Stub_OoImpl_ABeginning); + ZEPHIR_INIT(Stub_Invokes_AbstractProtected); ZEPHIR_INIT(Stub_Oo_Extend_Exception); ZEPHIR_INIT(Stub_Oo_Extend_Db_Exception); ZEPHIR_INIT(Stub_ScallParent); ZEPHIR_INIT(Stub_ConstantsParent); ZEPHIR_INIT(Stub_Globals_Session_Base); + ZEPHIR_INIT(Stub_Invokes_AbstractInvoker); + ZEPHIR_INIT(Stub_Invokes_AbstractInvokerComplex); ZEPHIR_INIT(Stub_Oo_AbstractStatic); ZEPHIR_INIT(Stub_Oo_Extend_Db_Query_Exception); ZEPHIR_INIT(Stub_Oo_OoDynamicA); @@ -295,6 +311,7 @@ static PHP_MINIT_FUNCTION(stub) ZEPHIR_INIT(Stub_FortyTwo); ZEPHIR_INIT(Stub_FunctionExists); ZEPHIR_INIT(Stub_Functional); + ZEPHIR_INIT(Stub_Functions); ZEPHIR_INIT(Stub_Geometry); ZEPHIR_INIT(Stub_Globals); ZEPHIR_INIT(Stub_Globals_Env); @@ -304,9 +321,13 @@ static PHP_MINIT_FUNCTION(stub) ZEPHIR_INIT(Stub_Globals_Session_Child); ZEPHIR_INIT(Stub_Instance); ZEPHIR_INIT(Stub_Instanceoff); + ZEPHIR_INIT(Stub_Interfaces_ImplementInt); + ZEPHIR_INIT(Stub_Interfaces_ImplementInterface); ZEPHIR_INIT(Stub_InternalClasses); ZEPHIR_INIT(Stub_InternalInterfaces); ZEPHIR_INIT(Stub_Invoke); + ZEPHIR_INIT(Stub_Invokes_InvokeProtected); + ZEPHIR_INIT(Stub_Invokes_InvokeProtectedComplex); ZEPHIR_INIT(Stub_IssetTest); ZEPHIR_INIT(Stub_Issue1404); ZEPHIR_INIT(Stub_Issue1521); @@ -397,6 +418,7 @@ static PHP_MINIT_FUNCTION(stub) ZEPHIR_INIT(Stub_Scall); ZEPHIR_INIT(Stub_ScallDynamic); ZEPHIR_INIT(Stub_ScallExternal); + ZEPHIR_INIT(Stub_ScallLateConstruct); ZEPHIR_INIT(Stub_Scope); ZEPHIR_INIT(Stub_Sort); ZEPHIR_INIT(Stub_SpectralNorm); @@ -559,11 +581,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_f_stub_zephir_namespaced_method_test, 0, 0, 1) ZEND_END_ARG_INFO() PHP_FUNCTION(f_Stub_test_call_relative_object_hint); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_f_stub_test_call_relative_object_hint, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_f_stub_test_call_relative_object_hint, 0, 1, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_OBJ_INFO(0, a, Stub\\Oo\\PropertyAccess, 0) ZEND_END_ARG_INFO() @@ -573,11 +591,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_f_stub_zephir_namespaced_method_with_type_casting ZEND_END_ARG_INFO() PHP_FUNCTION(f_Stub_test_call_object_hint); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_f_stub_test_call_object_hint, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_f_stub_test_call_object_hint, 0, 1, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_OBJ_INFO(0, a, Stub\\Oo\\PropertyAccess, 0) ZEND_END_ARG_INFO() diff --git a/ext/stub.h b/ext/stub.h index 0d90c3fcc9..8aee4b1e3b 100644 --- a/ext/stub.h +++ b/ext/stub.h @@ -4,12 +4,17 @@ #ifndef ZEPHIR_CLASS_ENTRIES_H #define ZEPHIR_CLASS_ENTRIES_H +#include "stub/invokes/abstractprotected.zep.h" #include "stub/testinterface.zep.h" #include "stub/oo/extend/exception.zep.h" #include "stub/oo/extend/db/exception.zep.h" #include "stub/scallparent.zep.h" #include "stub/constantsparent.zep.h" #include "stub/globals/session/base.zep.h" +#include "stub/interfaces/interfaceint.zep.h" +#include "stub/interfaces/interfaceintsignature.zep.h" +#include "stub/invokes/abstractinvoker.zep.h" +#include "stub/invokes/abstractinvokercomplex.zep.h" #include "stub/methodinterface.zep.h" #include "stub/oo/abstractstatic.zep.h" #include "stub/oo/extend/db/query/exception.zep.h" @@ -64,6 +69,7 @@ #include "stub/fortytwo.zep.h" #include "stub/functional.zep.h" #include "stub/functionexists.zep.h" +#include "stub/functions.zep.h" #include "stub/geometry.zep.h" #include "stub/globals.zep.h" #include "stub/globals/env.zep.h" @@ -74,9 +80,13 @@ #include "stub/instance.zep.h" #include "stub/instanceoff.zep.h" #include "stub/integration/psr/http/message/messageinterfaceex.zep.h" +#include "stub/interfaces/implementint.zep.h" +#include "stub/interfaces/implementinterface.zep.h" #include "stub/internalclasses.zep.h" #include "stub/internalinterfaces.zep.h" #include "stub/invoke.zep.h" +#include "stub/invokes/invokeprotected.zep.h" +#include "stub/invokes/invokeprotectedcomplex.zep.h" #include "stub/issettest.zep.h" #include "stub/issue1404.zep.h" #include "stub/issue1521.zep.h" @@ -167,6 +177,7 @@ #include "stub/scall.zep.h" #include "stub/scalldynamic.zep.h" #include "stub/scallexternal.zep.h" +#include "stub/scalllateconstruct.zep.h" #include "stub/scope.zep.h" #include "stub/sort.zep.h" #include "stub/spectralnorm.zep.h" diff --git a/ext/stub/0__closure.zep.c b/ext/stub/0__closure.zep.c index 3bbf191598..5197d912d0 100644 --- a/ext/stub/0__closure.zep.c +++ b/ext/stub/0__closure.zep.c @@ -31,6 +31,14 @@ PHP_METHOD(stub_0__closure, __invoke) { zval *this_ptr = getThis(); ZVAL_UNDEF(&x_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(x) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &x); diff --git a/ext/stub/10__closure.zep.c b/ext/stub/10__closure.zep.c index 40ce8236fc..604cc0a6e3 100644 --- a/ext/stub/10__closure.zep.c +++ b/ext/stub/10__closure.zep.c @@ -31,6 +31,14 @@ PHP_METHOD(stub_10__closure, __invoke) { zval *this_ptr = getThis(); ZVAL_UNDEF(&x_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(x) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &x); diff --git a/ext/stub/11__closure.zep.c b/ext/stub/11__closure.zep.c index e0db934a1e..10424d773b 100644 --- a/ext/stub/11__closure.zep.c +++ b/ext/stub/11__closure.zep.c @@ -28,6 +28,7 @@ PHP_METHOD(stub_11__closure, __invoke) { zval *this_ptr = getThis(); + RETURN_LONG(5); } diff --git a/ext/stub/11__closure.zep.h b/ext/stub/11__closure.zep.h index a519a035f0..929e281622 100644 --- a/ext/stub/11__closure.zep.h +++ b/ext/stub/11__closure.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_11__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_11__closure_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(stub_11__closure, __invoke, arginfo_stub_11__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#else + PHP_ME(stub_11__closure, __invoke, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#endif PHP_FE_END }; diff --git a/ext/stub/12__closure.zep.c b/ext/stub/12__closure.zep.c index c2ad47f511..09758b4c19 100644 --- a/ext/stub/12__closure.zep.c +++ b/ext/stub/12__closure.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(stub_12__closure, __invoke) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_CE_STATIC(stub_mcall_caller_ce, "perform", &_0, 0); diff --git a/ext/stub/12__closure.zep.h b/ext/stub/12__closure.zep.h index 399d4a59fc..e55860734b 100644 --- a/ext/stub/12__closure.zep.h +++ b/ext/stub/12__closure.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_12__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_12__closure_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(stub_12__closure, __invoke, arginfo_stub_12__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#else + PHP_ME(stub_12__closure, __invoke, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#endif PHP_FE_END }; diff --git a/ext/stub/1__closure.zep.c b/ext/stub/1__closure.zep.c index 36592bcf42..36492c3bab 100644 --- a/ext/stub/1__closure.zep.c +++ b/ext/stub/1__closure.zep.c @@ -29,5 +29,6 @@ PHP_METHOD(stub_1__closure, __invoke) { + } diff --git a/ext/stub/1__closure.zep.h b/ext/stub/1__closure.zep.h index f0c311cc2c..b0da61413e 100644 --- a/ext/stub/1__closure.zep.h +++ b/ext/stub/1__closure.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_1__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_1__closure_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(stub_1__closure, __invoke, arginfo_stub_1__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#else + PHP_ME(stub_1__closure, __invoke, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#endif PHP_FE_END }; diff --git a/ext/stub/2__closure.zep.c b/ext/stub/2__closure.zep.c index 8450da1fca..ceef747aaa 100644 --- a/ext/stub/2__closure.zep.c +++ b/ext/stub/2__closure.zep.c @@ -29,5 +29,6 @@ PHP_METHOD(stub_2__closure, __invoke) { + } diff --git a/ext/stub/2__closure.zep.h b/ext/stub/2__closure.zep.h index 199f106623..13f7c95086 100644 --- a/ext/stub/2__closure.zep.h +++ b/ext/stub/2__closure.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_2__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_2__closure_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(stub_2__closure, __invoke, arginfo_stub_2__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#else + PHP_ME(stub_2__closure, __invoke, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#endif PHP_FE_END }; diff --git a/ext/stub/3__closure.zep.c b/ext/stub/3__closure.zep.c index f3246442ad..181655a974 100644 --- a/ext/stub/3__closure.zep.c +++ b/ext/stub/3__closure.zep.c @@ -30,6 +30,14 @@ PHP_METHOD(stub_3__closure, __invoke) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m1_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(param1) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, ¶m1); diff --git a/ext/stub/4__closure.zep.c b/ext/stub/4__closure.zep.c index 7e55452b1a..14884896ff 100644 --- a/ext/stub/4__closure.zep.c +++ b/ext/stub/4__closure.zep.c @@ -30,6 +30,14 @@ PHP_METHOD(stub_4__closure, __invoke) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m1_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(param1) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, ¶m1); diff --git a/ext/stub/5__closure.zep.c b/ext/stub/5__closure.zep.c index a428f163f9..84e39e6909 100644 --- a/ext/stub/5__closure.zep.c +++ b/ext/stub/5__closure.zep.c @@ -30,6 +30,14 @@ PHP_METHOD(stub_5__closure, __invoke) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m1_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(param1) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, ¶m1); diff --git a/ext/stub/6__closure.zep.c b/ext/stub/6__closure.zep.c index 5af01f4c20..ab61e3da6b 100644 --- a/ext/stub/6__closure.zep.c +++ b/ext/stub/6__closure.zep.c @@ -31,6 +31,14 @@ PHP_METHOD(stub_6__closure, __invoke) { zval *this_ptr = getThis(); ZVAL_UNDEF(&x_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(x) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &x); diff --git a/ext/stub/7__closure.zep.c b/ext/stub/7__closure.zep.c index ef5233bcda..409b1084c1 100644 --- a/ext/stub/7__closure.zep.c +++ b/ext/stub/7__closure.zep.c @@ -31,6 +31,14 @@ PHP_METHOD(stub_7__closure, __invoke) { zval *this_ptr = getThis(); ZVAL_UNDEF(&x_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(x) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &x); diff --git a/ext/stub/8__closure.zep.c b/ext/stub/8__closure.zep.c index 7f9916c0d0..a86d33b262 100644 --- a/ext/stub/8__closure.zep.c +++ b/ext/stub/8__closure.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(stub_8__closure, __invoke) { ZVAL_UNDEF(&abc); + zephir_read_static_property_ce(&abc, stub_8__closure_ce, SL("abc"), PH_NOISY_CC); RETURN_LONG((zephir_get_numberval(&abc) + 1)); diff --git a/ext/stub/8__closure.zep.h b/ext/stub/8__closure.zep.h index eb4fd229b8..a6584a11da 100644 --- a/ext/stub/8__closure.zep.h +++ b/ext/stub/8__closure.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_8__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_8__closure_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(stub_8__closure, __invoke, arginfo_stub_8__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#else + PHP_ME(stub_8__closure, __invoke, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#endif PHP_FE_END }; diff --git a/ext/stub/9__closure.zep.c b/ext/stub/9__closure.zep.c index a9e3784331..83502b0b0c 100644 --- a/ext/stub/9__closure.zep.c +++ b/ext/stub/9__closure.zep.c @@ -34,6 +34,7 @@ PHP_METHOD(stub_9__closure, __invoke) { ZVAL_UNDEF(&abc); ZVAL_UNDEF(&_0); + zephir_read_static_property_ce(&abc, stub_9__closure_ce, SL("abc"), PH_NOISY_CC); zephir_array_fetch_string(&_0, &abc, SL("a"), PH_NOISY | PH_READONLY, "stub/closures.zep", 63); diff --git a/ext/stub/9__closure.zep.h b/ext/stub/9__closure.zep.h index 43e81df67a..32f88976fc 100644 --- a/ext/stub/9__closure.zep.h +++ b/ext/stub/9__closure.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_9__closure___invoke, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_9__closure_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(stub_9__closure, __invoke, arginfo_stub_9__closure___invoke, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#else + PHP_ME(stub_9__closure, __invoke, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) +#endif PHP_FE_END }; diff --git a/ext/stub/arithmetic.zep.c b/ext/stub/arithmetic.zep.c index 98e7a4156f..00bd591c92 100644 --- a/ext/stub/arithmetic.zep.c +++ b/ext/stub/arithmetic.zep.c @@ -38,6 +38,7 @@ PHP_METHOD(Stub_Arithmetic, intSum) { + a = 1; b = 2; c = (a + b); @@ -52,6 +53,7 @@ PHP_METHOD(Stub_Arithmetic, int2Sum) { + a = 1; c = (a + 2); RETURN_LONG(c); @@ -65,6 +67,7 @@ PHP_METHOD(Stub_Arithmetic, intSumSimple) { + c = 3; RETURN_LONG(c); @@ -77,6 +80,7 @@ PHP_METHOD(Stub_Arithmetic, boolSum) { + a = ((1) ? 1 : 0); b = ((2) ? 1 : 0); c = (a | b); @@ -91,6 +95,7 @@ PHP_METHOD(Stub_Arithmetic, bool2Sum) { + a = ((1) ? 1 : 0); c = (a + 2); RETURN_BOOL(c); @@ -104,6 +109,7 @@ PHP_METHOD(Stub_Arithmetic, bool3Sum) { + a = 1; c = (a | 0); RETURN_BOOL(c); @@ -117,6 +123,7 @@ PHP_METHOD(Stub_Arithmetic, boolSumSimple) { + c = ((3) ? 1 : 0); RETURN_BOOL(c); @@ -133,6 +140,7 @@ PHP_METHOD(Stub_Arithmetic, boolSumExpression) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); a = 1; @@ -150,6 +158,7 @@ PHP_METHOD(Stub_Arithmetic, doubleSum) { + a = (double) (1); b = (double) (2); c = (a + b); @@ -164,6 +173,7 @@ PHP_METHOD(Stub_Arithmetic, double2Sum) { + a = 1.0; b = 2.0; c = (a + b); @@ -178,6 +188,7 @@ PHP_METHOD(Stub_Arithmetic, doubleSumSimple) { + c = (double) (3); RETURN_DOUBLE(c); @@ -190,6 +201,7 @@ PHP_METHOD(Stub_Arithmetic, doubleSum2Simple) { + c = 3; RETURN_DOUBLE(c); @@ -205,6 +217,7 @@ PHP_METHOD(Stub_Arithmetic, doubleSumExpression) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, 0); @@ -225,6 +238,7 @@ PHP_METHOD(Stub_Arithmetic, doubleSumVarExpression) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); a = 1.0; @@ -242,6 +256,7 @@ PHP_METHOD(Stub_Arithmetic, varSum) { + a = 1; b = 2; c = (a + b); @@ -256,6 +271,7 @@ PHP_METHOD(Stub_Arithmetic, varSumSimple) { + c = 3; RETURN_LONG(c); @@ -269,6 +285,7 @@ PHP_METHOD(Stub_Arithmetic, intDoubleSum) { + a = (double) (1); b = 2; c = (long) ((a + (double) b)); @@ -283,6 +300,7 @@ PHP_METHOD(Stub_Arithmetic, intDoubleSumSimple) { + c = (long) (3); RETURN_LONG(c); @@ -296,6 +314,7 @@ PHP_METHOD(Stub_Arithmetic, doubleIntSum) { + a = (double) (1); b = 2; c = (a + (double) b); @@ -310,6 +329,7 @@ PHP_METHOD(Stub_Arithmetic, doubleIntSumSimple) { + c = 3; RETURN_DOUBLE(c); @@ -322,6 +342,7 @@ PHP_METHOD(Stub_Arithmetic, varIntSum) { + a = 1; b = 2; c = (a + b); @@ -336,6 +357,7 @@ PHP_METHOD(Stub_Arithmetic, intVarSum) { + a = 1; b = 2; c = (b + a); @@ -354,6 +376,7 @@ PHP_METHOD(Stub_Arithmetic, intVarImplicitCastSum) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -376,6 +399,7 @@ PHP_METHOD(Stub_Arithmetic, intVarImplicitCast2Sum) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -393,6 +417,7 @@ PHP_METHOD(Stub_Arithmetic, complexSum) { + c = 3; RETURN_DOUBLE(c); @@ -405,6 +430,7 @@ PHP_METHOD(Stub_Arithmetic, complex2Sum) { + c = (1 | 1); RETURN_BOOL(c); @@ -417,6 +443,7 @@ PHP_METHOD(Stub_Arithmetic, complex3Sum) { + c = (((1 + 1.0)) ? 1 : 0); RETURN_BOOL(c); @@ -430,6 +457,7 @@ PHP_METHOD(Stub_Arithmetic, complex4Sum) { ZVAL_UNDEF(&c); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&c); @@ -445,6 +473,7 @@ PHP_METHOD(Stub_Arithmetic, complex5Sum) { + c = (1 + 1); RETURN_LONG(c); @@ -457,6 +486,7 @@ PHP_METHOD(Stub_Arithmetic, complex6Sum) { + c = (((1 + 1)) ? 1 : 0); RETURN_BOOL(c); @@ -470,6 +500,7 @@ PHP_METHOD(Stub_Arithmetic, complex7Sum) { + a = ((1) ? 1 : 0); b = 2; c = (a + b); @@ -485,6 +516,7 @@ PHP_METHOD(Stub_Arithmetic, complex9Sum) { + a = ((1) ? 1 : 0); b = 2; c = (b + a); @@ -501,6 +533,7 @@ PHP_METHOD(Stub_Arithmetic, complex10Sum) { + a = ((1.0 != 0.0) ? 1 : 0); b = 2; c = (double) ((b + a)); @@ -517,6 +550,7 @@ PHP_METHOD(Stub_Arithmetic, complex11Sum) { + a = ((1) ? 1 : 0); b = (long) (2.0); c = (double) ((b + a)); @@ -532,6 +566,7 @@ PHP_METHOD(Stub_Arithmetic, complex12Sum) { + a = ((1) ? 1 : 0); b = (long) (2.0); c = (b + a); @@ -547,6 +582,7 @@ PHP_METHOD(Stub_Arithmetic, complex13Sum) { + a = ((1) ? 1 : 0); b = ((2.0 != 0.0) ? 1 : 0); c = (b | a); @@ -562,6 +598,7 @@ PHP_METHOD(Stub_Arithmetic, complex14Sum) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); c = (b + a); @@ -578,6 +615,7 @@ PHP_METHOD(Stub_Arithmetic, complex15Sum) { + a = 1; b = 2.0; c = (((b + (double) a) != 0.0) ? 1 : 0); @@ -593,6 +631,7 @@ PHP_METHOD(Stub_Arithmetic, complex16Sum) { + a = 1; b = 2.0; c = (b + (double) a); @@ -609,6 +648,7 @@ PHP_METHOD(Stub_Arithmetic, complex17Sum) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); c = (double) ((a + b)); @@ -625,6 +665,7 @@ PHP_METHOD(Stub_Arithmetic, complex18Sum) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a + b)); @@ -642,6 +683,7 @@ PHP_METHOD(Stub_Arithmetic, complex19Sum) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a + b)); @@ -659,6 +701,7 @@ PHP_METHOD(Stub_Arithmetic, complex20Sum) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a + b)); @@ -676,6 +719,7 @@ PHP_METHOD(Stub_Arithmetic, complex21Sum) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a + b)); @@ -692,6 +736,7 @@ PHP_METHOD(Stub_Arithmetic, complex22Sum) { + a = 1; b = (long) (2.0); d = (double) ((a + b)); @@ -709,6 +754,7 @@ PHP_METHOD(Stub_Arithmetic, complex23Sum) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a + b)); @@ -725,6 +771,7 @@ PHP_METHOD(Stub_Arithmetic, complex24Sum) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((((1 + a) + 0) + b)); @@ -739,6 +786,7 @@ PHP_METHOD(Stub_Arithmetic, addSum1) { + a = 0; a += 10; RETURN_LONG(a); @@ -752,6 +800,7 @@ PHP_METHOD(Stub_Arithmetic, addSum2) { + a = 0; a += 0; RETURN_LONG(a); @@ -765,6 +814,7 @@ PHP_METHOD(Stub_Arithmetic, addSum2b) { + a = 5; a += 0; RETURN_LONG(a); @@ -778,6 +828,7 @@ PHP_METHOD(Stub_Arithmetic, addSum3) { + a = 0; a += 1; RETURN_LONG(a); @@ -791,6 +842,7 @@ PHP_METHOD(Stub_Arithmetic, addSum4) { + a = 0; a += 0; RETURN_LONG(a); @@ -804,6 +856,7 @@ PHP_METHOD(Stub_Arithmetic, addSum5) { + a = 0; a += (long) (1.0); RETURN_LONG(a); @@ -817,6 +870,7 @@ PHP_METHOD(Stub_Arithmetic, addSum6) { + a = 0; a += (long) (1.0); RETURN_LONG(a); @@ -830,6 +884,7 @@ PHP_METHOD(Stub_Arithmetic, addSum7) { + a = 0.0; a += (double) (10); RETURN_DOUBLE(a); @@ -843,6 +898,7 @@ PHP_METHOD(Stub_Arithmetic, addSum8) { + a = 0.0; a += 0.0; RETURN_DOUBLE(a); @@ -856,6 +912,7 @@ PHP_METHOD(Stub_Arithmetic, addSum8b) { + a = 6.3; a += 0.0; RETURN_DOUBLE(a); @@ -869,6 +926,7 @@ PHP_METHOD(Stub_Arithmetic, addSum9) { + a = 0.0; a += 1; RETURN_DOUBLE(a); @@ -882,6 +940,7 @@ PHP_METHOD(Stub_Arithmetic, addSum10) { + a = 0.0; a += 0; RETURN_DOUBLE(a); @@ -895,6 +954,7 @@ PHP_METHOD(Stub_Arithmetic, addSum11) { + a = 0.0; a += 1.0; RETURN_DOUBLE(a); @@ -908,6 +968,7 @@ PHP_METHOD(Stub_Arithmetic, addSum12) { + a = 0; b = 10; a += b; @@ -923,6 +984,7 @@ PHP_METHOD(Stub_Arithmetic, addSum13) { + a = 0; b = 1; a += b; @@ -938,6 +1000,7 @@ PHP_METHOD(Stub_Arithmetic, addSum14) { + a = 0; b = 0; a += b; @@ -953,6 +1016,7 @@ PHP_METHOD(Stub_Arithmetic, addSum15) { + a = 0; b = 1.0; a += (long) b; @@ -967,6 +1031,7 @@ PHP_METHOD(Stub_Arithmetic, addSum16) { + a = 0.0; b = 10.0; a += b; @@ -982,6 +1047,7 @@ PHP_METHOD(Stub_Arithmetic, addSum17) { + a = 0.0; b = 1; a += (double) b; @@ -997,6 +1063,7 @@ PHP_METHOD(Stub_Arithmetic, addSum18) { + a = 0.0; b = 0; a += (double) b; @@ -1012,6 +1079,7 @@ PHP_METHOD(Stub_Arithmetic, addSum19) { + a = 0.0; b = 1; a += (double) b; @@ -1026,6 +1094,7 @@ PHP_METHOD(Stub_Arithmetic, addSum20) { + a = (long) (0.0); b = 1; a += b; @@ -1041,6 +1110,7 @@ PHP_METHOD(Stub_Arithmetic, addSum21) { + a = 0.0; b = 1; a += (double) b; @@ -1057,6 +1127,7 @@ PHP_METHOD(Stub_Arithmetic, addSum22) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1076,6 +1147,7 @@ PHP_METHOD(Stub_Arithmetic, addSum23) { + a = 1; a += 1024; RETURN_LONG(a); @@ -1090,6 +1162,14 @@ PHP_METHOD(Stub_Arithmetic, addSum24) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a); @@ -1112,6 +1192,7 @@ PHP_METHOD(Stub_Arithmetic, intSub) { + a = 1; b = 2; c = (a - b); @@ -1126,6 +1207,7 @@ PHP_METHOD(Stub_Arithmetic, intLetSub) { + c = 1; b = 2; c -= b; @@ -1140,6 +1222,7 @@ PHP_METHOD(Stub_Arithmetic, intSub2) { + a = 1; c = (a - 2); RETURN_LONG(c); @@ -1153,6 +1236,7 @@ PHP_METHOD(Stub_Arithmetic, intSubSimple) { + c = -1; RETURN_LONG(c); @@ -1165,6 +1249,7 @@ PHP_METHOD(Stub_Arithmetic, boolSub) { + a = ((1) ? 1 : 0); b = ((2) ? 1 : 0); c = (a & b); @@ -1179,6 +1264,7 @@ PHP_METHOD(Stub_Arithmetic, bool2Sub) { + a = ((1) ? 1 : 0); c = (a - 2); RETURN_BOOL(c); @@ -1192,6 +1278,7 @@ PHP_METHOD(Stub_Arithmetic, bool3Sub) { + a = 1; c = (a & 0); RETURN_BOOL(c); @@ -1205,6 +1292,7 @@ PHP_METHOD(Stub_Arithmetic, bool4Sub) { + a = 1; c = (a & 1); RETURN_BOOL(c); @@ -1218,6 +1306,7 @@ PHP_METHOD(Stub_Arithmetic, boolSubSimple) { + c = ((-1) ? 1 : 0); RETURN_BOOL(c); @@ -1230,6 +1319,7 @@ PHP_METHOD(Stub_Arithmetic, doubleSub) { + a = (double) (1); b = (double) (2); c = (a - b); @@ -1244,6 +1334,7 @@ PHP_METHOD(Stub_Arithmetic, double2Sub) { + a = 1.0; b = 2.0; c = (a - b); @@ -1258,6 +1349,7 @@ PHP_METHOD(Stub_Arithmetic, doubleSubSimple) { + c = (double) (-1); RETURN_DOUBLE(c); @@ -1270,6 +1362,7 @@ PHP_METHOD(Stub_Arithmetic, doubleSub2Simple) { + c = -1; RETURN_DOUBLE(c); @@ -1282,6 +1375,7 @@ PHP_METHOD(Stub_Arithmetic, varSub) { + a = 1; b = 2; c = (a - b); @@ -1296,6 +1390,7 @@ PHP_METHOD(Stub_Arithmetic, varSubSimple) { + c = -1; RETURN_LONG(c); @@ -1309,6 +1404,7 @@ PHP_METHOD(Stub_Arithmetic, intDoubleSub) { + a = (double) (1); b = 2; c = (long) ((a - (double) b)); @@ -1323,6 +1419,7 @@ PHP_METHOD(Stub_Arithmetic, intDoubleSubSimple) { + c = (long) (-1); RETURN_LONG(c); @@ -1336,6 +1433,7 @@ PHP_METHOD(Stub_Arithmetic, doubleIntSub) { + a = (double) (1); b = 2; c = (a - (double) b); @@ -1350,6 +1448,7 @@ PHP_METHOD(Stub_Arithmetic, doubleIntSubSimple) { + c = -1; RETURN_DOUBLE(c); @@ -1362,6 +1461,7 @@ PHP_METHOD(Stub_Arithmetic, varIntSub) { + a = 1; b = 2; c = (a - b); @@ -1376,6 +1476,7 @@ PHP_METHOD(Stub_Arithmetic, intVarSub) { + a = 1; b = 2; c = (b - a); @@ -1394,6 +1495,7 @@ PHP_METHOD(Stub_Arithmetic, intVarImplicitCastSub) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1416,6 +1518,7 @@ PHP_METHOD(Stub_Arithmetic, intVarImplicitCast2Sub) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1433,6 +1536,7 @@ PHP_METHOD(Stub_Arithmetic, complexSub) { + c = 1; RETURN_DOUBLE(c); @@ -1445,6 +1549,7 @@ PHP_METHOD(Stub_Arithmetic, complex2Sub) { + c = (1 & 1); RETURN_BOOL(c); @@ -1457,6 +1562,7 @@ PHP_METHOD(Stub_Arithmetic, complex3Sub) { + c = (((1 + 1.0)) ? 1 : 0); RETURN_BOOL(c); @@ -1470,6 +1576,7 @@ PHP_METHOD(Stub_Arithmetic, complex4Sub) { ZVAL_UNDEF(&c); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&c); @@ -1485,6 +1592,7 @@ PHP_METHOD(Stub_Arithmetic, complex5Sub) { + c = (1 - 1); RETURN_LONG(c); @@ -1497,6 +1605,7 @@ PHP_METHOD(Stub_Arithmetic, complex6Sub) { + c = (((1 + 1)) ? 1 : 0); RETURN_BOOL(c); @@ -1510,6 +1619,7 @@ PHP_METHOD(Stub_Arithmetic, complex7Sub) { + a = ((1) ? 1 : 0); b = 2; c = (a - b); @@ -1525,6 +1635,7 @@ PHP_METHOD(Stub_Arithmetic, complex9Sub) { + a = ((1) ? 1 : 0); b = 2; c = (b - a); @@ -1541,6 +1652,7 @@ PHP_METHOD(Stub_Arithmetic, complex10Sub) { + a = ((1.0 != 0.0) ? 1 : 0); b = 2; c = (double) ((b - a)); @@ -1557,6 +1669,7 @@ PHP_METHOD(Stub_Arithmetic, complex11Sub) { + a = ((1) ? 1 : 0); b = (long) (2.0); c = (double) ((b - a)); @@ -1572,6 +1685,7 @@ PHP_METHOD(Stub_Arithmetic, complex12Sub) { + a = ((1) ? 1 : 0); b = (long) (2.0); c = (b - a); @@ -1587,6 +1701,7 @@ PHP_METHOD(Stub_Arithmetic, complex13Sub) { + a = ((1) ? 1 : 0); b = ((2.0 != 0.0) ? 1 : 0); c = (b & a); @@ -1602,6 +1717,7 @@ PHP_METHOD(Stub_Arithmetic, complex14Sub) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); c = (b - a); @@ -1618,6 +1734,7 @@ PHP_METHOD(Stub_Arithmetic, complex15Sub) { + a = 1; b = 2.0; c = (((b - (double) a) != 0.0) ? 1 : 0); @@ -1633,6 +1750,7 @@ PHP_METHOD(Stub_Arithmetic, complex16Sub) { + a = 1; b = 2.0; c = (b - (double) a); @@ -1649,6 +1767,7 @@ PHP_METHOD(Stub_Arithmetic, complex17Sub) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); c = (double) ((a - b)); @@ -1665,6 +1784,7 @@ PHP_METHOD(Stub_Arithmetic, complex18Sub) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a - b)); @@ -1682,6 +1802,7 @@ PHP_METHOD(Stub_Arithmetic, complex19Sub) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a - b)); @@ -1699,6 +1820,7 @@ PHP_METHOD(Stub_Arithmetic, complex20Sub) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a - b)); @@ -1716,6 +1838,7 @@ PHP_METHOD(Stub_Arithmetic, complex21Sub) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a - b)); @@ -1732,6 +1855,7 @@ PHP_METHOD(Stub_Arithmetic, complex22Sub) { + a = 1; b = (long) (2.0); d = (double) ((a - b)); @@ -1749,6 +1873,7 @@ PHP_METHOD(Stub_Arithmetic, complex23Sub) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a - b)); @@ -1765,6 +1890,7 @@ PHP_METHOD(Stub_Arithmetic, complex24Sub) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((((1 - a) - 0) - b)); @@ -1779,6 +1905,7 @@ PHP_METHOD(Stub_Arithmetic, sub1) { + a = 0; a -= 10; RETURN_LONG(a); @@ -1792,6 +1919,7 @@ PHP_METHOD(Stub_Arithmetic, sub2) { + a = 0; a -= 0; RETURN_LONG(a); @@ -1805,6 +1933,7 @@ PHP_METHOD(Stub_Arithmetic, sub2b) { + a = 5; a -= 0; RETURN_LONG(a); @@ -1818,6 +1947,7 @@ PHP_METHOD(Stub_Arithmetic, sub3) { + a = 0; a -= 1; RETURN_LONG(a); @@ -1831,6 +1961,7 @@ PHP_METHOD(Stub_Arithmetic, sub4) { + a = 0; a -= 0; RETURN_LONG(a); @@ -1844,6 +1975,7 @@ PHP_METHOD(Stub_Arithmetic, sub5) { + a = 0; a -= (long) (1.0); RETURN_LONG(a); @@ -1857,6 +1989,7 @@ PHP_METHOD(Stub_Arithmetic, sub6) { + a = 0; a -= (long) (1.0); RETURN_LONG(a); @@ -1870,6 +2003,7 @@ PHP_METHOD(Stub_Arithmetic, sub7) { + a = 0.0; a -= (double) (10); RETURN_DOUBLE(a); @@ -1883,6 +2017,7 @@ PHP_METHOD(Stub_Arithmetic, sub8) { + a = 0.0; a -= 0.0; RETURN_DOUBLE(a); @@ -1896,6 +2031,7 @@ PHP_METHOD(Stub_Arithmetic, sub8b) { + a = 6.3; a -= 0.0; RETURN_DOUBLE(a); @@ -1909,6 +2045,7 @@ PHP_METHOD(Stub_Arithmetic, sub9) { + a = 0.0; a -= 1; RETURN_DOUBLE(a); @@ -1922,6 +2059,7 @@ PHP_METHOD(Stub_Arithmetic, sub10) { + a = 0.0; a -= 0; RETURN_DOUBLE(a); @@ -1935,6 +2073,7 @@ PHP_METHOD(Stub_Arithmetic, sub11) { + a = 0.0; a -= 1.0; RETURN_DOUBLE(a); @@ -1948,6 +2087,7 @@ PHP_METHOD(Stub_Arithmetic, sub12) { + a = 0; b = 10; a -= b; @@ -1963,6 +2103,7 @@ PHP_METHOD(Stub_Arithmetic, sub13) { + a = 0; b = 1; a -= b; @@ -1978,6 +2119,7 @@ PHP_METHOD(Stub_Arithmetic, sub14) { + a = 0; b = 0; a -= b; @@ -1993,6 +2135,7 @@ PHP_METHOD(Stub_Arithmetic, sub15) { + a = 0; b = 1.0; a -= (long) b; @@ -2007,6 +2150,7 @@ PHP_METHOD(Stub_Arithmetic, sub16) { + a = 0.0; b = 10.0; a -= b; @@ -2022,6 +2166,7 @@ PHP_METHOD(Stub_Arithmetic, sub17) { + a = 0.0; b = 1; a -= (double) b; @@ -2037,6 +2182,7 @@ PHP_METHOD(Stub_Arithmetic, sub18) { + a = 0.0; b = 0; a -= (double) b; @@ -2052,6 +2198,7 @@ PHP_METHOD(Stub_Arithmetic, sub19) { + a = 0.0; b = 1; a -= (double) b; @@ -2066,6 +2213,7 @@ PHP_METHOD(Stub_Arithmetic, sub20) { + a = (long) (0.0); b = 1; a -= b; @@ -2081,6 +2229,7 @@ PHP_METHOD(Stub_Arithmetic, sub21) { + a = 0.0; b = 1; a -= (double) b; @@ -2097,6 +2246,7 @@ PHP_METHOD(Stub_Arithmetic, sub22) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -2116,6 +2266,7 @@ PHP_METHOD(Stub_Arithmetic, sub23) { + a = 1; a -= 1024; RETURN_LONG(a); @@ -2130,6 +2281,14 @@ PHP_METHOD(Stub_Arithmetic, sub24) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a); @@ -2152,6 +2311,7 @@ PHP_METHOD(Stub_Arithmetic, mul1) { + a = 1; a *= 5; RETURN_LONG(a); @@ -2166,6 +2326,14 @@ PHP_METHOD(Stub_Arithmetic, mul2) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a); @@ -2188,6 +2356,7 @@ PHP_METHOD(Stub_Arithmetic, mul3) { + a = 1; a *= 1024; RETURN_LONG(a); @@ -2201,6 +2370,7 @@ PHP_METHOD(Stub_Arithmetic, less1) { + a = 1; b = 2; RETURN_BOOL(a < b); @@ -2214,6 +2384,7 @@ PHP_METHOD(Stub_Arithmetic, less2) { + a = 2; b = 1; RETURN_BOOL(a < b); @@ -2226,6 +2397,14 @@ PHP_METHOD(Stub_Arithmetic, less3) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -2241,6 +2420,14 @@ PHP_METHOD(Stub_Arithmetic, less4) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -2257,6 +2444,7 @@ PHP_METHOD(Stub_Arithmetic, greater1) { + a = 1; b = 2; RETURN_BOOL(a > b); @@ -2270,6 +2458,7 @@ PHP_METHOD(Stub_Arithmetic, greater2) { + a = 2; b = 1; RETURN_BOOL(a > b); @@ -2282,6 +2471,14 @@ PHP_METHOD(Stub_Arithmetic, greater3) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -2297,6 +2494,14 @@ PHP_METHOD(Stub_Arithmetic, greater4) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -2313,6 +2518,7 @@ PHP_METHOD(Stub_Arithmetic, letStatementIntMinus) { + a = -1; RETURN_LONG(a); @@ -2325,6 +2531,7 @@ PHP_METHOD(Stub_Arithmetic, declaredIntMinus) { + a = -1; RETURN_LONG(a); @@ -2340,6 +2547,14 @@ PHP_METHOD(Stub_Arithmetic, letStatementBoolMinus) { zval *this_ptr = getThis(); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &b); @@ -2359,6 +2574,14 @@ PHP_METHOD(Stub_Arithmetic, letStatementVarMinus) { ZVAL_UNDEF(&b_sub); ZVAL_UNDEF(&a); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &b); @@ -2378,6 +2601,7 @@ PHP_METHOD(Stub_Arithmetic, div1) { + a = 100; RETURN_DOUBLE(zephir_safe_div_long_long(((a - 1)), 4)); @@ -2391,6 +2615,7 @@ PHP_METHOD(Stub_Arithmetic, div2) { ZVAL_UNDEF(&_0); + zephir_read_property(&_0, this_ptr, ZEND_STRL("tmp1"), PH_NOISY_CC | PH_READONLY); RETURN_DOUBLE(zephir_safe_div_long_long(((zephir_get_numberval(&_0) - 1)), 4)); diff --git a/ext/stub/arithmetic.zep.h b/ext/stub/arithmetic.zep.h index 3106fa4826..728a60a683 100644 --- a/ext/stub/arithmetic.zep.h +++ b/ext/stub/arithmetic.zep.h @@ -662,167 +662,779 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_arithmetic_div2, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_arithmetic_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intSum, arginfo_stub_arithmetic_intsum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intSum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, int2Sum, arginfo_stub_arithmetic_int2sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, int2Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intSumSimple, arginfo_stub_arithmetic_intsumsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intSumSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, boolSum, arginfo_stub_arithmetic_boolsum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, boolSum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, bool2Sum, arginfo_stub_arithmetic_bool2sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, bool2Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, bool3Sum, arginfo_stub_arithmetic_bool3sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, bool3Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, boolSumSimple, arginfo_stub_arithmetic_boolsumsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, boolSumSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, boolSumExpression, arginfo_stub_arithmetic_boolsumexpression, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, boolSumExpression, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleSum, arginfo_stub_arithmetic_doublesum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleSum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, double2Sum, arginfo_stub_arithmetic_double2sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, double2Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleSumSimple, arginfo_stub_arithmetic_doublesumsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleSumSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleSum2Simple, arginfo_stub_arithmetic_doublesum2simple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleSum2Simple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleSumExpression, arginfo_stub_arithmetic_doublesumexpression, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleSumExpression, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleSumVarExpression, arginfo_stub_arithmetic_doublesumvarexpression, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleSumVarExpression, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, varSum, arginfo_stub_arithmetic_varsum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, varSum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, varSumSimple, arginfo_stub_arithmetic_varsumsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, varSumSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intDoubleSum, arginfo_stub_arithmetic_intdoublesum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intDoubleSum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intDoubleSumSimple, arginfo_stub_arithmetic_intdoublesumsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intDoubleSumSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleIntSum, arginfo_stub_arithmetic_doubleintsum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleIntSum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleIntSumSimple, arginfo_stub_arithmetic_doubleintsumsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleIntSumSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, varIntSum, arginfo_stub_arithmetic_varintsum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, varIntSum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intVarSum, arginfo_stub_arithmetic_intvarsum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intVarSum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intVarImplicitCastSum, arginfo_stub_arithmetic_intvarimplicitcastsum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intVarImplicitCastSum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intVarImplicitCast2Sum, arginfo_stub_arithmetic_intvarimplicitcast2sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intVarImplicitCast2Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complexSum, arginfo_stub_arithmetic_complexsum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complexSum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex2Sum, arginfo_stub_arithmetic_complex2sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex2Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex3Sum, arginfo_stub_arithmetic_complex3sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex3Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex4Sum, arginfo_stub_arithmetic_complex4sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex4Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex5Sum, arginfo_stub_arithmetic_complex5sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex5Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex6Sum, arginfo_stub_arithmetic_complex6sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex6Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex7Sum, arginfo_stub_arithmetic_complex7sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex7Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex9Sum, arginfo_stub_arithmetic_complex9sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex9Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex10Sum, arginfo_stub_arithmetic_complex10sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex10Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex11Sum, arginfo_stub_arithmetic_complex11sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex11Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex12Sum, arginfo_stub_arithmetic_complex12sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex12Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex13Sum, arginfo_stub_arithmetic_complex13sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex13Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex14Sum, arginfo_stub_arithmetic_complex14sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex14Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex15Sum, arginfo_stub_arithmetic_complex15sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex15Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex16Sum, arginfo_stub_arithmetic_complex16sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex16Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex17Sum, arginfo_stub_arithmetic_complex17sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex17Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex18Sum, arginfo_stub_arithmetic_complex18sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex18Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex19Sum, arginfo_stub_arithmetic_complex19sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex19Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex20Sum, arginfo_stub_arithmetic_complex20sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex20Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex21Sum, arginfo_stub_arithmetic_complex21sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex21Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex22Sum, arginfo_stub_arithmetic_complex22sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex22Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex23Sum, arginfo_stub_arithmetic_complex23sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex23Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex24Sum, arginfo_stub_arithmetic_complex24sum, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex24Sum, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum1, arginfo_stub_arithmetic_addsum1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum2, arginfo_stub_arithmetic_addsum2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum2b, arginfo_stub_arithmetic_addsum2b, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum2b, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum3, arginfo_stub_arithmetic_addsum3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum4, arginfo_stub_arithmetic_addsum4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum5, arginfo_stub_arithmetic_addsum5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum6, arginfo_stub_arithmetic_addsum6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum7, arginfo_stub_arithmetic_addsum7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum7, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum8, arginfo_stub_arithmetic_addsum8, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum8, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum8b, arginfo_stub_arithmetic_addsum8b, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum8b, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum9, arginfo_stub_arithmetic_addsum9, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum9, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum10, arginfo_stub_arithmetic_addsum10, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum10, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum11, arginfo_stub_arithmetic_addsum11, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum11, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum12, arginfo_stub_arithmetic_addsum12, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum12, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum13, arginfo_stub_arithmetic_addsum13, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum13, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum14, arginfo_stub_arithmetic_addsum14, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum14, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum15, arginfo_stub_arithmetic_addsum15, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum15, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum16, arginfo_stub_arithmetic_addsum16, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum16, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum17, arginfo_stub_arithmetic_addsum17, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum17, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum18, arginfo_stub_arithmetic_addsum18, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum18, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum19, arginfo_stub_arithmetic_addsum19, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum19, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum20, arginfo_stub_arithmetic_addsum20, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum20, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum21, arginfo_stub_arithmetic_addsum21, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum21, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum22, arginfo_stub_arithmetic_addsum22, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum22, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, addSum23, arginfo_stub_arithmetic_addsum23, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, addSum23, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Arithmetic, addSum24, arginfo_stub_arithmetic_addsum24, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intSub, arginfo_stub_arithmetic_intsub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intSub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intLetSub, arginfo_stub_arithmetic_intletsub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intLetSub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intSub2, arginfo_stub_arithmetic_intsub2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intSub2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intSubSimple, arginfo_stub_arithmetic_intsubsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intSubSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, boolSub, arginfo_stub_arithmetic_boolsub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, boolSub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, bool2Sub, arginfo_stub_arithmetic_bool2sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, bool2Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, bool3Sub, arginfo_stub_arithmetic_bool3sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, bool3Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, bool4Sub, arginfo_stub_arithmetic_bool4sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, bool4Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, boolSubSimple, arginfo_stub_arithmetic_boolsubsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, boolSubSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleSub, arginfo_stub_arithmetic_doublesub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleSub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, double2Sub, arginfo_stub_arithmetic_double2sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, double2Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleSubSimple, arginfo_stub_arithmetic_doublesubsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleSubSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleSub2Simple, arginfo_stub_arithmetic_doublesub2simple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleSub2Simple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, varSub, arginfo_stub_arithmetic_varsub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, varSub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, varSubSimple, arginfo_stub_arithmetic_varsubsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, varSubSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intDoubleSub, arginfo_stub_arithmetic_intdoublesub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intDoubleSub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intDoubleSubSimple, arginfo_stub_arithmetic_intdoublesubsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intDoubleSubSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleIntSub, arginfo_stub_arithmetic_doubleintsub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleIntSub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, doubleIntSubSimple, arginfo_stub_arithmetic_doubleintsubsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, doubleIntSubSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, varIntSub, arginfo_stub_arithmetic_varintsub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, varIntSub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intVarSub, arginfo_stub_arithmetic_intvarsub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intVarSub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intVarImplicitCastSub, arginfo_stub_arithmetic_intvarimplicitcastsub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intVarImplicitCastSub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, intVarImplicitCast2Sub, arginfo_stub_arithmetic_intvarimplicitcast2sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, intVarImplicitCast2Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complexSub, arginfo_stub_arithmetic_complexsub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complexSub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex2Sub, arginfo_stub_arithmetic_complex2sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex2Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex3Sub, arginfo_stub_arithmetic_complex3sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex3Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex4Sub, arginfo_stub_arithmetic_complex4sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex4Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex5Sub, arginfo_stub_arithmetic_complex5sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex5Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex6Sub, arginfo_stub_arithmetic_complex6sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex6Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex7Sub, arginfo_stub_arithmetic_complex7sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex7Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex9Sub, arginfo_stub_arithmetic_complex9sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex9Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex10Sub, arginfo_stub_arithmetic_complex10sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex10Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex11Sub, arginfo_stub_arithmetic_complex11sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex11Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex12Sub, arginfo_stub_arithmetic_complex12sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex12Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex13Sub, arginfo_stub_arithmetic_complex13sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex13Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex14Sub, arginfo_stub_arithmetic_complex14sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex14Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex15Sub, arginfo_stub_arithmetic_complex15sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex15Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex16Sub, arginfo_stub_arithmetic_complex16sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex16Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex17Sub, arginfo_stub_arithmetic_complex17sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex17Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex18Sub, arginfo_stub_arithmetic_complex18sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex18Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex19Sub, arginfo_stub_arithmetic_complex19sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex19Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex20Sub, arginfo_stub_arithmetic_complex20sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex20Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex21Sub, arginfo_stub_arithmetic_complex21sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex21Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex22Sub, arginfo_stub_arithmetic_complex22sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex22Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex23Sub, arginfo_stub_arithmetic_complex23sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex23Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, complex24Sub, arginfo_stub_arithmetic_complex24sub, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, complex24Sub, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub1, arginfo_stub_arithmetic_sub1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub2, arginfo_stub_arithmetic_sub2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub2b, arginfo_stub_arithmetic_sub2b, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub2b, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub3, arginfo_stub_arithmetic_sub3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub4, arginfo_stub_arithmetic_sub4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub5, arginfo_stub_arithmetic_sub5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub6, arginfo_stub_arithmetic_sub6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub7, arginfo_stub_arithmetic_sub7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub7, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub8, arginfo_stub_arithmetic_sub8, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub8, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub8b, arginfo_stub_arithmetic_sub8b, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub8b, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub9, arginfo_stub_arithmetic_sub9, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub9, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub10, arginfo_stub_arithmetic_sub10, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub10, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub11, arginfo_stub_arithmetic_sub11, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub11, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub12, arginfo_stub_arithmetic_sub12, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub12, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub13, arginfo_stub_arithmetic_sub13, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub13, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub14, arginfo_stub_arithmetic_sub14, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub14, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub15, arginfo_stub_arithmetic_sub15, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub15, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub16, arginfo_stub_arithmetic_sub16, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub16, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub17, arginfo_stub_arithmetic_sub17, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub17, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub18, arginfo_stub_arithmetic_sub18, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub18, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub19, arginfo_stub_arithmetic_sub19, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub19, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub20, arginfo_stub_arithmetic_sub20, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub20, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub21, arginfo_stub_arithmetic_sub21, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub21, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub22, arginfo_stub_arithmetic_sub22, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub22, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, sub23, arginfo_stub_arithmetic_sub23, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, sub23, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Arithmetic, sub24, arginfo_stub_arithmetic_sub24, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, mul1, arginfo_stub_arithmetic_mul1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, mul1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Arithmetic, mul2, arginfo_stub_arithmetic_mul2, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, mul3, arginfo_stub_arithmetic_mul3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, mul3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, less1, arginfo_stub_arithmetic_less1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, less1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, less2, arginfo_stub_arithmetic_less2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, less2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Arithmetic, less3, arginfo_stub_arithmetic_less3, ZEND_ACC_PUBLIC) PHP_ME(Stub_Arithmetic, less4, arginfo_stub_arithmetic_less4, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, greater1, arginfo_stub_arithmetic_greater1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, greater1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, greater2, arginfo_stub_arithmetic_greater2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, greater2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Arithmetic, greater3, arginfo_stub_arithmetic_greater3, ZEND_ACC_PUBLIC) PHP_ME(Stub_Arithmetic, greater4, arginfo_stub_arithmetic_greater4, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, letStatementIntMinus, arginfo_stub_arithmetic_letstatementintminus, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, letStatementIntMinus, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, declaredIntMinus, arginfo_stub_arithmetic_declaredintminus, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, declaredIntMinus, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Arithmetic, letStatementBoolMinus, arginfo_stub_arithmetic_letstatementboolminus, ZEND_ACC_PUBLIC) PHP_ME(Stub_Arithmetic, letStatementVarMinus, arginfo_stub_arithmetic_letstatementvarminus, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, div1, arginfo_stub_arithmetic_div1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, div1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Arithmetic, div2, arginfo_stub_arithmetic_div2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Arithmetic, div2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/arrayaccessobj.zep.c b/ext/stub/arrayaccessobj.zep.c index 35affe7c55..2c62174bc6 100644 --- a/ext/stub/arrayaccessobj.zep.c +++ b/ext/stub/arrayaccessobj.zep.c @@ -36,6 +36,7 @@ PHP_METHOD(Stub_ArrayAccessObj, __construct) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -55,6 +56,15 @@ PHP_METHOD(Stub_ArrayAccessObj, offsetSet) { ZVAL_UNDEF(&offset_sub); ZVAL_UNDEF(&value_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(offset) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &offset, &value); @@ -75,6 +85,14 @@ PHP_METHOD(Stub_ArrayAccessObj, offsetExists) { ZVAL_UNDEF(&offset_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(offset) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &offset); @@ -92,6 +110,14 @@ PHP_METHOD(Stub_ArrayAccessObj, offsetUnset) { ZVAL_UNDEF(&offset_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(offset) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &offset); @@ -112,6 +138,14 @@ PHP_METHOD(Stub_ArrayAccessObj, offsetGet) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(offset) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &offset); diff --git a/ext/stub/arrayaccessobj.zep.h b/ext/stub/arrayaccessobj.zep.h index 13b2846205..874fa613ef 100644 --- a/ext/stub/arrayaccessobj.zep.h +++ b/ext/stub/arrayaccessobj.zep.h @@ -30,7 +30,11 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_arrayaccessobj_offsetget, 0, 0, 1) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_arrayaccessobj_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ArrayAccessObj, __construct, arginfo_stub_arrayaccessobj___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#else + PHP_ME(Stub_ArrayAccessObj, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#endif PHP_ME(Stub_ArrayAccessObj, offsetSet, arginfo_stub_arrayaccessobj_offsetset, ZEND_ACC_PUBLIC) PHP_ME(Stub_ArrayAccessObj, offsetExists, arginfo_stub_arrayaccessobj_offsetexists, ZEND_ACC_PUBLIC) PHP_ME(Stub_ArrayAccessObj, offsetUnset, arginfo_stub_arrayaccessobj_offsetunset, ZEND_ACC_PUBLIC) diff --git a/ext/stub/arrayaccesstest.zep.c b/ext/stub/arrayaccesstest.zep.c index a07269ab1f..739f17841f 100644 --- a/ext/stub/arrayaccesstest.zep.c +++ b/ext/stub/arrayaccesstest.zep.c @@ -35,6 +35,7 @@ PHP_METHOD(Stub_ArrayAccessTest, exits) { ZVAL_UNDEF(&arr); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&arr); @@ -55,6 +56,7 @@ PHP_METHOD(Stub_ArrayAccessTest, get) { ZVAL_UNDEF(&arr); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&arr); diff --git a/ext/stub/arrayaccesstest.zep.h b/ext/stub/arrayaccesstest.zep.h index 16374e2cdc..ddba5c0642 100644 --- a/ext/stub/arrayaccesstest.zep.h +++ b/ext/stub/arrayaccesstest.zep.h @@ -13,7 +13,15 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_arrayaccesstest_get, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_arrayaccesstest_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ArrayAccessTest, exits, arginfo_stub_arrayaccesstest_exits, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_ArrayAccessTest, exits, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ArrayAccessTest, get, arginfo_stub_arrayaccesstest_get, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_ArrayAccessTest, get, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif PHP_FE_END }; diff --git a/ext/stub/arrayiterator.zep.c b/ext/stub/arrayiterator.zep.c index cee129c154..22763da481 100644 --- a/ext/stub/arrayiterator.zep.c +++ b/ext/stub/arrayiterator.zep.c @@ -41,6 +41,7 @@ PHP_METHOD(Stub_ArrayIterator, __construct) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -70,6 +71,7 @@ PHP_METHOD(Stub_ArrayIterator, rewind) { ZVAL_UNDEF(&_0); + ZEPHIR_INIT_ZVAL_NREF(_0); ZVAL_LONG(&_0, 0); zephir_update_property_zval(this_ptr, ZEND_STRL("position"), &_0); @@ -86,6 +88,7 @@ PHP_METHOD(Stub_ArrayIterator, current) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); zephir_read_property(&_0, this_ptr, ZEND_STRL("test"), PH_NOISY_CC | PH_READONLY); @@ -101,6 +104,7 @@ PHP_METHOD(Stub_ArrayIterator, key) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "position"); } @@ -110,6 +114,7 @@ PHP_METHOD(Stub_ArrayIterator, next) { zval *this_ptr = getThis(); + RETURN_ON_FAILURE(zephir_property_incr(this_ptr, SL("position"))); } @@ -123,6 +128,7 @@ PHP_METHOD(Stub_ArrayIterator, valid) { ZVAL_UNDEF(&_1); + zephir_read_property(&_0, this_ptr, ZEND_STRL("test"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_1, this_ptr, ZEND_STRL("position"), PH_NOISY_CC | PH_READONLY); RETURN_BOOL(zephir_array_isset(&_0, &_1)); diff --git a/ext/stub/arrayiterator.zep.h b/ext/stub/arrayiterator.zep.h index 8a92bd956a..ff88eff86f 100644 --- a/ext/stub/arrayiterator.zep.h +++ b/ext/stub/arrayiterator.zep.h @@ -29,11 +29,35 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_arrayiterator_valid, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_arrayiterator_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ArrayIterator, __construct, arginfo_stub_arrayiterator___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#else + PHP_ME(Stub_ArrayIterator, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ArrayIterator, rewind, arginfo_stub_arrayiterator_rewind, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ArrayIterator, rewind, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ArrayIterator, current, arginfo_stub_arrayiterator_current, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ArrayIterator, current, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ArrayIterator, key, arginfo_stub_arrayiterator_key, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ArrayIterator, key, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ArrayIterator, next, arginfo_stub_arrayiterator_next, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ArrayIterator, next, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ArrayIterator, valid, arginfo_stub_arrayiterator_valid, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ArrayIterator, valid, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/arrayiteratortest.zep.c b/ext/stub/arrayiteratortest.zep.c index d5fde0d345..1c7d90ca81 100644 --- a/ext/stub/arrayiteratortest.zep.c +++ b/ext/stub/arrayiteratortest.zep.c @@ -40,6 +40,7 @@ PHP_METHOD(Stub_ArrayIteratorTest, test) { ZVAL_UNDEF(&v); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&arr); diff --git a/ext/stub/arrayiteratortest.zep.h b/ext/stub/arrayiteratortest.zep.h index 50ce7fe1f9..033327a2d3 100644 --- a/ext/stub/arrayiteratortest.zep.h +++ b/ext/stub/arrayiteratortest.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_arrayiteratortest_test, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_arrayiteratortest_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ArrayIteratorTest, test, arginfo_stub_arrayiteratortest_test, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_ArrayIteratorTest, test, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif PHP_FE_END }; diff --git a/ext/stub/arraysearch.zep.c b/ext/stub/arraysearch.zep.c index d41f7d2af1..8f0f69b33c 100644 --- a/ext/stub/arraysearch.zep.c +++ b/ext/stub/arraysearch.zep.c @@ -40,6 +40,17 @@ PHP_METHOD(Stub_ArraySearch, simpleSearch) { ZVAL_UNDEF(&needle_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&haystack); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 3) + Z_PARAM_ZVAL(needle) + Z_PARAM_ARRAY(haystack) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(strict) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 1, &needle, &haystack_param, &strict_param); @@ -72,6 +83,7 @@ PHP_METHOD(Stub_ArraySearch, searchUsingArrayInsideZephir) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&pos); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&itoA64); diff --git a/ext/stub/arraysearch.zep.h b/ext/stub/arraysearch.zep.h index 04582ff2ce..d34e1d8511 100644 --- a/ext/stub/arraysearch.zep.h +++ b/ext/stub/arraysearch.zep.h @@ -9,11 +9,7 @@ PHP_METHOD(Stub_ArraySearch, searchUsingArrayInsideZephir); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_arraysearch_simplesearch, 0, 0, 2) ZEND_ARG_INFO(0, needle) ZEND_ARG_ARRAY_INFO(0, haystack, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, strict, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, strict) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_arraysearch_searchusingarrayinsidezephir, 0, 0, 0) @@ -21,6 +17,10 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_arraysearch_method_entry) { PHP_ME(Stub_ArraySearch, simpleSearch, arginfo_stub_arraysearch_simplesearch, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ArraySearch, searchUsingArrayInsideZephir, arginfo_stub_arraysearch_searchusingarrayinsidezephir, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ArraySearch, searchUsingArrayInsideZephir, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/assign.zep.c b/ext/stub/assign.zep.c index 011a16b369..cd009f3de8 100644 --- a/ext/stub/assign.zep.c +++ b/ext/stub/assign.zep.c @@ -40,6 +40,7 @@ PHP_METHOD(Stub_Assign, getTestVar) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "testVar"); } @@ -49,6 +50,7 @@ PHP_METHOD(Stub_Assign, getMyArray) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "myArray"); } @@ -60,6 +62,7 @@ PHP_METHOD(Stub_Assign, testAssign1) { + a = 1; RETURN_LONG(a); @@ -72,6 +75,7 @@ PHP_METHOD(Stub_Assign, testAssign2) { + a = 1; RETURN_LONG(a); @@ -84,6 +88,7 @@ PHP_METHOD(Stub_Assign, testAssign3) { + a = 0; RETURN_LONG(a); @@ -96,6 +101,7 @@ PHP_METHOD(Stub_Assign, testAssign4) { + a = 0; RETURN_LONG(a); @@ -108,6 +114,7 @@ PHP_METHOD(Stub_Assign, testAssign5) { + a = (long) (2.0); RETURN_LONG(a); @@ -120,6 +127,7 @@ PHP_METHOD(Stub_Assign, testAssign6) { + a = ((1) ? 1 : 0); RETURN_BOOL(a); @@ -132,6 +140,7 @@ PHP_METHOD(Stub_Assign, testAssign7) { + a = ((1.0 != 0.0) ? 1 : 0); RETURN_BOOL(a); @@ -144,6 +153,7 @@ PHP_METHOD(Stub_Assign, testAssign8) { + a = 1; RETURN_BOOL(a); @@ -156,6 +166,7 @@ PHP_METHOD(Stub_Assign, testAssign9) { + a = 0; RETURN_BOOL(a); @@ -168,6 +179,7 @@ PHP_METHOD(Stub_Assign, testAssign10) { + a = 0; RETURN_BOOL(a); @@ -180,6 +192,7 @@ PHP_METHOD(Stub_Assign, testAssign11) { + a = 0.0; RETURN_DOUBLE(a); @@ -192,6 +205,7 @@ PHP_METHOD(Stub_Assign, testAssign12) { + a = (double) (4); RETURN_DOUBLE(a); @@ -204,6 +218,7 @@ PHP_METHOD(Stub_Assign, testAssign13) { + a = 0; RETURN_DOUBLE(a); @@ -216,6 +231,7 @@ PHP_METHOD(Stub_Assign, testAssign14) { + a = 1; RETURN_DOUBLE(a); @@ -228,6 +244,7 @@ PHP_METHOD(Stub_Assign, testAssign15) { + a = 5.0; RETURN_DOUBLE(a); @@ -240,6 +257,7 @@ PHP_METHOD(Stub_Assign, testAssign16) { + a = 1; RETURN_LONG(a); @@ -252,6 +270,7 @@ PHP_METHOD(Stub_Assign, testAssign17) { + a = 1.0; RETURN_DOUBLE(a); @@ -264,6 +283,7 @@ PHP_METHOD(Stub_Assign, testAssign18) { + a = 0; RETURN_BOOL(a); @@ -276,6 +296,7 @@ PHP_METHOD(Stub_Assign, testAssign19) { + a = 1; RETURN_BOOL(a); @@ -289,6 +310,7 @@ PHP_METHOD(Stub_Assign, testAssign20) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -304,6 +326,7 @@ PHP_METHOD(Stub_Assign, testAssign21) { + a = 1; b = a; RETURN_LONG(b); @@ -317,6 +340,7 @@ PHP_METHOD(Stub_Assign, testAssign22) { + a = 1.0; b = a; RETURN_DOUBLE(b); @@ -330,6 +354,7 @@ PHP_METHOD(Stub_Assign, testAssign23) { + a = 1; b = a; RETURN_BOOL(b); @@ -344,6 +369,7 @@ PHP_METHOD(Stub_Assign, testAssign24) { + a = 1; b = (double) a; RETURN_DOUBLE(b); @@ -358,6 +384,7 @@ PHP_METHOD(Stub_Assign, testAssign25) { + a = 1; b = (double) a; RETURN_DOUBLE(b); @@ -372,6 +399,7 @@ PHP_METHOD(Stub_Assign, testAssign26) { + a = (double) (1); b = (long) a; RETURN_LONG(b); @@ -386,6 +414,7 @@ PHP_METHOD(Stub_Assign, testAssign27) { + b = 1; a = (double) b; RETURN_DOUBLE(a); @@ -400,6 +429,7 @@ PHP_METHOD(Stub_Assign, testAssign28) { + b = 1; a = ((b) ? 1 : 0); RETURN_BOOL(a); @@ -414,6 +444,7 @@ PHP_METHOD(Stub_Assign, testAssign29) { + b = 1.0; a = ((b != 0.0) ? 1 : 0); RETURN_BOOL(a); @@ -428,6 +459,7 @@ PHP_METHOD(Stub_Assign, testAssign30) { + b = 0; a = b; RETURN_LONG(a); @@ -442,6 +474,7 @@ PHP_METHOD(Stub_Assign, testAssign31) { + b = 0; a = (double) b; RETURN_DOUBLE(a); @@ -455,6 +488,7 @@ PHP_METHOD(Stub_Assign, testAssign32) { + b = 0; a = b; RETURN_BOOL(a); @@ -468,6 +502,7 @@ PHP_METHOD(Stub_Assign, testAssign33) { + b = 0; a = b; RETURN_BOOL(a); @@ -482,6 +517,7 @@ PHP_METHOD(Stub_Assign, testAssign34) { + b = 0; a = ((b) ? 1 : 0); RETURN_BOOL(a); @@ -496,6 +532,7 @@ PHP_METHOD(Stub_Assign, testAssign35) { + b = 0; a = ((b != 0.0) ? 1 : 0); RETURN_BOOL(a); @@ -509,6 +546,7 @@ PHP_METHOD(Stub_Assign, testAssign36) { + b = 0; a = b; RETURN_BOOL(a); @@ -530,6 +568,7 @@ PHP_METHOD(Stub_Assign, testAssign37) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_4); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&v); @@ -579,6 +618,14 @@ PHP_METHOD(Stub_Assign, testAssign38) { ZVAL_UNDEF(&index_sub); ZVAL_UNDEF(&arr); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index); @@ -604,6 +651,7 @@ PHP_METHOD(Stub_Assign, testAssign39) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&c); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -629,6 +677,7 @@ PHP_METHOD(Stub_Assign, testAssign40) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -653,6 +702,14 @@ PHP_METHOD(Stub_Assign, testAssign41) { zend_long num, a = 0; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &num_param); @@ -674,6 +731,14 @@ PHP_METHOD(Stub_Assign, testAssign42) { zend_long num, a = 0; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &num_param); @@ -692,6 +757,14 @@ PHP_METHOD(Stub_Assign, testAssign43) { zend_long num, a = 0; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &num_param); @@ -710,6 +783,14 @@ PHP_METHOD(Stub_Assign, testAssign44) { zend_long num, a = 0; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &num_param); @@ -734,6 +815,7 @@ PHP_METHOD(Stub_Assign, testPropertyAssign1) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_ZVAL_NREF(_0); @@ -784,6 +866,7 @@ PHP_METHOD(Stub_Assign, testPropertyAssign2) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&f); + ZEPHIR_MM_GROW(); a = 1; @@ -822,6 +905,7 @@ PHP_METHOD(Stub_Assign, testPropertyIncr1) { ZVAL_UNDEF(&_0); + ZEPHIR_INIT_ZVAL_NREF(_0); ZVAL_LONG(&_0, 1); zephir_update_property_zval(this_ptr, ZEND_STRL("testVar"), &_0); @@ -839,6 +923,7 @@ PHP_METHOD(Stub_Assign, testPropertyAddAssign1) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_ZVAL_NREF(_0); @@ -862,6 +947,7 @@ PHP_METHOD(Stub_Assign, testPropertyAddAssign2) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_ZVAL_NREF(_0); @@ -885,6 +971,7 @@ PHP_METHOD(Stub_Assign, testPropertyAssignValuePlus1) { ZVAL_UNDEF(&_1); + ZEPHIR_INIT_ZVAL_NREF(_0); ZVAL_LONG(&_0, 1); zephir_update_property_zval(this_ptr, ZEND_STRL("testVar"), &_0); @@ -904,6 +991,7 @@ PHP_METHOD(Stub_Assign, testPropertyDecr) { ZVAL_UNDEF(&_0); + ZEPHIR_INIT_ZVAL_NREF(_0); ZVAL_LONG(&_0, 2); zephir_update_property_zval(this_ptr, ZEND_STRL("testVar"), &_0); @@ -921,6 +1009,7 @@ PHP_METHOD(Stub_Assign, testPropertySubAssign1) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_ZVAL_NREF(_0); @@ -944,6 +1033,7 @@ PHP_METHOD(Stub_Assign, testPropertySubAssign2) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_ZVAL_NREF(_0); @@ -967,6 +1057,7 @@ PHP_METHOD(Stub_Assign, testPropertyMulAssign1) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_ZVAL_NREF(_0); @@ -990,6 +1081,7 @@ PHP_METHOD(Stub_Assign, testPropertyMulAssign2) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_ZVAL_NREF(_0); @@ -1012,6 +1104,7 @@ PHP_METHOD(Stub_Assign, testPropertyAssignStringConcat) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -1037,6 +1130,7 @@ PHP_METHOD(Stub_Assign, testPropertyArray1) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -1089,6 +1183,7 @@ PHP_METHOD(Stub_Assign, testPropertyArray2) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&f); + ZEPHIR_MM_GROW(); a = 1; @@ -1142,6 +1237,7 @@ PHP_METHOD(Stub_Assign, testPropertyArray3) { ZVAL_UNDEF(&_10); ZVAL_UNDEF(&_11); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -1195,6 +1291,14 @@ PHP_METHOD(Stub_Assign, testPropertyArray4) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index); @@ -1239,6 +1343,14 @@ PHP_METHOD(Stub_Assign, testPropertyArray5) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index_param); @@ -1280,6 +1392,7 @@ PHP_METHOD(Stub_Assign, testPropertyArray6) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -1319,6 +1432,7 @@ PHP_METHOD(Stub_Assign, testPropertyArray7) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -1358,6 +1472,14 @@ PHP_METHOD(Stub_Assign, testPropertyArray8) { ZVAL_BOOL(&__$true, 1); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index); @@ -1401,6 +1523,14 @@ PHP_METHOD(Stub_Assign, testPropertyArray9) { ZVAL_BOOL(&__$true, 1); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index_param); @@ -1446,6 +1576,14 @@ PHP_METHOD(Stub_Assign, testPropertyArray10) { ZVAL_BOOL(&__$true, 1); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index_param); @@ -1493,6 +1631,14 @@ PHP_METHOD(Stub_Assign, testPropertyArray11) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index); @@ -1541,6 +1687,14 @@ PHP_METHOD(Stub_Assign, testPropertyArray12) { ZVAL_UNDEF(&_4); ZVAL_UNDEF(&_5); ZVAL_UNDEF(&_6); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index); @@ -1597,6 +1751,14 @@ PHP_METHOD(Stub_Assign, testPropertyArray13) { ZVAL_UNDEF(&_4); ZVAL_UNDEF(&_5); ZVAL_UNDEF(&_6); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index); @@ -1649,6 +1811,7 @@ PHP_METHOD(Stub_Assign, testPropertyArray14) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_3); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&v); @@ -1703,6 +1866,7 @@ PHP_METHOD(Stub_Assign, testStaticPropertyAssign1) { ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_ZVAL_NREF(_0); @@ -1756,6 +1920,7 @@ PHP_METHOD(Stub_Assign, testStaticPropertyAssign2) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&f); + ZEPHIR_MM_GROW(); a = 1; @@ -1798,6 +1963,7 @@ PHP_METHOD(Stub_Assign, testStaticPropertyArray1) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -1839,6 +2005,7 @@ PHP_METHOD(Stub_Assign, testStaticPropertyArray2) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -1880,6 +2047,14 @@ PHP_METHOD(Stub_Assign, testStaticPropertyArray3) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index); @@ -1923,6 +2098,7 @@ PHP_METHOD(Stub_Assign, testStaticPropertyArrayAppend) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -1959,6 +2135,7 @@ PHP_METHOD(Stub_Assign, testStaticPropertyArrayMutli1) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -2000,6 +2177,7 @@ PHP_METHOD(Stub_Assign, testStaticPropertyArrayMutli2) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -2041,6 +2219,14 @@ PHP_METHOD(Stub_Assign, testStaticPropertyArrayMutli3) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index); @@ -2087,6 +2273,7 @@ PHP_METHOD(Stub_Assign, testStaticPropertyArrayMulti4) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_3); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&v); @@ -2136,6 +2323,7 @@ PHP_METHOD(Stub_Assign, testStaticPropertyArrayAppend1) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -2173,6 +2361,15 @@ PHP_METHOD(Stub_Assign, testArrayVarAssign1) { ZVAL_UNDEF(&index_sub); ZVAL_UNDEF(&value_sub); ZVAL_UNDEF(&a); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(index) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &index, &value); @@ -2195,6 +2392,15 @@ PHP_METHOD(Stub_Assign, testArrayVarAssign2) { ZVAL_UNDEF(&index_sub); ZVAL_UNDEF(&value_sub); ZVAL_UNDEF(&_POST); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(index) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &index, &value); @@ -2217,6 +2423,15 @@ PHP_METHOD(Stub_Assign, testArrayProperty) { ZVAL_UNDEF(&index_sub); ZVAL_UNDEF(&value_sub); ZVAL_UNDEF(&_POST); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(index) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &index, &value); @@ -2241,6 +2456,15 @@ PHP_METHOD(Stub_Assign, testGlobalVarAssign) { ZVAL_UNDEF(&index_sub); ZVAL_UNDEF(&value_sub); ZVAL_UNDEF(&_POST); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(index) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_get_global(&_POST, SL("_POST")); zephir_fetch_params_without_memory_grow(2, 0, &index, &value); @@ -2262,6 +2486,7 @@ PHP_METHOD(Stub_Assign, testConstantKeyAssign) { ZVAL_UNDEF(&elements); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&elements); @@ -2290,6 +2515,7 @@ PHP_METHOD(Stub_Assign, testArrayBoolExpressionAssign) { ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&str); @@ -2327,6 +2553,7 @@ PHP_METHOD(Stub_Assign, testAssignSuperGlobals) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); + ZEPHIR_MM_GROW(); zephir_get_global(&_GET, SL("_GET")); @@ -2363,6 +2590,7 @@ PHP_METHOD(Stub_Assign, testAssignSuperGlobalsSERVER) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); zephir_get_global(&_SERVER, SL("_SERVER")); @@ -2391,6 +2619,7 @@ PHP_METHOD(Stub_Assign, testAssignSuperGlobalsGET) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); zephir_get_global(&_GET, SL("_GET")); diff --git a/ext/stub/assign.zep.h b/ext/stub/assign.zep.h index 66885efd0c..40a9eac3f2 100644 --- a/ext/stub/assign.zep.h +++ b/ext/stub/assign.zep.h @@ -102,333 +102,141 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_assign_getmyarray, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign1, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign1, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign2, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign2, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign3, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign3, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign4, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign4, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign5, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign5, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign6, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign6, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign7, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign7, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign8, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign8, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign9, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign9, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign10, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign10, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign11, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign11, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign12, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign12, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign13, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign13, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign14, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign14, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign15, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign15, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign16, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign16, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign17, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign17, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign18, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign18, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign19, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign19, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign20, 0, 0, IS_NULL, 1) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign20, 0, 0, IS_NULL, NULL, 1) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign21, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign21, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign22, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign22, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign23, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign23, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign24, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign24, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign25, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign25, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign26, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign26, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign27, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign27, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign28, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign28, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign29, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign29, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign30, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign30, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign31, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign31, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign32, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign32, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign33, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign33, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign34, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign34, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign35, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign35, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign36, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign36, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign37, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign37, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign38, 0, 1, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign38, 0, 1, IS_ARRAY, NULL, 0) -#endif ZEND_ARG_INFO(0, index) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign39, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign39, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign40, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign40, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign41, 0, 1, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign41, 0, 1, IS_LONG, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign42, 0, 1, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign42, 0, 1, IS_LONG, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign43, 0, 1, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign43, 0, 1, IS_LONG, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign44, 0, 1, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_assign_testassign44, 0, 1, IS_LONG, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_assign_testpropertyassign1, 0, 0, 0) @@ -481,11 +289,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_assign_testpropertyarray4, 0, 0, 1) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_assign_testpropertyarray5, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, index, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, index) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_assign_testpropertyarray6, 0, 0, 0) @@ -499,19 +303,11 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_assign_testpropertyarray8, 0, 0, 1) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_assign_testpropertyarray9, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, index, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, index) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_assign_testpropertyarray10, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, index, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, index) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_assign_testpropertyarray11, 0, 0, 1) @@ -600,8 +396,16 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_assign_testassignsuperglobalsget, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_assign_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, getTestVar, arginfo_stub_assign_gettestvar, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, getTestVar, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, getMyArray, arginfo_stub_assign_getmyarray, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, getMyArray, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Assign, testAssign1, arginfo_stub_assign_testassign1, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testAssign2, arginfo_stub_assign_testassign2, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testAssign3, arginfo_stub_assign_testassign3, ZEND_ACC_PUBLIC) @@ -646,51 +450,179 @@ ZEPHIR_INIT_FUNCS(stub_assign_method_entry) { PHP_ME(Stub_Assign, testAssign42, arginfo_stub_assign_testassign42, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testAssign43, arginfo_stub_assign_testassign43, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testAssign44, arginfo_stub_assign_testassign44, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyAssign1, arginfo_stub_assign_testpropertyassign1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyAssign1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyAssign2, arginfo_stub_assign_testpropertyassign2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyAssign2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyIncr1, arginfo_stub_assign_testpropertyincr1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyIncr1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyAddAssign1, arginfo_stub_assign_testpropertyaddassign1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyAddAssign1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyAddAssign2, arginfo_stub_assign_testpropertyaddassign2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyAddAssign2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyAssignValuePlus1, arginfo_stub_assign_testpropertyassignvalueplus1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyAssignValuePlus1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyDecr, arginfo_stub_assign_testpropertydecr, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyDecr, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertySubAssign1, arginfo_stub_assign_testpropertysubassign1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertySubAssign1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertySubAssign2, arginfo_stub_assign_testpropertysubassign2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertySubAssign2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyMulAssign1, arginfo_stub_assign_testpropertymulassign1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyMulAssign1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyMulAssign2, arginfo_stub_assign_testpropertymulassign2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyMulAssign2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyAssignStringConcat, arginfo_stub_assign_testpropertyassignstringconcat, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyAssignStringConcat, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyArray1, arginfo_stub_assign_testpropertyarray1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyArray1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyArray2, arginfo_stub_assign_testpropertyarray2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyArray2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyArray3, arginfo_stub_assign_testpropertyarray3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyArray3, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Assign, testPropertyArray4, arginfo_stub_assign_testpropertyarray4, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testPropertyArray5, arginfo_stub_assign_testpropertyarray5, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyArray6, arginfo_stub_assign_testpropertyarray6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyArray6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyArray7, arginfo_stub_assign_testpropertyarray7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyArray7, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Assign, testPropertyArray8, arginfo_stub_assign_testpropertyarray8, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testPropertyArray9, arginfo_stub_assign_testpropertyarray9, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testPropertyArray10, arginfo_stub_assign_testpropertyarray10, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testPropertyArray11, arginfo_stub_assign_testpropertyarray11, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testPropertyArray12, arginfo_stub_assign_testpropertyarray12, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testPropertyArray13, arginfo_stub_assign_testpropertyarray13, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testPropertyArray14, arginfo_stub_assign_testpropertyarray14, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testPropertyArray14, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testStaticPropertyAssign1, arginfo_stub_assign_teststaticpropertyassign1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testStaticPropertyAssign1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testStaticPropertyAssign2, arginfo_stub_assign_teststaticpropertyassign2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testStaticPropertyAssign2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testStaticPropertyArray1, arginfo_stub_assign_teststaticpropertyarray1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testStaticPropertyArray1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testStaticPropertyArray2, arginfo_stub_assign_teststaticpropertyarray2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testStaticPropertyArray2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Assign, testStaticPropertyArray3, arginfo_stub_assign_teststaticpropertyarray3, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testStaticPropertyArrayAppend, arginfo_stub_assign_teststaticpropertyarrayappend, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testStaticPropertyArrayAppend, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testStaticPropertyArrayMutli1, arginfo_stub_assign_teststaticpropertyarraymutli1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testStaticPropertyArrayMutli1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testStaticPropertyArrayMutli2, arginfo_stub_assign_teststaticpropertyarraymutli2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testStaticPropertyArrayMutli2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Assign, testStaticPropertyArrayMutli3, arginfo_stub_assign_teststaticpropertyarraymutli3, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testStaticPropertyArrayMulti4, arginfo_stub_assign_teststaticpropertyarraymulti4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testStaticPropertyArrayMulti4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testStaticPropertyArrayAppend1, arginfo_stub_assign_teststaticpropertyarrayappend1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testStaticPropertyArrayAppend1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Assign, testArrayVarAssign1, arginfo_stub_assign_testarrayvarassign1, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testArrayVarAssign2, arginfo_stub_assign_testarrayvarassign2, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testArrayProperty, arginfo_stub_assign_testarrayproperty, ZEND_ACC_PUBLIC) PHP_ME(Stub_Assign, testGlobalVarAssign, arginfo_stub_assign_testglobalvarassign, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testConstantKeyAssign, arginfo_stub_assign_testconstantkeyassign, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testConstantKeyAssign, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testArrayBoolExpressionAssign, arginfo_stub_assign_testarrayboolexpressionassign, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testArrayBoolExpressionAssign, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testAssignSuperGlobals, arginfo_stub_assign_testassignsuperglobals, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testAssignSuperGlobals, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testAssignSuperGlobalsSERVER, arginfo_stub_assign_testassignsuperglobalsserver, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testAssignSuperGlobalsSERVER, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Assign, testAssignSuperGlobalsGET, arginfo_stub_assign_testassignsuperglobalsget, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Assign, testAssignSuperGlobalsGET, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/bench/foo.zep.c b/ext/stub/bench/foo.zep.c index f51e3f4553..aacdda25c2 100644 --- a/ext/stub/bench/foo.zep.c +++ b/ext/stub/bench/foo.zep.c @@ -43,6 +43,14 @@ PHP_METHOD(Stub_Bench_Foo, emptyForInRange) { ZVAL_UNDEF(&n_sub); ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -82,6 +90,14 @@ PHP_METHOD(Stub_Bench_Foo, readStatic) { ZVAL_UNDEF(&x); ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -123,6 +139,14 @@ PHP_METHOD(Stub_Bench_Foo, writeStatic) { ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -164,6 +188,14 @@ PHP_METHOD(Stub_Bench_Foo, issetStatic) { ZVAL_UNDEF(&n_sub); ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -204,6 +236,14 @@ PHP_METHOD(Stub_Bench_Foo, emptyStatic) { ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -246,6 +286,14 @@ PHP_METHOD(Stub_Bench_Foo, readProp) { ZVAL_UNDEF(&x); ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -286,6 +334,14 @@ PHP_METHOD(Stub_Bench_Foo, writeProp) { ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -329,6 +385,14 @@ PHP_METHOD(Stub_Bench_Foo, assignAddProp) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3$$3); ZVAL_UNDEF(&_4$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -388,6 +452,14 @@ PHP_METHOD(Stub_Bench_Foo, postIncProp) { ZVAL_UNDEF(&n_sub); ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -427,6 +499,14 @@ PHP_METHOD(Stub_Bench_Foo, postDecProp) { ZVAL_UNDEF(&n_sub); ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -466,6 +546,14 @@ PHP_METHOD(Stub_Bench_Foo, issetProp) { ZVAL_UNDEF(&n_sub); ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -506,6 +594,14 @@ PHP_METHOD(Stub_Bench_Foo, emptyProp) { ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -542,6 +638,7 @@ PHP_METHOD(Stub_Bench_Foo, g) { + } PHP_METHOD(Stub_Bench_Foo, call) { @@ -556,6 +653,14 @@ PHP_METHOD(Stub_Bench_Foo, call) { ZVAL_UNDEF(&n_sub); ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -591,6 +696,7 @@ PHP_METHOD(Stub_Bench_Foo, staticMethod) { + } PHP_METHOD(Stub_Bench_Foo, staticMethod1) { @@ -598,6 +704,7 @@ PHP_METHOD(Stub_Bench_Foo, staticMethod1) { zval *this_ptr = getThis(); + RETURN_BOOL(1); } @@ -614,6 +721,14 @@ PHP_METHOD(Stub_Bench_Foo, scall) { ZVAL_UNDEF(&n_sub); ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -655,6 +770,14 @@ PHP_METHOD(Stub_Bench_Foo, scallWithReturnTrue) { ZVAL_UNDEF(&n_sub); ZVAL_UNDEF(&i); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); @@ -696,6 +819,14 @@ PHP_METHOD(Stub_Bench_Foo, readConst) { ZVAL_UNDEF(&i); ZVAL_UNDEF(&x); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); diff --git a/ext/stub/bench/foo.zep.h b/ext/stub/bench/foo.zep.h index a5f314b960..e138460b1d 100644 --- a/ext/stub/bench/foo.zep.h +++ b/ext/stub/bench/foo.zep.h @@ -78,22 +78,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_bench_foo_call, 0, 0, 1) ZEND_ARG_INFO(0, n) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_bench_foo_staticmethod, 0, 0, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_bench_foo_staticmethod, 0, 0, IS_VOID, NULL, 0) -#endif ZEND_END_ARG_INFO() -#else -#define arginfo_stub_bench_foo_staticmethod NULL -#endif -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_bench_foo_staticmethod1, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_bench_foo_staticmethod1, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_bench_foo_scall, 0, 0, 1) @@ -121,7 +109,11 @@ ZEPHIR_INIT_FUNCS(stub_bench_foo_method_entry) { PHP_ME(Stub_Bench_Foo, postDecProp, arginfo_stub_bench_foo_postdecprop, ZEND_ACC_PUBLIC) PHP_ME(Stub_Bench_Foo, issetProp, arginfo_stub_bench_foo_issetprop, ZEND_ACC_PUBLIC) PHP_ME(Stub_Bench_Foo, emptyProp, arginfo_stub_bench_foo_emptyprop, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bench_Foo, g, arginfo_stub_bench_foo_g, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bench_Foo, g, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Bench_Foo, call, arginfo_stub_bench_foo_call, ZEND_ACC_PUBLIC) PHP_ME(Stub_Bench_Foo, staticMethod, arginfo_stub_bench_foo_staticmethod, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) PHP_ME(Stub_Bench_Foo, staticMethod1, arginfo_stub_bench_foo_staticmethod1, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) diff --git a/ext/stub/bitwise.zep.c b/ext/stub/bitwise.zep.c index 5e54a03dcd..81e81d18bc 100644 --- a/ext/stub/bitwise.zep.c +++ b/ext/stub/bitwise.zep.c @@ -36,6 +36,7 @@ PHP_METHOD(Stub_Bitwise, intAnd) { + a = 1; b = 2; c = (a & b); @@ -50,6 +51,7 @@ PHP_METHOD(Stub_Bitwise, int2And) { + a = 1; c = (a & 2); RETURN_LONG(c); @@ -63,6 +65,7 @@ PHP_METHOD(Stub_Bitwise, intAndSimple) { + c = 0; RETURN_LONG(c); @@ -75,6 +78,7 @@ PHP_METHOD(Stub_Bitwise, boolAnd) { + a = ((1) ? 1 : 0); b = ((2) ? 1 : 0); c = (((a & b)) ? 1 : 0); @@ -89,6 +93,7 @@ PHP_METHOD(Stub_Bitwise, bool2And) { + a = ((1) ? 1 : 0); c = (((a & 2)) ? 1 : 0); RETURN_BOOL(c); @@ -102,6 +107,7 @@ PHP_METHOD(Stub_Bitwise, bool3And) { + a = 1; c = (((a & 0)) ? 1 : 0); RETURN_BOOL(c); @@ -115,6 +121,7 @@ PHP_METHOD(Stub_Bitwise, boolAndSimple) { + c = ((0) ? 1 : 0); RETURN_BOOL(c); @@ -127,6 +134,7 @@ PHP_METHOD(Stub_Bitwise, doubleAnd) { + a = (double) (1); b = (double) (2); c = (double) (((int) (a) & (int) (b))); @@ -141,6 +149,7 @@ PHP_METHOD(Stub_Bitwise, double2And) { + a = 1.0; b = 2.0; c = (double) (((int) (a) & (int) (b))); @@ -155,6 +164,7 @@ PHP_METHOD(Stub_Bitwise, doubleAndSimple) { + c = (double) (0); RETURN_DOUBLE(c); @@ -167,6 +177,7 @@ PHP_METHOD(Stub_Bitwise, doubleAnd2Simple) { + c = (double) (0.0); RETURN_DOUBLE(c); @@ -179,6 +190,7 @@ PHP_METHOD(Stub_Bitwise, varAnd) { + a = 1; b = 2; c = (a & b); @@ -193,6 +205,7 @@ PHP_METHOD(Stub_Bitwise, varAndSimple) { + c = 0; RETURN_LONG(c); @@ -206,6 +219,7 @@ PHP_METHOD(Stub_Bitwise, intDoubleAnd) { + a = (double) (1); b = 2; c = ((int) (a) & b); @@ -220,6 +234,7 @@ PHP_METHOD(Stub_Bitwise, intDoubleAndSimple) { + c = 0; RETURN_LONG(c); @@ -233,6 +248,7 @@ PHP_METHOD(Stub_Bitwise, doubleIntAnd) { + a = (double) (1); b = 2; c = (double) (((int) (a) & b)); @@ -247,6 +263,7 @@ PHP_METHOD(Stub_Bitwise, doubleIntAndSimple) { + c = (double) (0); RETURN_DOUBLE(c); @@ -259,6 +276,7 @@ PHP_METHOD(Stub_Bitwise, varIntAnd) { + a = 1; b = 2; c = (a & b); @@ -273,6 +291,7 @@ PHP_METHOD(Stub_Bitwise, intVarAnd) { + a = 1; b = 2; c = (b & a); @@ -291,6 +310,7 @@ PHP_METHOD(Stub_Bitwise, intVarImplicitCastAnd) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -313,6 +333,7 @@ PHP_METHOD(Stub_Bitwise, intVarImplicitCast2And) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -330,6 +351,7 @@ PHP_METHOD(Stub_Bitwise, complexAnd) { + c = (double) (0); RETURN_DOUBLE(c); @@ -342,6 +364,7 @@ PHP_METHOD(Stub_Bitwise, complex2And) { + c = (((1 & 1)) ? 1 : 0); RETURN_BOOL(c); @@ -354,6 +377,7 @@ PHP_METHOD(Stub_Bitwise, complex3And) { + c = (((1 &((1.0) ? 1 : 0))) ? 1 : 0); RETURN_BOOL(c); @@ -367,6 +391,7 @@ PHP_METHOD(Stub_Bitwise, complex4And) { ZVAL_UNDEF(&c); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&c); @@ -382,6 +407,7 @@ PHP_METHOD(Stub_Bitwise, complex5And) { + c = (1 & 1); RETURN_LONG(c); @@ -394,6 +420,7 @@ PHP_METHOD(Stub_Bitwise, complex6And) { + c = (((1 &((1) ? 1 : 0))) ? 1 : 0); RETURN_BOOL(c); @@ -407,6 +434,7 @@ PHP_METHOD(Stub_Bitwise, complex7And) { + a = ((1) ? 1 : 0); b = 2; c = (a & b); @@ -422,6 +450,7 @@ PHP_METHOD(Stub_Bitwise, complex9And) { + a = ((1) ? 1 : 0); b = 2; c = (b & a); @@ -438,6 +467,7 @@ PHP_METHOD(Stub_Bitwise, complex10And) { + a = ((1.0 != 0.0) ? 1 : 0); b = 2; c = (double) ((b & a)); @@ -454,6 +484,7 @@ PHP_METHOD(Stub_Bitwise, complex11And) { + a = ((1) ? 1 : 0); b = (long) (2.0); c = (double) ((b & a)); @@ -469,6 +500,7 @@ PHP_METHOD(Stub_Bitwise, complex12And) { + a = ((1) ? 1 : 0); b = (long) (2.0); c = (b & a); @@ -484,6 +516,7 @@ PHP_METHOD(Stub_Bitwise, complex13And) { + a = ((1) ? 1 : 0); b = ((2.0 != 0.0) ? 1 : 0); c = (b & a); @@ -499,6 +532,7 @@ PHP_METHOD(Stub_Bitwise, complex14And) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); c = (b & a); @@ -515,6 +549,7 @@ PHP_METHOD(Stub_Bitwise, complex15And) { + a = 1; b = 2.0; c = ((((int) (b) & a)) ? 1 : 0); @@ -530,6 +565,7 @@ PHP_METHOD(Stub_Bitwise, complex16And) { + a = 1; b = 2.0; c = (double) (((int) (b) & a)); @@ -546,6 +582,7 @@ PHP_METHOD(Stub_Bitwise, complex17And) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); c = (double) ((a & b)); @@ -562,6 +599,7 @@ PHP_METHOD(Stub_Bitwise, complex18And) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a & b)); @@ -579,6 +617,7 @@ PHP_METHOD(Stub_Bitwise, complex19And) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a & b)); @@ -596,6 +635,7 @@ PHP_METHOD(Stub_Bitwise, complex20And) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a & b)); @@ -613,6 +653,7 @@ PHP_METHOD(Stub_Bitwise, complex21And) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a & b)); @@ -629,6 +670,7 @@ PHP_METHOD(Stub_Bitwise, complex22And) { + a = 1; b = (long) (2.0); d = (double) ((a & b)); @@ -646,6 +688,7 @@ PHP_METHOD(Stub_Bitwise, complex23And) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a & b)); @@ -661,6 +704,7 @@ PHP_METHOD(Stub_Bitwise, complex24And) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (1 & (a & ((int) (0) & b))); @@ -675,6 +719,7 @@ PHP_METHOD(Stub_Bitwise, intOr) { + a = 1; b = 2; c = (a | b); @@ -689,6 +734,7 @@ PHP_METHOD(Stub_Bitwise, int2Or) { + a = 1; c = (a | 2); RETURN_LONG(c); @@ -702,6 +748,7 @@ PHP_METHOD(Stub_Bitwise, intOrSimple) { + c = 3; RETURN_LONG(c); @@ -714,6 +761,7 @@ PHP_METHOD(Stub_Bitwise, boolOr) { + a = ((1) ? 1 : 0); b = ((2) ? 1 : 0); c = (((a | b)) ? 1 : 0); @@ -728,6 +776,7 @@ PHP_METHOD(Stub_Bitwise, bool2Or) { + a = ((1) ? 1 : 0); c = (((a | 2)) ? 1 : 0); RETURN_BOOL(c); @@ -741,6 +790,7 @@ PHP_METHOD(Stub_Bitwise, bool3Or) { + a = 1; c = (((a | 0)) ? 1 : 0); RETURN_BOOL(c); @@ -754,6 +804,7 @@ PHP_METHOD(Stub_Bitwise, bool4Or) { + a = 1; c = (((a | 1)) ? 1 : 0); RETURN_BOOL(c); @@ -767,6 +818,7 @@ PHP_METHOD(Stub_Bitwise, boolOrSimple) { + c = ((3) ? 1 : 0); RETURN_BOOL(c); @@ -779,6 +831,7 @@ PHP_METHOD(Stub_Bitwise, doubleOr) { + a = (double) (1); b = (double) (2); c = (double) (((int) (a) | (int) (b))); @@ -793,6 +846,7 @@ PHP_METHOD(Stub_Bitwise, double2Or) { + a = 1.0; b = 2.0; c = (double) (((int) (a) | (int) (b))); @@ -807,6 +861,7 @@ PHP_METHOD(Stub_Bitwise, doubleOrSimple) { + c = (double) (3); RETURN_DOUBLE(c); @@ -819,6 +874,7 @@ PHP_METHOD(Stub_Bitwise, doubleOr2Simple) { + c = (double) (3.0); RETURN_DOUBLE(c); @@ -831,6 +887,7 @@ PHP_METHOD(Stub_Bitwise, varOr) { + a = 1; b = 2; c = (a | b); @@ -845,6 +902,7 @@ PHP_METHOD(Stub_Bitwise, varOrSimple) { + c = 3; RETURN_LONG(c); @@ -858,6 +916,7 @@ PHP_METHOD(Stub_Bitwise, intDoubleOr) { + a = (double) (1); b = 2; c = ((int) (a) | b); @@ -872,6 +931,7 @@ PHP_METHOD(Stub_Bitwise, intDoubleOrSimple) { + c = 3.0; RETURN_LONG(c); @@ -885,6 +945,7 @@ PHP_METHOD(Stub_Bitwise, doubleIntOr) { + a = (double) (1); b = 2; c = (double) (((int) (a) | b)); @@ -899,6 +960,7 @@ PHP_METHOD(Stub_Bitwise, doubleIntOrSimple) { + c = (double) (3.0); RETURN_DOUBLE(c); @@ -911,6 +973,7 @@ PHP_METHOD(Stub_Bitwise, varIntOr) { + a = 1; b = 2; c = (a | b); @@ -925,6 +988,7 @@ PHP_METHOD(Stub_Bitwise, intVarOr) { + a = 1; b = 2; c = (b | a); @@ -943,6 +1007,7 @@ PHP_METHOD(Stub_Bitwise, intVarImplicitCastOr) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -965,6 +1030,7 @@ PHP_METHOD(Stub_Bitwise, intVarImplicitCast2Or) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -982,6 +1048,7 @@ PHP_METHOD(Stub_Bitwise, complexOr) { + c = (double) (3.0); RETURN_DOUBLE(c); @@ -994,6 +1061,7 @@ PHP_METHOD(Stub_Bitwise, complex2Or) { + c = (((1 | 1)) ? 1 : 0); RETURN_BOOL(c); @@ -1006,6 +1074,7 @@ PHP_METHOD(Stub_Bitwise, complex3Or) { + c = (((1 |((1.0) ? 1 : 0))) ? 1 : 0); RETURN_BOOL(c); @@ -1019,6 +1088,7 @@ PHP_METHOD(Stub_Bitwise, complex4Or) { ZVAL_UNDEF(&c); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&c); @@ -1034,6 +1104,7 @@ PHP_METHOD(Stub_Bitwise, complex5Or) { + c = (1 | 1); RETURN_LONG(c); @@ -1046,6 +1117,7 @@ PHP_METHOD(Stub_Bitwise, complex6Or) { + c = (((1 |((1) ? 1 : 0))) ? 1 : 0); RETURN_BOOL(c); @@ -1059,6 +1131,7 @@ PHP_METHOD(Stub_Bitwise, complex7Or) { + a = ((1) ? 1 : 0); b = 2; c = (a | b); @@ -1074,6 +1147,7 @@ PHP_METHOD(Stub_Bitwise, complex9Or) { + a = ((1) ? 1 : 0); b = 2; c = (b | a); @@ -1090,6 +1164,7 @@ PHP_METHOD(Stub_Bitwise, complex10Or) { + a = ((1.0 != 0.0) ? 1 : 0); b = 2; c = (double) ((b | a)); @@ -1106,6 +1181,7 @@ PHP_METHOD(Stub_Bitwise, complex11Or) { + a = ((1) ? 1 : 0); b = (long) (2.0); c = (double) ((b | a)); @@ -1121,6 +1197,7 @@ PHP_METHOD(Stub_Bitwise, complex12Or) { + a = ((1) ? 1 : 0); b = (long) (2.0); c = (b | a); @@ -1136,6 +1213,7 @@ PHP_METHOD(Stub_Bitwise, complex13Or) { + a = ((1) ? 1 : 0); b = ((2.0 != 0.0) ? 1 : 0); c = (b | a); @@ -1151,6 +1229,7 @@ PHP_METHOD(Stub_Bitwise, complex14Or) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); c = (b | a); @@ -1167,6 +1246,7 @@ PHP_METHOD(Stub_Bitwise, complex15Or) { + a = 1; b = 2.0; c = ((((int) (b) | a)) ? 1 : 0); @@ -1182,6 +1262,7 @@ PHP_METHOD(Stub_Bitwise, complex16Or) { + a = 1; b = 2.0; c = (double) (((int) (b) | a)); @@ -1198,6 +1279,7 @@ PHP_METHOD(Stub_Bitwise, complex17Or) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); c = (double) ((a | b)); @@ -1214,6 +1296,7 @@ PHP_METHOD(Stub_Bitwise, complex18Or) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a | b)); @@ -1231,6 +1314,7 @@ PHP_METHOD(Stub_Bitwise, complex19Or) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a | b)); @@ -1248,6 +1332,7 @@ PHP_METHOD(Stub_Bitwise, complex20Or) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a | b)); @@ -1265,6 +1350,7 @@ PHP_METHOD(Stub_Bitwise, complex21Or) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a | b)); @@ -1281,6 +1367,7 @@ PHP_METHOD(Stub_Bitwise, complex22Or) { + a = 1; b = (long) (2.0); d = (double) ((a | b)); @@ -1298,6 +1385,7 @@ PHP_METHOD(Stub_Bitwise, complex23Or) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((a | b)); @@ -1314,6 +1402,7 @@ PHP_METHOD(Stub_Bitwise, complex24Or) { + a = 1; b = ((2.0 != 0.0) ? 1 : 0); d = (double) ((((1 | a) | 0) | b)); @@ -1328,6 +1417,7 @@ PHP_METHOD(Stub_Bitwise, intShiftLeft) { + a = 1; b = 2; c = (a << b); @@ -1342,6 +1432,7 @@ PHP_METHOD(Stub_Bitwise, int2ShiftLeft) { + a = 1; c = (a << 2); RETURN_LONG(c); @@ -1355,6 +1446,7 @@ PHP_METHOD(Stub_Bitwise, intShiftLeftSimple) { + c = 4; RETURN_LONG(c); @@ -1367,6 +1459,7 @@ PHP_METHOD(Stub_Bitwise, intShiftRight) { + a = 1; b = 2; c = (a >> b); @@ -1381,6 +1474,7 @@ PHP_METHOD(Stub_Bitwise, int2ShiftRight) { + a = 1; c = (a >> 2); RETURN_LONG(c); @@ -1394,6 +1488,7 @@ PHP_METHOD(Stub_Bitwise, intShiftRightSimple) { + c = 0; RETURN_LONG(c); @@ -1405,6 +1500,14 @@ PHP_METHOD(Stub_Bitwise, testBitwiseNot) { zend_long a; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a_param); @@ -1421,6 +1524,15 @@ PHP_METHOD(Stub_Bitwise, testBitwiseAndNot) { zend_long a, b; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_LONG(a) + Z_PARAM_LONG(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a_param, &b_param); @@ -1438,6 +1550,14 @@ PHP_METHOD(Stub_Bitwise, getInt) { zend_long num; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &num_param); @@ -1462,6 +1582,7 @@ PHP_METHOD(Stub_Bitwise, testbitwiseXor) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&j); + ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, 123); diff --git a/ext/stub/bitwise.zep.h b/ext/stub/bitwise.zep.h index 339786ac87..cc94f5ccdc 100644 --- a/ext/stub/bitwise.zep.h +++ b/ext/stub/bitwise.zep.h @@ -389,140 +389,504 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_bitwise_intshiftrightsimple, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_bitwise_testbitwisenot, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_bitwise_testbitwiseandnot, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_bitwise_getint, 0, 1, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_bitwise_getint, 0, 1, IS_LONG, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_bitwise_testbitwisexor, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_bitwise_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intAnd, arginfo_stub_bitwise_intand, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intAnd, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, int2And, arginfo_stub_bitwise_int2and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, int2And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intAndSimple, arginfo_stub_bitwise_intandsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intAndSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, boolAnd, arginfo_stub_bitwise_booland, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, boolAnd, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, bool2And, arginfo_stub_bitwise_bool2and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, bool2And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, bool3And, arginfo_stub_bitwise_bool3and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, bool3And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, boolAndSimple, arginfo_stub_bitwise_boolandsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, boolAndSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, doubleAnd, arginfo_stub_bitwise_doubleand, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, doubleAnd, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, double2And, arginfo_stub_bitwise_double2and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, double2And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, doubleAndSimple, arginfo_stub_bitwise_doubleandsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, doubleAndSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, doubleAnd2Simple, arginfo_stub_bitwise_doubleand2simple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, doubleAnd2Simple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, varAnd, arginfo_stub_bitwise_varand, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, varAnd, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, varAndSimple, arginfo_stub_bitwise_varandsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, varAndSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intDoubleAnd, arginfo_stub_bitwise_intdoubleand, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intDoubleAnd, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intDoubleAndSimple, arginfo_stub_bitwise_intdoubleandsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intDoubleAndSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, doubleIntAnd, arginfo_stub_bitwise_doubleintand, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, doubleIntAnd, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, doubleIntAndSimple, arginfo_stub_bitwise_doubleintandsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, doubleIntAndSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, varIntAnd, arginfo_stub_bitwise_varintand, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, varIntAnd, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intVarAnd, arginfo_stub_bitwise_intvarand, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intVarAnd, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intVarImplicitCastAnd, arginfo_stub_bitwise_intvarimplicitcastand, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intVarImplicitCastAnd, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intVarImplicitCast2And, arginfo_stub_bitwise_intvarimplicitcast2and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intVarImplicitCast2And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complexAnd, arginfo_stub_bitwise_complexand, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complexAnd, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex2And, arginfo_stub_bitwise_complex2and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex2And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex3And, arginfo_stub_bitwise_complex3and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex3And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex4And, arginfo_stub_bitwise_complex4and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex4And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex5And, arginfo_stub_bitwise_complex5and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex5And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex6And, arginfo_stub_bitwise_complex6and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex6And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex7And, arginfo_stub_bitwise_complex7and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex7And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex9And, arginfo_stub_bitwise_complex9and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex9And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex10And, arginfo_stub_bitwise_complex10and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex10And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex11And, arginfo_stub_bitwise_complex11and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex11And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex12And, arginfo_stub_bitwise_complex12and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex12And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex13And, arginfo_stub_bitwise_complex13and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex13And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex14And, arginfo_stub_bitwise_complex14and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex14And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex15And, arginfo_stub_bitwise_complex15and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex15And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex16And, arginfo_stub_bitwise_complex16and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex16And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex17And, arginfo_stub_bitwise_complex17and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex17And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex18And, arginfo_stub_bitwise_complex18and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex18And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex19And, arginfo_stub_bitwise_complex19and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex19And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex20And, arginfo_stub_bitwise_complex20and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex20And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex21And, arginfo_stub_bitwise_complex21and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex21And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex22And, arginfo_stub_bitwise_complex22and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex22And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex23And, arginfo_stub_bitwise_complex23and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex23And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex24And, arginfo_stub_bitwise_complex24and, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex24And, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intOr, arginfo_stub_bitwise_intor, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intOr, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, int2Or, arginfo_stub_bitwise_int2or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, int2Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intOrSimple, arginfo_stub_bitwise_intorsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intOrSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, boolOr, arginfo_stub_bitwise_boolor, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, boolOr, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, bool2Or, arginfo_stub_bitwise_bool2or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, bool2Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, bool3Or, arginfo_stub_bitwise_bool3or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, bool3Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, bool4Or, arginfo_stub_bitwise_bool4or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, bool4Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, boolOrSimple, arginfo_stub_bitwise_boolorsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, boolOrSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, doubleOr, arginfo_stub_bitwise_doubleor, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, doubleOr, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, double2Or, arginfo_stub_bitwise_double2or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, double2Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, doubleOrSimple, arginfo_stub_bitwise_doubleorsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, doubleOrSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, doubleOr2Simple, arginfo_stub_bitwise_doubleor2simple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, doubleOr2Simple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, varOr, arginfo_stub_bitwise_varor, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, varOr, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, varOrSimple, arginfo_stub_bitwise_varorsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, varOrSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intDoubleOr, arginfo_stub_bitwise_intdoubleor, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intDoubleOr, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intDoubleOrSimple, arginfo_stub_bitwise_intdoubleorsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intDoubleOrSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, doubleIntOr, arginfo_stub_bitwise_doubleintor, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, doubleIntOr, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, doubleIntOrSimple, arginfo_stub_bitwise_doubleintorsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, doubleIntOrSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, varIntOr, arginfo_stub_bitwise_varintor, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, varIntOr, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intVarOr, arginfo_stub_bitwise_intvaror, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intVarOr, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intVarImplicitCastOr, arginfo_stub_bitwise_intvarimplicitcastor, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intVarImplicitCastOr, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intVarImplicitCast2Or, arginfo_stub_bitwise_intvarimplicitcast2or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intVarImplicitCast2Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complexOr, arginfo_stub_bitwise_complexor, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complexOr, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex2Or, arginfo_stub_bitwise_complex2or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex2Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex3Or, arginfo_stub_bitwise_complex3or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex3Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex4Or, arginfo_stub_bitwise_complex4or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex4Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex5Or, arginfo_stub_bitwise_complex5or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex5Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex6Or, arginfo_stub_bitwise_complex6or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex6Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex7Or, arginfo_stub_bitwise_complex7or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex7Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex9Or, arginfo_stub_bitwise_complex9or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex9Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex10Or, arginfo_stub_bitwise_complex10or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex10Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex11Or, arginfo_stub_bitwise_complex11or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex11Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex12Or, arginfo_stub_bitwise_complex12or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex12Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex13Or, arginfo_stub_bitwise_complex13or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex13Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex14Or, arginfo_stub_bitwise_complex14or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex14Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex15Or, arginfo_stub_bitwise_complex15or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex15Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex16Or, arginfo_stub_bitwise_complex16or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex16Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex17Or, arginfo_stub_bitwise_complex17or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex17Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex18Or, arginfo_stub_bitwise_complex18or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex18Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex19Or, arginfo_stub_bitwise_complex19or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex19Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex20Or, arginfo_stub_bitwise_complex20or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex20Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex21Or, arginfo_stub_bitwise_complex21or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex21Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex22Or, arginfo_stub_bitwise_complex22or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex22Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex23Or, arginfo_stub_bitwise_complex23or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex23Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, complex24Or, arginfo_stub_bitwise_complex24or, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, complex24Or, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intShiftLeft, arginfo_stub_bitwise_intshiftleft, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intShiftLeft, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, int2ShiftLeft, arginfo_stub_bitwise_int2shiftleft, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, int2ShiftLeft, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intShiftLeftSimple, arginfo_stub_bitwise_intshiftleftsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intShiftLeftSimple, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intShiftRight, arginfo_stub_bitwise_intshiftright, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intShiftRight, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, int2ShiftRight, arginfo_stub_bitwise_int2shiftright, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, int2ShiftRight, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, intShiftRightSimple, arginfo_stub_bitwise_intshiftrightsimple, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, intShiftRightSimple, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Bitwise, testBitwiseNot, arginfo_stub_bitwise_testbitwisenot, ZEND_ACC_PUBLIC) PHP_ME(Stub_Bitwise, testBitwiseAndNot, arginfo_stub_bitwise_testbitwiseandnot, ZEND_ACC_PUBLIC) PHP_ME(Stub_Bitwise, getInt, arginfo_stub_bitwise_getint, ZEND_ACC_PROTECTED) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Bitwise, testbitwiseXor, arginfo_stub_bitwise_testbitwisexor, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Bitwise, testbitwiseXor, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/branchprediction.zep.c b/ext/stub/branchprediction.zep.c index 0240034271..9d4f7bcfb8 100644 --- a/ext/stub/branchprediction.zep.c +++ b/ext/stub/branchprediction.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(Stub_BranchPrediction, testLikely1) { zval *this_ptr = getThis(); + if (EXPECTED(1 == 1)) { RETURN_BOOL(1); } else { @@ -47,6 +48,14 @@ PHP_METHOD(Stub_BranchPrediction, testLikely2) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -65,6 +74,7 @@ PHP_METHOD(Stub_BranchPrediction, testUnlikely1) { zval *this_ptr = getThis(); + if (EXPECTED(1 == 1)) { RETURN_BOOL(1); } else { @@ -79,6 +89,14 @@ PHP_METHOD(Stub_BranchPrediction, testUnlikely2) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); diff --git a/ext/stub/branchprediction.zep.h b/ext/stub/branchprediction.zep.h index f2d2c48b24..7ba6de0329 100644 --- a/ext/stub/branchprediction.zep.h +++ b/ext/stub/branchprediction.zep.h @@ -23,9 +23,17 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_branchprediction_testunlikely2, 0, 0, 1) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_branchprediction_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_BranchPrediction, testLikely1, arginfo_stub_branchprediction_testlikely1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_BranchPrediction, testLikely1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_BranchPrediction, testLikely2, arginfo_stub_branchprediction_testlikely2, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_BranchPrediction, testUnlikely1, arginfo_stub_branchprediction_testunlikely1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_BranchPrediction, testUnlikely1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_BranchPrediction, testUnlikely2, arginfo_stub_branchprediction_testunlikely2, ZEND_ACC_PUBLIC) PHP_FE_END }; diff --git a/ext/stub/builtin/arraymethods.zep.c b/ext/stub/builtin/arraymethods.zep.c index 26c6bf880b..685d574119 100644 --- a/ext/stub/builtin/arraymethods.zep.c +++ b/ext/stub/builtin/arraymethods.zep.c @@ -37,6 +37,7 @@ PHP_METHOD(Stub_BuiltIn_ArrayMethods, getJoin1) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -68,6 +69,7 @@ PHP_METHOD(Stub_BuiltIn_ArrayMethods, getReversed1) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -99,6 +101,7 @@ PHP_METHOD(Stub_BuiltIn_ArrayMethods, getMap1) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); diff --git a/ext/stub/builtin/arraymethods.zep.h b/ext/stub/builtin/arraymethods.zep.h index 6a936fb439..1e49dcbfc5 100644 --- a/ext/stub/builtin/arraymethods.zep.h +++ b/ext/stub/builtin/arraymethods.zep.h @@ -17,8 +17,20 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_arraymethods_getmap1, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_builtin_arraymethods_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_BuiltIn_ArrayMethods, getJoin1, arginfo_stub_builtin_arraymethods_getjoin1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_BuiltIn_ArrayMethods, getJoin1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_BuiltIn_ArrayMethods, getReversed1, arginfo_stub_builtin_arraymethods_getreversed1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_BuiltIn_ArrayMethods, getReversed1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_BuiltIn_ArrayMethods, getMap1, arginfo_stub_builtin_arraymethods_getmap1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_BuiltIn_ArrayMethods, getMap1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/builtin/charmethods.zep.c b/ext/stub/builtin/charmethods.zep.c index eb4aa099b8..970250328d 100644 --- a/ext/stub/builtin/charmethods.zep.c +++ b/ext/stub/builtin/charmethods.zep.c @@ -35,6 +35,7 @@ PHP_METHOD(Stub_BuiltIn_CharMethods, getHex) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -59,6 +60,14 @@ PHP_METHOD(Stub_BuiltIn_CharMethods, getHexForString) { ZVAL_UNDEF(&_1$$3); ZVAL_UNDEF(&_2$$3); ZVAL_UNDEF(&_3$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); diff --git a/ext/stub/builtin/charmethods.zep.h b/ext/stub/builtin/charmethods.zep.h index 752f6eceae..f3576f4dcb 100644 --- a/ext/stub/builtin/charmethods.zep.h +++ b/ext/stub/builtin/charmethods.zep.h @@ -10,15 +10,15 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_charmethods_gethex, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_charmethods_gethexforstring, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_builtin_charmethods_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_BuiltIn_CharMethods, getHex, arginfo_stub_builtin_charmethods_gethex, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_BuiltIn_CharMethods, getHex, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_BuiltIn_CharMethods, getHexForString, arginfo_stub_builtin_charmethods_gethexforstring, ZEND_ACC_PUBLIC) PHP_FE_END }; diff --git a/ext/stub/builtin/intmethods.zep.c b/ext/stub/builtin/intmethods.zep.c index 6a2d2ba645..cee3ebbef2 100644 --- a/ext/stub/builtin/intmethods.zep.c +++ b/ext/stub/builtin/intmethods.zep.c @@ -36,6 +36,14 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getAbs) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &num_param); @@ -60,6 +68,7 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getAbs1) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, -5); @@ -78,6 +87,14 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getBinary) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &num_param); @@ -101,6 +118,14 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getHex) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &num_param); @@ -124,6 +149,14 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getOctal) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &num_param); @@ -148,6 +181,15 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getPow) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_LONG(num) + Z_PARAM_LONG(exp) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &num_param, &exp_param); @@ -171,6 +213,14 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getSqrt) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &num_param); @@ -191,6 +241,14 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getExp) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &num_param); @@ -212,6 +270,14 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getSin) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &num_param); @@ -230,6 +296,14 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getCos) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &num_param); @@ -248,6 +322,14 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getTan) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &num_param); @@ -261,37 +343,63 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getTan) { PHP_METHOD(Stub_BuiltIn_IntMethods, getAsin) { - zval *num_param = NULL, _0; - zend_long num; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zval *num_param = NULL, _0, _1; + zend_long num, ZEPHIR_LAST_CALL_STATUS; zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(1, 0, &num_param); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &num_param); num = zephir_get_intval(num_param); ZVAL_LONG(&_0, num); - RETURN_DOUBLE(asin(num)); + ZEPHIR_CALL_FUNCTION(&_1, "asin", NULL, 12, &_0); + zephir_check_call_status(); + RETURN_CCTOR(&_1); } PHP_METHOD(Stub_BuiltIn_IntMethods, getAcos) { - zval *num_param = NULL, _0; - zend_long num; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zval *num_param = NULL, _0, _1; + zend_long num, ZEPHIR_LAST_CALL_STATUS; zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(1, 0, &num_param); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &num_param); num = zephir_get_intval(num_param); ZVAL_LONG(&_0, num); - RETURN_DOUBLE(acos(num)); + ZEPHIR_CALL_FUNCTION(&_1, "acos", NULL, 13, &_0); + zephir_check_call_status(); + RETURN_CCTOR(&_1); } @@ -304,6 +412,14 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getAtan) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &num_param); @@ -312,7 +428,7 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getAtan) { ZVAL_LONG(&_0, num); - ZEPHIR_CALL_FUNCTION(&_1, "atan", NULL, 12, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "atan", NULL, 14, &_0); zephir_check_call_status(); RETURN_CCTOR(&_1); @@ -330,6 +446,16 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getLog) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_LONG(num) + Z_PARAM_OPTIONAL + Z_PARAM_LONG(base) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &num_param, &base_param); @@ -344,13 +470,13 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getLog) { if (base == -1) { ZVAL_LONG(&_0$$3, num); - ZEPHIR_CALL_FUNCTION(&_1$$3, "log", NULL, 13, &_0$$3); + ZEPHIR_CALL_FUNCTION(&_1$$3, "log", NULL, 15, &_0$$3); zephir_check_call_status(); RETURN_CCTOR(&_1$$3); } ZVAL_LONG(&_2, num); ZVAL_LONG(&_3, base); - ZEPHIR_CALL_FUNCTION(&_4, "log", NULL, 13, &_2, &_3); + ZEPHIR_CALL_FUNCTION(&_4, "log", NULL, 15, &_2, &_3); zephir_check_call_status(); RETURN_CCTOR(&_4); diff --git a/ext/stub/builtin/intmethods.zep.h b/ext/stub/builtin/intmethods.zep.h index bfc57784b7..f73dae4ad3 100644 --- a/ext/stub/builtin/intmethods.zep.h +++ b/ext/stub/builtin/intmethods.zep.h @@ -20,133 +20,73 @@ PHP_METHOD(Stub_BuiltIn_IntMethods, getAtan); PHP_METHOD(Stub_BuiltIn_IntMethods, getLog); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getabs, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getabs1, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getbinary, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_gethex, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getoctal, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getpow, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, exp, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, exp) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getsqrt, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getexp, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getsin, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getcos, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_gettan, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getasin, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getacos, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getatan, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_intmethods_getlog, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, base, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, base) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_builtin_intmethods_method_entry) { PHP_ME(Stub_BuiltIn_IntMethods, getAbs, arginfo_stub_builtin_intmethods_getabs, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_BuiltIn_IntMethods, getAbs1, arginfo_stub_builtin_intmethods_getabs1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_BuiltIn_IntMethods, getAbs1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_BuiltIn_IntMethods, getBinary, arginfo_stub_builtin_intmethods_getbinary, ZEND_ACC_PUBLIC) PHP_ME(Stub_BuiltIn_IntMethods, getHex, arginfo_stub_builtin_intmethods_gethex, ZEND_ACC_PUBLIC) PHP_ME(Stub_BuiltIn_IntMethods, getOctal, arginfo_stub_builtin_intmethods_getoctal, ZEND_ACC_PUBLIC) diff --git a/ext/stub/builtin/stringmethods.zep.c b/ext/stub/builtin/stringmethods.zep.c index e1f5323674..98ea5a038e 100644 --- a/ext/stub/builtin/stringmethods.zep.c +++ b/ext/stub/builtin/stringmethods.zep.c @@ -39,6 +39,16 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, camelize) { ZVAL_UNDEF(&delimiter_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_STR(str) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(delimiter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &str_param, &delimiter); @@ -67,6 +77,16 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, uncamelize) { ZVAL_UNDEF(&delimiter_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_STR(str) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(delimiter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &str_param, &delimiter); @@ -92,6 +112,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getLength1) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -108,6 +129,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getLength2) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -124,6 +146,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getLength3) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -140,6 +163,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getLength4) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); @@ -160,6 +191,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getLength5) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); @@ -183,6 +222,15 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getIndex) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&needle); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(str) + Z_PARAM_STR(needle) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &str_param, &needle_param); @@ -209,6 +257,16 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getIndexWithPosition) { ZVAL_UNDEF(&needle); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_STR(str) + Z_PARAM_STR(needle) + Z_PARAM_LONG(position) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 3, 0, &str_param, &needle_param, &position_param); @@ -234,6 +292,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getTrimmed) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -253,6 +312,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getTrimmed1) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -275,6 +342,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getLeftTrimmed) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -297,6 +372,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getRightTrimmed) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -319,6 +402,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getLower) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -341,6 +432,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getUpper) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -364,6 +463,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getLowerFirst) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -371,7 +478,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getLowerFirst) { zephir_get_strval(&str, str_param); - ZEPHIR_CALL_FUNCTION(&_0, "lcfirst", NULL, 14, &str); + ZEPHIR_CALL_FUNCTION(&_0, "lcfirst", NULL, 16, &str); zephir_check_call_status(); RETURN_CCTOR(&_0); @@ -386,6 +493,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getUpperFirst) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -410,6 +525,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getFormatted) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -419,7 +542,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getFormatted) { ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "hello %s!"); - ZEPHIR_CALL_FUNCTION(&_1, "sprintf", NULL, 15, &_0, &str); + ZEPHIR_CALL_FUNCTION(&_1, "sprintf", NULL, 17, &_0, &str); zephir_check_call_status(); RETURN_CCTOR(&_1); @@ -434,6 +557,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getMd5) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -457,6 +588,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getSha1) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -464,7 +603,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getSha1) { zephir_get_strval(&str, str_param); - ZEPHIR_CALL_FUNCTION(&_0, "sha1", NULL, 16, &str); + ZEPHIR_CALL_FUNCTION(&_0, "sha1", NULL, 18, &str); zephir_check_call_status(); RETURN_CCTOR(&_0); @@ -480,6 +619,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getNl2br) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -487,7 +634,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getNl2br) { zephir_get_strval(&str, str_param); - ZEPHIR_CALL_FUNCTION(&_0, "nl2br", NULL, 17, &str); + ZEPHIR_CALL_FUNCTION(&_0, "nl2br", NULL, 19, &str); zephir_check_call_status(); RETURN_CCTOR(&_0); @@ -503,6 +650,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getParsedCsv) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -510,7 +665,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getParsedCsv) { zephir_get_strval(&str, str_param); - ZEPHIR_CALL_FUNCTION(&_0, "str_getcsv", NULL, 18, &str); + ZEPHIR_CALL_FUNCTION(&_0, "str_getcsv", NULL, 20, &str); zephir_check_call_status(); RETURN_CCTOR(&_0); @@ -527,6 +682,16 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getParsedJson) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_STR(str) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(assoc) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &str_param, &assoc_param); @@ -557,6 +722,15 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getRepeatted) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(str) + Z_PARAM_LONG(count) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &str_param, &count_param); @@ -566,7 +740,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getRepeatted) { ZVAL_LONG(&_0, count); - ZEPHIR_CALL_FUNCTION(&_1, "str_repeat", NULL, 19, &str, &_0); + ZEPHIR_CALL_FUNCTION(&_1, "str_repeat", NULL, 21, &str, &_0); zephir_check_call_status(); RETURN_CCTOR(&_1); @@ -582,6 +756,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getShuffled) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -589,7 +771,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getShuffled) { zephir_get_strval(&str, str_param); - ZEPHIR_CALL_FUNCTION(&_0, "str_shuffle", NULL, 20, &str); + ZEPHIR_CALL_FUNCTION(&_0, "str_shuffle", NULL, 22, &str); zephir_check_call_status(); RETURN_CCTOR(&_0); @@ -606,6 +788,15 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getSplited) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&del); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(str) + Z_PARAM_STR(del) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &str_param, &del_param); @@ -614,7 +805,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getSplited) { zephir_get_strval(&del, del_param); - ZEPHIR_CALL_FUNCTION(&_0, "str_split", NULL, 21, &str, &del); + ZEPHIR_CALL_FUNCTION(&_0, "str_split", NULL, 23, &str, &del); zephir_check_call_status(); RETURN_CCTOR(&_0); @@ -631,6 +822,15 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getCompare) { ZVAL_UNDEF(&left); ZVAL_UNDEF(&right); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(left) + Z_PARAM_STR(right) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &left_param, &right_param); @@ -639,7 +839,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getCompare) { zephir_get_strval(&right, right_param); - ZEPHIR_CALL_FUNCTION(&_0, "strcmp", NULL, 22, &left, &right); + ZEPHIR_CALL_FUNCTION(&_0, "strcmp", NULL, 24, &left, &right); zephir_check_call_status(); RETURN_CCTOR(&_0); @@ -656,6 +856,15 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getCompareLocale) { ZVAL_UNDEF(&left); ZVAL_UNDEF(&right); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(left) + Z_PARAM_STR(right) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &left_param, &right_param); @@ -664,7 +873,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getCompareLocale) { zephir_get_strval(&right, right_param); - ZEPHIR_CALL_FUNCTION(&_0, "strcoll", NULL, 23, &left, &right); + ZEPHIR_CALL_FUNCTION(&_0, "strcoll", NULL, 25, &left, &right); zephir_check_call_status(); RETURN_CCTOR(&_0); @@ -680,6 +889,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getReversed) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -687,7 +904,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getReversed) { zephir_get_strval(&str, str_param); - ZEPHIR_CALL_FUNCTION(&_0, "strrev", NULL, 24, &str); + ZEPHIR_CALL_FUNCTION(&_0, "strrev", NULL, 26, &str); zephir_check_call_status(); RETURN_CCTOR(&_0); @@ -703,6 +920,14 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getHtmlSpecialChars) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -710,7 +935,7 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getHtmlSpecialChars) { zephir_get_strval(&str, str_param); - ZEPHIR_CALL_FUNCTION(&_0, "htmlspecialchars", NULL, 25, &str); + ZEPHIR_CALL_FUNCTION(&_0, "htmlspecialchars", NULL, 27, &str); zephir_check_call_status(); RETURN_CCTOR(&_0); diff --git a/ext/stub/builtin/stringmethods.zep.h b/ext/stub/builtin/stringmethods.zep.h index 8874962cd9..22cc2eb3e8 100644 --- a/ext/stub/builtin/stringmethods.zep.h +++ b/ext/stub/builtin/stringmethods.zep.h @@ -34,29 +34,13 @@ PHP_METHOD(Stub_BuiltIn_StringMethods, getCompareLocale); PHP_METHOD(Stub_BuiltIn_StringMethods, getReversed); PHP_METHOD(Stub_BuiltIn_StringMethods, getHtmlSpecialChars); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_builtin_stringmethods_camelize, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_builtin_stringmethods_camelize, 0, 1, IS_STRING, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_ARG_INFO(0, delimiter) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_builtin_stringmethods_uncamelize, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_builtin_stringmethods_uncamelize, 0, 1, IS_STRING, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_ARG_INFO(0, delimiter) ZEND_END_ARG_INFO() @@ -70,251 +54,139 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getlength3, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getlength4, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getlength5, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getindex, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, needle, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, needle) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getindexwithposition, 0, 0, 3) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, needle, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, needle) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, position, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, position) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_gettrimmed, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_gettrimmed1, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getlefttrimmed, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getrighttrimmed, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getlower, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getupper, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getlowerfirst, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getupperfirst, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getformatted, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getmd5, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getsha1, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getnl2br, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getparsedcsv, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getparsedjson, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, assoc, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, assoc) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getrepeatted, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, count, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, count) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getshuffled, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getsplited, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, del, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, del) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getcompare, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, left, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, left) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, right, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, right) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getcomparelocale, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, left, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, left) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, right, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, right) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_getreversed, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_builtin_stringmethods_gethtmlspecialchars, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_builtin_stringmethods_method_entry) { PHP_ME(Stub_BuiltIn_StringMethods, camelize, arginfo_stub_builtin_stringmethods_camelize, ZEND_ACC_PUBLIC) PHP_ME(Stub_BuiltIn_StringMethods, uncamelize, arginfo_stub_builtin_stringmethods_uncamelize, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_BuiltIn_StringMethods, getLength1, arginfo_stub_builtin_stringmethods_getlength1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_BuiltIn_StringMethods, getLength1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_BuiltIn_StringMethods, getLength2, arginfo_stub_builtin_stringmethods_getlength2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_BuiltIn_StringMethods, getLength2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_BuiltIn_StringMethods, getLength3, arginfo_stub_builtin_stringmethods_getlength3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_BuiltIn_StringMethods, getLength3, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_BuiltIn_StringMethods, getLength4, arginfo_stub_builtin_stringmethods_getlength4, ZEND_ACC_PUBLIC) PHP_ME(Stub_BuiltIn_StringMethods, getLength5, arginfo_stub_builtin_stringmethods_getlength5, ZEND_ACC_PUBLIC) PHP_ME(Stub_BuiltIn_StringMethods, getIndex, arginfo_stub_builtin_stringmethods_getindex, ZEND_ACC_PUBLIC) PHP_ME(Stub_BuiltIn_StringMethods, getIndexWithPosition, arginfo_stub_builtin_stringmethods_getindexwithposition, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_BuiltIn_StringMethods, getTrimmed, arginfo_stub_builtin_stringmethods_gettrimmed, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_BuiltIn_StringMethods, getTrimmed, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_BuiltIn_StringMethods, getTrimmed1, arginfo_stub_builtin_stringmethods_gettrimmed1, ZEND_ACC_PUBLIC) PHP_ME(Stub_BuiltIn_StringMethods, getLeftTrimmed, arginfo_stub_builtin_stringmethods_getlefttrimmed, ZEND_ACC_PUBLIC) PHP_ME(Stub_BuiltIn_StringMethods, getRightTrimmed, arginfo_stub_builtin_stringmethods_getrighttrimmed, ZEND_ACC_PUBLIC) diff --git a/ext/stub/cast.zep.c b/ext/stub/cast.zep.c index 0fd09c2aca..2f4e6c2817 100644 --- a/ext/stub/cast.zep.c +++ b/ext/stub/cast.zep.c @@ -37,6 +37,7 @@ PHP_METHOD(Stub_Cast, testCharCastFromChar) { zval *this_ptr = getThis(); + RETURN_LONG('a'); } @@ -51,6 +52,7 @@ PHP_METHOD(Stub_Cast, testCharCastFromVariableChar) { + a = 'A'; _0 = a; RETURN_LONG(_0); @@ -65,6 +67,7 @@ PHP_METHOD(Stub_Cast, testStringCastChar) { zval *this_ptr = getThis(); + RETURN_STRING("z"); } @@ -81,6 +84,7 @@ PHP_METHOD(Stub_Cast, testStringCastVariableChar) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); a = 'X'; @@ -95,6 +99,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromFloat) { zval *this_ptr = getThis(); + RETURN_LONG((int) 5.0); } @@ -106,6 +111,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromVariableFloat) { + a = 5.0; RETURN_LONG((int) (a)); @@ -119,6 +125,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromChar) { zval *this_ptr = getThis(); + RETURN_LONG('A'); } @@ -133,6 +140,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromVariableChar) { + a = 'a'; RETURN_LONG(a); @@ -143,6 +151,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromBooleanTrue) { zval *this_ptr = getThis(); + RETURN_LONG(1); } @@ -152,6 +161,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromBooleanFalse) { zval *this_ptr = getThis(); + RETURN_LONG(0); } @@ -163,6 +173,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromVariableBooleanTrue) { + a = 1; RETURN_LONG((int) (a)); @@ -175,6 +186,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromVariableBooleanFalse) { + a = 0; RETURN_LONG((int) (a)); @@ -188,6 +200,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromVariableNull) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -204,6 +217,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromStringValue) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -221,6 +235,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromVariableString) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -237,6 +252,14 @@ PHP_METHOD(Stub_Cast, testIntCastFromParameterString) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); @@ -253,6 +276,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromNull) { zval *this_ptr = getThis(); + RETURN_LONG(0); } @@ -265,6 +289,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromVariableEmptyArray) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -281,6 +306,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromEmptyArray) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -298,6 +324,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromVariableArray) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -328,6 +355,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromArray) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -360,6 +388,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromStdClass) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -380,6 +409,7 @@ PHP_METHOD(Stub_Cast, testIntCastFromVariableStdClass) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -396,6 +426,7 @@ PHP_METHOD(Stub_Cast, testLongCastFromChar) { zval *this_ptr = getThis(); + RETURN_LONG((long) 'a'); } @@ -410,6 +441,7 @@ PHP_METHOD(Stub_Cast, testLongCastFromVariableChar) { + a = 'A'; RETURN_LONG(a); @@ -420,6 +452,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromFloat) { zval *this_ptr = getThis(); + RETURN_DOUBLE(5.0); } @@ -431,6 +464,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromVariableFloat) { + a = 5.0; RETURN_DOUBLE((double) (a)); @@ -441,6 +475,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromBooleanTrue) { zval *this_ptr = getThis(); + RETURN_DOUBLE(1); } @@ -450,6 +485,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromBooleanFalse) { zval *this_ptr = getThis(); + RETURN_DOUBLE(0); } @@ -461,6 +497,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromVariableBooleanTrue) { + a = 1; RETURN_DOUBLE((double) (a)); @@ -473,6 +510,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromVariableBooleanFalse) { + a = 0; RETURN_DOUBLE((double) (a)); @@ -486,6 +524,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromVariableNull) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -499,6 +538,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromNull) { zval *this_ptr = getThis(); + RETURN_DOUBLE(0); } @@ -511,6 +551,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromVariableEmptyArray) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -527,6 +568,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromEmptyArray) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -544,6 +586,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromVariableArray) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -574,6 +617,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromArray) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -606,6 +650,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromStdClass) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -626,6 +671,7 @@ PHP_METHOD(Stub_Cast, testFloatCastFromVariableStdClass) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -642,6 +688,7 @@ PHP_METHOD(Stub_Cast, testDoubleCastFromVChar) { zval *this_ptr = getThis(); + RETURN_DOUBLE((double) 'a'); } @@ -656,6 +703,7 @@ PHP_METHOD(Stub_Cast, testDoubleCastFromVariableChar) { + a = 'A'; RETURN_DOUBLE((double) a); @@ -666,6 +714,7 @@ PHP_METHOD(Stub_Cast, testBooleanCastFromIntTrue1) { zval *this_ptr = getThis(); + RETURN_BOOL((zend_bool) 1); } @@ -675,6 +724,7 @@ PHP_METHOD(Stub_Cast, testBooleanCastFromIntTrue2) { zval *this_ptr = getThis(); + RETURN_BOOL((zend_bool) 1000); } @@ -684,6 +734,7 @@ PHP_METHOD(Stub_Cast, testBooleanCastFromIntFalse) { zval *this_ptr = getThis(); + RETURN_BOOL((zend_bool) 0); } @@ -696,6 +747,7 @@ PHP_METHOD(Stub_Cast, testBooleanCastFromObject) { ZVAL_UNDEF(&simpleObject); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&simpleObject); @@ -712,6 +764,7 @@ PHP_METHOD(Stub_Cast, testBooleanCastFromEmptyArray) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -729,6 +782,7 @@ PHP_METHOD(Stub_Cast, testBooleanCastFromArray) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -757,6 +811,7 @@ PHP_METHOD(Stub_Cast, testBooleanCastFromNull) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -773,6 +828,7 @@ PHP_METHOD(Stub_Cast, testBooleanCastFromChar) { zval *this_ptr = getThis(); + RETURN_BOOL((zend_bool) 'a'); } @@ -787,6 +843,7 @@ PHP_METHOD(Stub_Cast, testBooleanCastFromVariableChar) { + a = 'A'; RETURN_BOOL((zend_bool) a); @@ -800,6 +857,7 @@ PHP_METHOD(Stub_Cast, testObjectCastFromInt) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -817,6 +875,7 @@ PHP_METHOD(Stub_Cast, testObjectCastFromFloat) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -834,6 +893,7 @@ PHP_METHOD(Stub_Cast, testObjectCastFromFalse) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -851,6 +911,7 @@ PHP_METHOD(Stub_Cast, testObjectCastFromTrue) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -868,6 +929,7 @@ PHP_METHOD(Stub_Cast, testObjectCastFromNull) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -886,6 +948,7 @@ PHP_METHOD(Stub_Cast, testObjectCastFromEmptyArray) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -907,6 +970,7 @@ PHP_METHOD(Stub_Cast, testObjectCastFromArray) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -937,6 +1001,7 @@ PHP_METHOD(Stub_Cast, testObjectCastFromEmptyString) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -954,6 +1019,7 @@ PHP_METHOD(Stub_Cast, testObjectCastFromString) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -971,6 +1037,7 @@ PHP_METHOD(Stub_Cast, testCastStdinToInteger) { ZVAL_UNDEF(&handle); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&handle); @@ -987,6 +1054,7 @@ PHP_METHOD(Stub_Cast, testCastStdoutToInteger) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -1002,6 +1070,14 @@ PHP_METHOD(Stub_Cast, testCastFileResourceToInteger) { zval *this_ptr = getThis(); ZVAL_UNDEF(&fileName_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(fileName) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &fileName); @@ -1023,6 +1099,7 @@ PHP_METHOD(Stub_Cast, testArrayCastFromVariableArray) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&uids); @@ -1052,6 +1129,7 @@ PHP_METHOD(Stub_Cast, testArrayCastFromVariableTrue) { ZVAL_UNDEF(&uids); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&uids); @@ -1072,6 +1150,7 @@ PHP_METHOD(Stub_Cast, testArrayCastFromVariableFalse) { ZVAL_UNDEF(&uids); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&uids); @@ -1092,6 +1171,7 @@ PHP_METHOD(Stub_Cast, testArrayCastFromVariableNull) { ZVAL_UNDEF(&uids); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&uids); @@ -1112,6 +1192,7 @@ PHP_METHOD(Stub_Cast, testArrayCastFromVariableInteger) { ZVAL_UNDEF(&uids); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&uids); @@ -1132,6 +1213,7 @@ PHP_METHOD(Stub_Cast, testArrayCastFromVariableFloat) { ZVAL_UNDEF(&uids); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&uids); @@ -1152,6 +1234,7 @@ PHP_METHOD(Stub_Cast, testArrayCastFromVariableString) { ZVAL_UNDEF(&uids); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&uids); @@ -1173,6 +1256,7 @@ PHP_METHOD(Stub_Cast, testArrayCastFromVariableStdClass) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&uids); diff --git a/ext/stub/cast.zep.h b/ext/stub/cast.zep.h index 488cab973f..5679705561 100644 --- a/ext/stub/cast.zep.h +++ b/ext/stub/cast.zep.h @@ -74,359 +74,155 @@ PHP_METHOD(Stub_Cast, testArrayCastFromVariableFloat); PHP_METHOD(Stub_Cast, testArrayCastFromVariableString); PHP_METHOD(Stub_Cast, testArrayCastFromVariableStdClass); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testcharcastfromchar, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testcharcastfromchar, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testcharcastfromvariablechar, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testcharcastfromvariablechar, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_teststringcastchar, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_teststringcastchar, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_teststringcastvariablechar, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_teststringcastvariablechar, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromfloat, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromfloat, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablefloat, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablefloat, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromchar, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromchar, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablechar, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablechar, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfrombooleantrue, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfrombooleantrue, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfrombooleanfalse, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfrombooleanfalse, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablebooleantrue, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablebooleantrue, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablebooleanfalse, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablebooleanfalse, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablenull, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablenull, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromstringvalue, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromstringvalue, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablestring, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablestring, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromparameterstring, 0, 1, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromparameterstring, 0, 1, IS_LONG, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromnull, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromnull, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariableemptyarray, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariableemptyarray, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromemptyarray, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromemptyarray, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablearray, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablearray, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromarray, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromarray, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromstdclass, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromstdclass, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablestdclass, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testintcastfromvariablestdclass, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testlongcastfromchar, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testlongcastfromchar, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testlongcastfromvariablechar, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testlongcastfromvariablechar, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromfloat, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromfloat, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablefloat, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablefloat, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfrombooleantrue, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfrombooleantrue, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfrombooleanfalse, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfrombooleanfalse, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablebooleantrue, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablebooleantrue, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablebooleanfalse, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablebooleanfalse, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablenull, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablenull, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromnull, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromnull, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariableemptyarray, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariableemptyarray, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromemptyarray, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromemptyarray, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablearray, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablearray, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromarray, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromarray, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromstdclass, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromstdclass, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablestdclass, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testfloatcastfromvariablestdclass, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testdoublecastfromvchar, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testdoublecastfromvchar, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testdoublecastfromvariablechar, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testdoublecastfromvariablechar, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfrominttrue1, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfrominttrue1, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfrominttrue2, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfrominttrue2, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromintfalse, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromintfalse, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromobject, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromobject, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromemptyarray, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromemptyarray, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromarray, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromarray, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromnull, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromnull, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromchar, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromchar, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromvariablechar, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testbooleancastfromvariablechar, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_cast_testobjectcastfromint, 0, 0, 0) @@ -456,82 +252,38 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_cast_testobjectcastfromstring, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testcaststdintointeger, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testcaststdintointeger, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testcaststdouttointeger, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testcaststdouttointeger, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testcastfileresourcetointeger, 0, 1, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testcastfileresourcetointeger, 0, 1, IS_LONG, NULL, 0) -#endif ZEND_ARG_INFO(0, fileName) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablearray, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablearray, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariabletrue, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariabletrue, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablefalse, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablefalse, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablenull, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablenull, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariableinteger, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariableinteger, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablefloat, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablefloat, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablestring, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablestring, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablestdclass, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_cast_testarraycastfromvariablestdclass, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_cast_method_entry) { @@ -585,15 +337,51 @@ ZEPHIR_INIT_FUNCS(stub_cast_method_entry) { PHP_ME(Stub_Cast, testBooleanCastFromNull, arginfo_stub_cast_testbooleancastfromnull, ZEND_ACC_PUBLIC) PHP_ME(Stub_Cast, testBooleanCastFromChar, arginfo_stub_cast_testbooleancastfromchar, ZEND_ACC_PUBLIC) PHP_ME(Stub_Cast, testBooleanCastFromVariableChar, arginfo_stub_cast_testbooleancastfromvariablechar, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Cast, testObjectCastFromInt, arginfo_stub_cast_testobjectcastfromint, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Cast, testObjectCastFromInt, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Cast, testObjectCastFromFloat, arginfo_stub_cast_testobjectcastfromfloat, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Cast, testObjectCastFromFloat, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Cast, testObjectCastFromFalse, arginfo_stub_cast_testobjectcastfromfalse, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Cast, testObjectCastFromFalse, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Cast, testObjectCastFromTrue, arginfo_stub_cast_testobjectcastfromtrue, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Cast, testObjectCastFromTrue, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Cast, testObjectCastFromNull, arginfo_stub_cast_testobjectcastfromnull, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Cast, testObjectCastFromNull, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Cast, testObjectCastFromEmptyArray, arginfo_stub_cast_testobjectcastfromemptyarray, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Cast, testObjectCastFromEmptyArray, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Cast, testObjectCastFromArray, arginfo_stub_cast_testobjectcastfromarray, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Cast, testObjectCastFromArray, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Cast, testObjectCastFromEmptyString, arginfo_stub_cast_testobjectcastfromemptystring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Cast, testObjectCastFromEmptyString, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Cast, testObjectCastFromString, arginfo_stub_cast_testobjectcastfromstring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Cast, testObjectCastFromString, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Cast, testCastStdinToInteger, arginfo_stub_cast_testcaststdintointeger, ZEND_ACC_PUBLIC) PHP_ME(Stub_Cast, testCastStdoutToInteger, arginfo_stub_cast_testcaststdouttointeger, ZEND_ACC_PUBLIC) PHP_ME(Stub_Cast, testCastFileResourceToInteger, arginfo_stub_cast_testcastfileresourcetointeger, ZEND_ACC_PUBLIC) diff --git a/ext/stub/cblock.zep.c b/ext/stub/cblock.zep.c index 3b80e926a8..67c3470f86 100644 --- a/ext/stub/cblock.zep.c +++ b/ext/stub/cblock.zep.c @@ -51,6 +51,7 @@ PHP_METHOD(Stub_Cblock, testCblock1) { + a = 0; a = MAX_FACTOR; @@ -66,6 +67,7 @@ PHP_METHOD(Stub_Cblock, testCblock2) { + a = 0; a = fibonacci(MAX_FACTOR); diff --git a/ext/stub/cblock.zep.h b/ext/stub/cblock.zep.h index 15c9ffa72d..2787016396 100644 --- a/ext/stub/cblock.zep.h +++ b/ext/stub/cblock.zep.h @@ -13,7 +13,15 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_cblock_testcblock2, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_cblock_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Cblock, testCblock1, arginfo_stub_cblock_testcblock1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Cblock, testCblock1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Cblock, testCblock2, arginfo_stub_cblock_testcblock2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Cblock, testCblock2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/chars.zep.c b/ext/stub/chars.zep.c index 711183baef..a32e13946d 100644 --- a/ext/stub/chars.zep.c +++ b/ext/stub/chars.zep.c @@ -35,6 +35,7 @@ PHP_METHOD(Stub_Chars, sumChars1) { + ch = 'A'; chlower = (ch + 32); RETURN_LONG(chlower); @@ -47,6 +48,14 @@ PHP_METHOD(Stub_Chars, sumChars2) { char ch, chlower = 0; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(ch) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &ch_param); @@ -65,6 +74,7 @@ PHP_METHOD(Stub_Chars, diffChars1) { + ch = 'a'; chlower = (ch - 32); RETURN_LONG(chlower); @@ -77,6 +87,14 @@ PHP_METHOD(Stub_Chars, diffChars2) { char ch, chlower = 0; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(ch) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &ch_param); diff --git a/ext/stub/chars.zep.h b/ext/stub/chars.zep.h index f5e4a4b473..0de15250d1 100644 --- a/ext/stub/chars.zep.h +++ b/ext/stub/chars.zep.h @@ -8,42 +8,18 @@ PHP_METHOD(Stub_Chars, sumChars2); PHP_METHOD(Stub_Chars, diffChars1); PHP_METHOD(Stub_Chars, diffChars2); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_chars_sumchars1, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_chars_sumchars1, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_chars_sumchars2, 0, 1, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_chars_sumchars2, 0, 1, IS_LONG, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, ch, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, ch) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_chars_diffchars1, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_chars_diffchars1, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_chars_diffchars2, 0, 1, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_chars_diffchars2, 0, 1, IS_LONG, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, ch, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, ch) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_chars_method_entry) { diff --git a/ext/stub/closures.zep.c b/ext/stub/closures.zep.c index 306963c307..d13e5199c1 100644 --- a/ext/stub/closures.zep.c +++ b/ext/stub/closures.zep.c @@ -31,6 +31,7 @@ PHP_METHOD(Stub_Closures, simple1) { zval *this_ptr = getThis(); + zephir_create_closure_ex(return_value, NULL, stub_1__closure_ce, SL("__invoke")); return; @@ -41,6 +42,7 @@ PHP_METHOD(Stub_Closures, simple2) { zval *this_ptr = getThis(); + zephir_create_closure_ex(return_value, NULL, stub_2__closure_ce, SL("__invoke")); return; @@ -51,6 +53,7 @@ PHP_METHOD(Stub_Closures, simple3) { zval *this_ptr = getThis(); + zephir_create_closure_ex(return_value, NULL, stub_3__closure_ce, SL("__invoke")); return; @@ -61,6 +64,7 @@ PHP_METHOD(Stub_Closures, simple4) { zval *this_ptr = getThis(); + zephir_create_closure_ex(return_value, NULL, stub_4__closure_ce, SL("__invoke")); return; @@ -71,6 +75,7 @@ PHP_METHOD(Stub_Closures, simple5) { zval *this_ptr = getThis(); + zephir_create_closure_ex(return_value, NULL, stub_5__closure_ce, SL("__invoke")); return; @@ -81,6 +86,7 @@ PHP_METHOD(Stub_Closures, arrow1) { zval *this_ptr = getThis(); + zephir_create_closure_ex(return_value, NULL, stub_6__closure_ce, SL("__invoke")); return; @@ -91,6 +97,7 @@ PHP_METHOD(Stub_Closures, arrow2) { zval *this_ptr = getThis(); + zephir_create_closure_ex(return_value, NULL, stub_7__closure_ce, SL("__invoke")); return; @@ -105,6 +112,7 @@ PHP_METHOD(Stub_Closures, testUseCommand) { ZVAL_UNDEF(&_0); + abc = 1; zephir_create_closure_ex(return_value, NULL, stub_8__closure_ce, SL("__invoke")); ZEPHIR_INIT_ZVAL_NREF(_0); @@ -122,6 +130,14 @@ PHP_METHOD(Stub_Closures, issue1860) { zval *this_ptr = getThis(); ZVAL_UNDEF(&abc); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(abc) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &abc_param); diff --git a/ext/stub/closures.zep.h b/ext/stub/closures.zep.h index 60c24a2ad7..e9e69f81a4 100644 --- a/ext/stub/closures.zep.h +++ b/ext/stub/closures.zep.h @@ -42,14 +42,46 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_closures_issue1860, 0, 0, 1) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_closures_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Closures, simple1, arginfo_stub_closures_simple1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Closures, simple1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Closures, simple2, arginfo_stub_closures_simple2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Closures, simple2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Closures, simple3, arginfo_stub_closures_simple3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Closures, simple3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Closures, simple4, arginfo_stub_closures_simple4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Closures, simple4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Closures, simple5, arginfo_stub_closures_simple5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Closures, simple5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Closures, arrow1, arginfo_stub_closures_arrow1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Closures, arrow1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Closures, arrow2, arginfo_stub_closures_arrow2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Closures, arrow2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Closures, testUseCommand, arginfo_stub_closures_testusecommand, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Closures, testUseCommand, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Closures, issue1860, arginfo_stub_closures_issue1860, ZEND_ACC_PUBLIC) PHP_FE_END }; diff --git a/ext/stub/compare.zep.c b/ext/stub/compare.zep.c index 27c8d98fd6..bcde08a54a 100644 --- a/ext/stub/compare.zep.c +++ b/ext/stub/compare.zep.c @@ -35,6 +35,15 @@ PHP_METHOD(Stub_Compare, isLessInt) { zend_long a, b; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_LONG(a) + Z_PARAM_LONG(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a_param, &b_param); @@ -52,6 +61,15 @@ PHP_METHOD(Stub_Compare, isGreaterEqual) { zend_long a, b; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_LONG(a) + Z_PARAM_LONG(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a_param, &b_param); @@ -69,6 +87,15 @@ PHP_METHOD(Stub_Compare, isLessDouble) { double a, b; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a_param, &b_param); @@ -86,6 +113,14 @@ PHP_METHOD(Stub_Compare, isLessThenPi) { double a; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a_param); @@ -102,6 +137,14 @@ PHP_METHOD(Stub_Compare, isMoreThenPi) { double a; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a_param); @@ -123,6 +166,14 @@ PHP_METHOD(Stub_Compare, testVarWithStringEquals) { zval *this_ptr = getThis(); ZVAL_UNDEF(&str); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str_param); @@ -166,6 +217,14 @@ PHP_METHOD(Stub_Compare, testVarEqualsNull) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -184,6 +243,14 @@ PHP_METHOD(Stub_Compare, testNullEqualsVar) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -203,6 +270,7 @@ PHP_METHOD(Stub_Compare, testNotIdenticalZeroVar) { + a = 5; RETURN_BOOL(0 != a); @@ -215,6 +283,7 @@ PHP_METHOD(Stub_Compare, testNotIdenticalZeroInt) { + a = 5; RETURN_BOOL(0 != a); @@ -227,6 +296,7 @@ PHP_METHOD(Stub_Compare, testNotIdenticalZeroLong) { + a = 5; RETURN_BOOL(0 != a); diff --git a/ext/stub/compare.zep.h b/ext/stub/compare.zep.h index 4f74a29dee..71df3fed42 100644 --- a/ext/stub/compare.zep.h +++ b/ext/stub/compare.zep.h @@ -16,66 +16,30 @@ PHP_METHOD(Stub_Compare, testNotIdenticalZeroInt); PHP_METHOD(Stub_Compare, testNotIdenticalZeroLong); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_compare_islessint, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_compare_isgreaterequal, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_compare_islessdouble, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, a) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_compare_islessthenpi, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_compare_ismorethenpi, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_compare_testvarwithstringequals, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_compare_testvarequalsnull, 0, 0, 1) @@ -104,8 +68,20 @@ ZEPHIR_INIT_FUNCS(stub_compare_method_entry) { PHP_ME(Stub_Compare, testVarWithStringEquals, arginfo_stub_compare_testvarwithstringequals, ZEND_ACC_PUBLIC) PHP_ME(Stub_Compare, testVarEqualsNull, arginfo_stub_compare_testvarequalsnull, ZEND_ACC_PUBLIC) PHP_ME(Stub_Compare, testNullEqualsVar, arginfo_stub_compare_testnullequalsvar, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Compare, testNotIdenticalZeroVar, arginfo_stub_compare_testnotidenticalzerovar, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Compare, testNotIdenticalZeroVar, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Compare, testNotIdenticalZeroInt, arginfo_stub_compare_testnotidenticalzeroint, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Compare, testNotIdenticalZeroInt, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Compare, testNotIdenticalZeroLong, arginfo_stub_compare_testnotidenticalzerolong, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Compare, testNotIdenticalZeroLong, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/concat.zep.c b/ext/stub/concat.zep.c index 837245a91c..590289f226 100644 --- a/ext/stub/concat.zep.c +++ b/ext/stub/concat.zep.c @@ -36,6 +36,7 @@ PHP_METHOD(Stub_Concat, getTestProperty) { ZVAL_UNDEF(&_0); + zephir_read_static_property_ce(&_0, stub_concat_ce, SL("testProperty"), PH_NOISY_CC | PH_READONLY); RETURN_CTORW(&_0); @@ -50,6 +51,14 @@ PHP_METHOD(Stub_Concat, testConcatBySelfProperty) { ZVAL_UNDEF(&title); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(title) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &title_param); @@ -75,6 +84,7 @@ PHP_METHOD(Stub_Concat, testConcat1) { ZVAL_UNDEF(&url); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&url); @@ -97,6 +107,7 @@ PHP_METHOD(Stub_Concat, testConcat2) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&url); @@ -126,6 +137,7 @@ PHP_METHOD(Stub_Concat, testConcat3) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -154,6 +166,14 @@ PHP_METHOD(Stub_Concat, testConcat4) { ZVAL_UNDEF(&query); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &value); @@ -192,6 +212,14 @@ PHP_METHOD(Stub_Concat, testConcat5) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&retval); ZVAL_UNDEF(&left); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(number) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &number_param); diff --git a/ext/stub/concat.zep.h b/ext/stub/concat.zep.h index fb937cbf11..751d2c51b5 100644 --- a/ext/stub/concat.zep.h +++ b/ext/stub/concat.zep.h @@ -11,70 +11,29 @@ PHP_METHOD(Stub_Concat, testConcat3); PHP_METHOD(Stub_Concat, testConcat4); PHP_METHOD(Stub_Concat, testConcat5); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_gettestproperty, 0, 0, IS_STRING, 1) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_gettestproperty, 0, 0, IS_STRING, NULL, 1) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcatbyselfproperty, 0, 1, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcatbyselfproperty, 0, 1, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_concat_testconcatbyselfproperty, 0, 0, 1) -#define arginfo_stub_concat_testconcatbyselfproperty NULL -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, title, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, title) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcat1, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcat1, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcat2, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcat2, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcat3, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcat3, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcat4, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcat4, 0, 1, IS_STRING, NULL, 0) -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcat5, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_concat_testconcat5, 0, 1, IS_STRING, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, number, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, number) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_concat_method_entry) { diff --git a/ext/stub/constants.zep.c b/ext/stub/constants.zep.c index ed6e4d89e0..c6221e1716 100644 --- a/ext/stub/constants.zep.c +++ b/ext/stub/constants.zep.c @@ -86,6 +86,7 @@ PHP_METHOD(Stub_Constants, getPropWsVarsGet) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propWsVarsGet"); } @@ -95,6 +96,7 @@ PHP_METHOD(Stub_Constants, getPropertyC1) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propertyC1"); } @@ -104,6 +106,7 @@ PHP_METHOD(Stub_Constants, getPropertyC2) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propertyC2"); } @@ -113,6 +116,7 @@ PHP_METHOD(Stub_Constants, getPropertyC3) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propertyC3"); } @@ -122,6 +126,7 @@ PHP_METHOD(Stub_Constants, getPropertyC4) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propertyC4"); } @@ -131,6 +136,7 @@ PHP_METHOD(Stub_Constants, getPropertyC5) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propertyC5"); } @@ -140,6 +146,7 @@ PHP_METHOD(Stub_Constants, getPropertyC6) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propertyC6"); } @@ -149,6 +156,7 @@ PHP_METHOD(Stub_Constants, getPropertyC7) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propertyC7"); } @@ -158,6 +166,7 @@ PHP_METHOD(Stub_Constants, getPropertyC8) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propertyC8"); } @@ -169,6 +178,7 @@ PHP_METHOD(Stub_Constants, getPropertyC9) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propertyC9"); } @@ -178,6 +188,7 @@ PHP_METHOD(Stub_Constants, testReadConstant) { zval *this_ptr = getThis(); + RETURN_LONG(3); } @@ -187,6 +198,7 @@ PHP_METHOD(Stub_Constants, testReadClassConstant1) { zval *this_ptr = getThis(); + RETURN_LONG(10); } @@ -196,6 +208,7 @@ PHP_METHOD(Stub_Constants, testReadClassConstant2) { zval *this_ptr = getThis(); + RETURN_LONG(10); } @@ -205,6 +218,7 @@ PHP_METHOD(Stub_Constants, testReadClassConstant3) { zval *this_ptr = getThis(); + RETURN_LONG(10); } @@ -214,6 +228,7 @@ PHP_METHOD(Stub_Constants, testPHPVersionEnvConstant) { zval *this_ptr = getThis(); + ZEPHIR_GET_CONSTANT(return_value, "PHP_VERSION"); return; @@ -224,6 +239,7 @@ PHP_METHOD(Stub_Constants, testClassMagicConstant) { zval *this_ptr = getThis(); + RETURN_STRING("Stub\\Constants"); } @@ -233,6 +249,7 @@ PHP_METHOD(Stub_Constants, testMethodMagicConstant) { zval *this_ptr = getThis(); + RETURN_STRING("Constants:testMethodMagicConstant"); } @@ -242,6 +259,7 @@ PHP_METHOD(Stub_Constants, testFunctionMagicConstant) { zval *this_ptr = getThis(); + RETURN_STRING("testFunctionMagicConstant"); } @@ -251,6 +269,7 @@ PHP_METHOD(Stub_Constants, testNamespaceMagicConstant) { zval *this_ptr = getThis(); + RETURN_STRING("Stub"); } @@ -260,6 +279,7 @@ PHP_METHOD(Stub_Constants, testDirConstant) { zval *this_ptr = getThis(); + RETURN_NULL(); } @@ -272,6 +292,7 @@ PHP_METHOD(Stub_Constants, testPHPVersionEnvConstantInExpValue) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -293,6 +314,7 @@ PHP_METHOD(Stub_Constants, testStringDelimiterConstantDoubleQuoted) { ZVAL_UNDEF(&delimiter); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&delimiter); @@ -309,6 +331,7 @@ PHP_METHOD(Stub_Constants, testStringConstantWithVars) { ZVAL_UNDEF(&property); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&property); @@ -322,6 +345,7 @@ PHP_METHOD(Stub_Constants, testStringPropertyWithVarsAssigned) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propWsVarsAssigned"); } @@ -331,6 +355,7 @@ PHP_METHOD(Stub_Constants, testStringPropertyWithVarsGet) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propWsVarsGet"); } diff --git a/ext/stub/constants.zep.h b/ext/stub/constants.zep.h index 7d43f80357..1c7f8c870d 100644 --- a/ext/stub/constants.zep.h +++ b/ext/stub/constants.zep.h @@ -105,30 +105,130 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_constants_teststringpropertywithvarsget, 0, ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_constants_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, getPropWsVarsGet, arginfo_stub_constants_getpropwsvarsget, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, getPropWsVarsGet, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, getPropertyC1, arginfo_stub_constants_getpropertyc1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, getPropertyC1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, getPropertyC2, arginfo_stub_constants_getpropertyc2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, getPropertyC2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, getPropertyC3, arginfo_stub_constants_getpropertyc3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, getPropertyC3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, getPropertyC4, arginfo_stub_constants_getpropertyc4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, getPropertyC4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, getPropertyC5, arginfo_stub_constants_getpropertyc5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, getPropertyC5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, getPropertyC6, arginfo_stub_constants_getpropertyc6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, getPropertyC6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, getPropertyC7, arginfo_stub_constants_getpropertyc7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, getPropertyC7, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, getPropertyC8, arginfo_stub_constants_getpropertyc8, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, getPropertyC8, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, getPropertyC9, arginfo_stub_constants_getpropertyc9, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, getPropertyC9, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testReadConstant, arginfo_stub_constants_testreadconstant, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testReadConstant, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testReadClassConstant1, arginfo_stub_constants_testreadclassconstant1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testReadClassConstant1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testReadClassConstant2, arginfo_stub_constants_testreadclassconstant2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testReadClassConstant2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testReadClassConstant3, arginfo_stub_constants_testreadclassconstant3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testReadClassConstant3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testPHPVersionEnvConstant, arginfo_stub_constants_testphpversionenvconstant, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testPHPVersionEnvConstant, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testClassMagicConstant, arginfo_stub_constants_testclassmagicconstant, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testClassMagicConstant, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testMethodMagicConstant, arginfo_stub_constants_testmethodmagicconstant, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testMethodMagicConstant, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testFunctionMagicConstant, arginfo_stub_constants_testfunctionmagicconstant, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testFunctionMagicConstant, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testNamespaceMagicConstant, arginfo_stub_constants_testnamespacemagicconstant, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testNamespaceMagicConstant, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testDirConstant, arginfo_stub_constants_testdirconstant, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testDirConstant, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testPHPVersionEnvConstantInExpValue, arginfo_stub_constants_testphpversionenvconstantinexpvalue, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testPHPVersionEnvConstantInExpValue, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testStringDelimiterConstantDoubleQuoted, arginfo_stub_constants_teststringdelimiterconstantdoublequoted, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testStringDelimiterConstantDoubleQuoted, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testStringConstantWithVars, arginfo_stub_constants_teststringconstantwithvars, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testStringConstantWithVars, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testStringPropertyWithVarsAssigned, arginfo_stub_constants_teststringpropertywithvarsassigned, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testStringPropertyWithVarsAssigned, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Constants, testStringPropertyWithVarsGet, arginfo_stub_constants_teststringpropertywithvarsget, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Constants, testStringPropertyWithVarsGet, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/constantsinterface.zep.c b/ext/stub/constantsinterface.zep.c index d456ff8260..ef314d3e22 100644 --- a/ext/stub/constantsinterface.zep.c +++ b/ext/stub/constantsinterface.zep.c @@ -29,6 +29,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInterfaceConstant1) { zval *this_ptr = getThis(); + RETURN_NULL(); } @@ -38,6 +39,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInterfaceConstant2) { zval *this_ptr = getThis(); + RETURN_BOOL(0); } @@ -47,6 +49,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInterfaceConstant3) { zval *this_ptr = getThis(); + RETURN_BOOL(1); } @@ -56,6 +59,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInterfaceConstant4) { zval *this_ptr = getThis(); + RETURN_LONG(10); } @@ -65,6 +69,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInterfaceConstant5) { zval *this_ptr = getThis(); + RETURN_DOUBLE(10.25); } @@ -74,6 +79,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInterfaceConstant6) { zval *this_ptr = getThis(); + RETURN_STRING("test"); } @@ -83,6 +89,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant1) { zval *this_ptr = getThis(); + RETURN_NULL(); } @@ -92,6 +99,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant2) { zval *this_ptr = getThis(); + RETURN_BOOL(0); } @@ -101,6 +109,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant3) { zval *this_ptr = getThis(); + RETURN_BOOL(1); } @@ -110,6 +119,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant4) { zval *this_ptr = getThis(); + RETURN_LONG(10); } @@ -119,6 +129,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant5) { zval *this_ptr = getThis(); + RETURN_DOUBLE(10.25); } @@ -128,6 +139,7 @@ PHP_METHOD(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant6) { zval *this_ptr = getThis(); + RETURN_STRING("test"); } diff --git a/ext/stub/constantsinterface.zep.h b/ext/stub/constantsinterface.zep.h index 6a2b295107..e9a940d24a 100644 --- a/ext/stub/constantsinterface.zep.h +++ b/ext/stub/constantsinterface.zep.h @@ -53,17 +53,65 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_constantsinterface_testreadinheritancefromin ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_constantsinterface_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant1, arginfo_stub_constantsinterface_testreadinterfaceconstant1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant2, arginfo_stub_constantsinterface_testreadinterfaceconstant2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant3, arginfo_stub_constantsinterface_testreadinterfaceconstant3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant4, arginfo_stub_constantsinterface_testreadinterfaceconstant4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant5, arginfo_stub_constantsinterface_testreadinterfaceconstant5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant6, arginfo_stub_constantsinterface_testreadinterfaceconstant6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInterfaceConstant6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant1, arginfo_stub_constantsinterface_testreadinheritancefrominterfaceconstant1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant2, arginfo_stub_constantsinterface_testreadinheritancefrominterfaceconstant2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant3, arginfo_stub_constantsinterface_testreadinheritancefrominterfaceconstant3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant4, arginfo_stub_constantsinterface_testreadinheritancefrominterfaceconstant4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant5, arginfo_stub_constantsinterface_testreadinheritancefrominterfaceconstant5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant6, arginfo_stub_constantsinterface_testreadinheritancefrominterfaceconstant6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterface, testReadInheritanceFromInterfaceConstant6, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/constantsinterfacea.zep.c b/ext/stub/constantsinterfacea.zep.c index 556d231c81..3cdeb1dc8d 100644 --- a/ext/stub/constantsinterfacea.zep.c +++ b/ext/stub/constantsinterfacea.zep.c @@ -29,6 +29,7 @@ PHP_METHOD(Stub_ConstantsInterfaceA, testReadInterfaceConstant1) { zval *this_ptr = getThis(); + RETURN_NULL(); } @@ -38,6 +39,7 @@ PHP_METHOD(Stub_ConstantsInterfaceA, testReadInterfaceConstant2) { zval *this_ptr = getThis(); + RETURN_BOOL(0); } @@ -47,6 +49,7 @@ PHP_METHOD(Stub_ConstantsInterfaceA, testReadInterfaceConstant3) { zval *this_ptr = getThis(); + RETURN_BOOL(1); } @@ -56,6 +59,7 @@ PHP_METHOD(Stub_ConstantsInterfaceA, testReadInterfaceConstant4) { zval *this_ptr = getThis(); + RETURN_LONG(10); } @@ -65,6 +69,7 @@ PHP_METHOD(Stub_ConstantsInterfaceA, testReadInterfaceConstant5) { zval *this_ptr = getThis(); + RETURN_DOUBLE(10.25); } @@ -74,6 +79,7 @@ PHP_METHOD(Stub_ConstantsInterfaceA, testReadInterfaceConstant6) { zval *this_ptr = getThis(); + RETURN_STRING("test"); } diff --git a/ext/stub/constantsinterfacea.zep.h b/ext/stub/constantsinterfacea.zep.h index a0677b6960..b332767b6a 100644 --- a/ext/stub/constantsinterfacea.zep.h +++ b/ext/stub/constantsinterfacea.zep.h @@ -29,11 +29,35 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_constantsinterfacea_testreadinterfaceconstan ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_constantsinterfacea_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant1, arginfo_stub_constantsinterfacea_testreadinterfaceconstant1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant2, arginfo_stub_constantsinterfacea_testreadinterfaceconstant2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant3, arginfo_stub_constantsinterfacea_testreadinterfaceconstant3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant4, arginfo_stub_constantsinterfacea_testreadinterfaceconstant4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant5, arginfo_stub_constantsinterfacea_testreadinterfaceconstant5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant6, arginfo_stub_constantsinterfacea_testreadinterfaceconstant6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceA, testReadInterfaceConstant6, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/constantsinterfaceb.zep.c b/ext/stub/constantsinterfaceb.zep.c index d0b797eafa..627adf4562 100644 --- a/ext/stub/constantsinterfaceb.zep.c +++ b/ext/stub/constantsinterfaceb.zep.c @@ -29,6 +29,7 @@ PHP_METHOD(Stub_ConstantsInterfaceB, testReadInterfaceConstant1) { zval *this_ptr = getThis(); + RETURN_NULL(); } @@ -38,6 +39,7 @@ PHP_METHOD(Stub_ConstantsInterfaceB, testReadInterfaceConstant2) { zval *this_ptr = getThis(); + RETURN_BOOL(0); } @@ -47,6 +49,7 @@ PHP_METHOD(Stub_ConstantsInterfaceB, testReadInterfaceConstant3) { zval *this_ptr = getThis(); + RETURN_BOOL(1); } @@ -56,6 +59,7 @@ PHP_METHOD(Stub_ConstantsInterfaceB, testReadInterfaceConstant4) { zval *this_ptr = getThis(); + RETURN_LONG(10); } @@ -65,6 +69,7 @@ PHP_METHOD(Stub_ConstantsInterfaceB, testReadInterfaceConstant5) { zval *this_ptr = getThis(); + RETURN_DOUBLE(10.25); } @@ -74,6 +79,7 @@ PHP_METHOD(Stub_ConstantsInterfaceB, testReadInterfaceConstant6) { zval *this_ptr = getThis(); + RETURN_STRING("test"); } diff --git a/ext/stub/constantsinterfaceb.zep.h b/ext/stub/constantsinterfaceb.zep.h index d3e2550fcf..a643c4dc33 100644 --- a/ext/stub/constantsinterfaceb.zep.h +++ b/ext/stub/constantsinterfaceb.zep.h @@ -29,11 +29,35 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_constantsinterfaceb_testreadinterfaceconstan ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_constantsinterfaceb_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant1, arginfo_stub_constantsinterfaceb_testreadinterfaceconstant1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant2, arginfo_stub_constantsinterfaceb_testreadinterfaceconstant2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant3, arginfo_stub_constantsinterfaceb_testreadinterfaceconstant3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant4, arginfo_stub_constantsinterfaceb_testreadinterfaceconstant4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant5, arginfo_stub_constantsinterfaceb_testreadinterfaceconstant5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant6, arginfo_stub_constantsinterfaceb_testreadinterfaceconstant6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ConstantsInterfaceB, testReadInterfaceConstant6, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/declaretest.zep.c b/ext/stub/declaretest.zep.c index 5979363a54..a252963fc7 100644 --- a/ext/stub/declaretest.zep.c +++ b/ext/stub/declaretest.zep.c @@ -36,6 +36,7 @@ PHP_METHOD(Stub_DeclareTest, testStringDeclare1) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -52,6 +53,7 @@ PHP_METHOD(Stub_DeclareTest, testStringDeclare2) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -67,6 +69,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare1) { + a = 1; RETURN_LONG(a); @@ -79,6 +82,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare2) { + a = 1; RETURN_LONG(a); @@ -91,6 +95,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare3) { + a = 1.0; RETURN_DOUBLE(a); @@ -103,6 +108,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare4) { + a = 1.0; RETURN_DOUBLE(a); @@ -115,6 +121,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare5) { + a = 'A'; RETURN_LONG(a); @@ -127,6 +134,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare6) { + a = 'A'; RETURN_LONG(a); @@ -139,6 +147,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare7) { + a = 1; RETURN_LONG(a); @@ -151,6 +160,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare8) { + a = 1; RETURN_BOOL(a); @@ -163,6 +173,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare9) { + a = 0; RETURN_BOOL(a); @@ -175,6 +186,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare10) { + a = 10; RETURN_LONG(a); @@ -187,6 +199,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare11) { + a = 10.5; RETURN_DOUBLE(a); @@ -199,6 +212,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare12) { + a = 0; RETURN_BOOL(a); @@ -211,6 +225,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare13) { + a = 1; RETURN_BOOL(a); @@ -224,6 +239,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare14) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -240,6 +256,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclare15) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -257,6 +274,7 @@ PHP_METHOD(Stub_DeclareTest, testDeclareMcallExpression) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_CALL_METHOD(&a, this_ptr, "testdeclare14", NULL, 0); diff --git a/ext/stub/declaretest.zep.h b/ext/stub/declaretest.zep.h index 8ddc726ad8..bd341be029 100644 --- a/ext/stub/declaretest.zep.h +++ b/ext/stub/declaretest.zep.h @@ -77,23 +77,95 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_declaretest_testdeclaremcallexpression, 0, 0 ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_declaretest_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testStringDeclare1, arginfo_stub_declaretest_teststringdeclare1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testStringDeclare1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testStringDeclare2, arginfo_stub_declaretest_teststringdeclare2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testStringDeclare2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare1, arginfo_stub_declaretest_testdeclare1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare2, arginfo_stub_declaretest_testdeclare2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare3, arginfo_stub_declaretest_testdeclare3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare4, arginfo_stub_declaretest_testdeclare4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare5, arginfo_stub_declaretest_testdeclare5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare6, arginfo_stub_declaretest_testdeclare6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare7, arginfo_stub_declaretest_testdeclare7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare7, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare8, arginfo_stub_declaretest_testdeclare8, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare8, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare9, arginfo_stub_declaretest_testdeclare9, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare9, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare10, arginfo_stub_declaretest_testdeclare10, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare10, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare11, arginfo_stub_declaretest_testdeclare11, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare11, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare12, arginfo_stub_declaretest_testdeclare12, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare12, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare13, arginfo_stub_declaretest_testdeclare13, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare13, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare14, arginfo_stub_declaretest_testdeclare14, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare14, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclare15, arginfo_stub_declaretest_testdeclare15, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclare15, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_DeclareTest, testDeclareMcallExpression, arginfo_stub_declaretest_testdeclaremcallexpression, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_DeclareTest, testDeclareMcallExpression, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/diinterface.zep.c b/ext/stub/diinterface.zep.c index f82932b46e..847a1e9e9e 100644 --- a/ext/stub/diinterface.zep.c +++ b/ext/stub/diinterface.zep.c @@ -21,4 +21,3 @@ ZEPHIR_INIT_CLASS(Stub_DiInterface) { } ZEPHIR_DOC_METHOD(Stub_DiInterface, getShared); - diff --git a/ext/stub/echoes.zep.c b/ext/stub/echoes.zep.c index ff752dad7c..058cd9be8c 100644 --- a/ext/stub/echoes.zep.c +++ b/ext/stub/echoes.zep.c @@ -31,6 +31,7 @@ PHP_METHOD(Stub_Echoes, testEcho1) { zval *this_ptr = getThis(); + php_printf("%d", 1); } @@ -40,6 +41,7 @@ PHP_METHOD(Stub_Echoes, testEcho2) { zval *this_ptr = getThis(); + php_printf("%f", 1.0); } @@ -49,6 +51,7 @@ PHP_METHOD(Stub_Echoes, testEcho3) { zval *this_ptr = getThis(); + php_printf("%s", 1 ? "1": ""); } @@ -58,6 +61,7 @@ PHP_METHOD(Stub_Echoes, testEcho4) { zval *this_ptr = getThis(); + php_printf("%s", 0 ? "1": ""); } @@ -67,6 +71,7 @@ PHP_METHOD(Stub_Echoes, testEcho5) { zval *this_ptr = getThis(); + php_printf("%s", "hello"); } diff --git a/ext/stub/echoes.zep.h b/ext/stub/echoes.zep.h index 67b9dc4c72..01b93baf47 100644 --- a/ext/stub/echoes.zep.h +++ b/ext/stub/echoes.zep.h @@ -25,10 +25,30 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_echoes_testecho5, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_echoes_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Echoes, testEcho1, arginfo_stub_echoes_testecho1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Echoes, testEcho1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Echoes, testEcho2, arginfo_stub_echoes_testecho2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Echoes, testEcho2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Echoes, testEcho3, arginfo_stub_echoes_testecho3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Echoes, testEcho3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Echoes, testEcho4, arginfo_stub_echoes_testecho4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Echoes, testEcho4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Echoes, testEcho5, arginfo_stub_echoes_testecho5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Echoes, testEcho5, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/emptytest.zep.c b/ext/stub/emptytest.zep.c index 1d7ad671df..6488ed865a 100644 --- a/ext/stub/emptytest.zep.c +++ b/ext/stub/emptytest.zep.c @@ -40,6 +40,7 @@ PHP_METHOD(Stub_EmptyTest, testDynamicVarArrayEmpty) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -57,6 +58,7 @@ PHP_METHOD(Stub_EmptyTest, testDynamicVarArrayNotEmpty) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -85,6 +87,7 @@ PHP_METHOD(Stub_EmptyTest, testEmptyString) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -101,6 +104,7 @@ PHP_METHOD(Stub_EmptyTest, testNotEmptyString) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -117,6 +121,14 @@ PHP_METHOD(Stub_EmptyTest, testString) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); diff --git a/ext/stub/emptytest.zep.h b/ext/stub/emptytest.zep.h index a5616e4e94..4a39df105a 100644 --- a/ext/stub/emptytest.zep.h +++ b/ext/stub/emptytest.zep.h @@ -22,18 +22,30 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_emptytest_testnotemptystring, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_emptytest_teststring, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_emptytest_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_EmptyTest, testDynamicVarArrayEmpty, arginfo_stub_emptytest_testdynamicvararrayempty, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_EmptyTest, testDynamicVarArrayEmpty, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_EmptyTest, testDynamicVarArrayNotEmpty, arginfo_stub_emptytest_testdynamicvararraynotempty, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_EmptyTest, testDynamicVarArrayNotEmpty, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_EmptyTest, testEmptyString, arginfo_stub_emptytest_testemptystring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_EmptyTest, testEmptyString, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_EmptyTest, testNotEmptyString, arginfo_stub_emptytest_testnotemptystring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_EmptyTest, testNotEmptyString, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_EmptyTest, testString, arginfo_stub_emptytest_teststring, ZEND_ACC_PUBLIC) PHP_FE_END }; diff --git a/ext/stub/evaltest.zep.c b/ext/stub/evaltest.zep.c index bf47141935..552b477702 100644 --- a/ext/stub/evaltest.zep.c +++ b/ext/stub/evaltest.zep.c @@ -34,6 +34,14 @@ PHP_METHOD(Stub_EvalTest, evalCode) { zval *this_ptr = getThis(); ZVAL_UNDEF(&code); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(code) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &code_param); diff --git a/ext/stub/evaltest.zep.h b/ext/stub/evaltest.zep.h index c8713ca237..e163cbd860 100644 --- a/ext/stub/evaltest.zep.h +++ b/ext/stub/evaltest.zep.h @@ -6,11 +6,7 @@ ZEPHIR_INIT_CLASS(Stub_EvalTest); PHP_METHOD(Stub_EvalTest, evalCode); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_evaltest_evalcode, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, code, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, code) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_evaltest_method_entry) { diff --git a/ext/stub/exception.zep.c b/ext/stub/exception.zep.c index 17c793e75d..c5c62f18ac 100644 --- a/ext/stub/exception.zep.c +++ b/ext/stub/exception.zep.c @@ -24,7 +24,7 @@ */ ZEPHIR_INIT_CLASS(Stub_Exception) { - ZEPHIR_REGISTER_CLASS_EX(Stub, Exception, stub, exception, zend_exception_get_default(), stub_exception_method_entry, 0); + ZEPHIR_REGISTER_CLASS_EX(Stub, Exception, stub, exception, zend_ce_exception, stub_exception_method_entry, 0); return SUCCESS; @@ -41,6 +41,14 @@ PHP_METHOD(Stub_Exception, testRuntimePropertyFetch) { zval *this_ptr = getThis(); ZVAL_UNDEF(&message); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(message) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &message_param); diff --git a/ext/stub/exception.zep.h b/ext/stub/exception.zep.h index 26bdfc9d17..4575b0da63 100644 --- a/ext/stub/exception.zep.h +++ b/ext/stub/exception.zep.h @@ -6,11 +6,7 @@ ZEPHIR_INIT_CLASS(Stub_Exception); PHP_METHOD(Stub_Exception, testRuntimePropertyFetch); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_exception_testruntimepropertyfetch, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, message, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, message) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_exception_method_entry) { diff --git a/ext/stub/exceptions.zep.c b/ext/stub/exceptions.zep.c index 8f4d320465..7ec8ef19da 100644 --- a/ext/stub/exceptions.zep.c +++ b/ext/stub/exceptions.zep.c @@ -37,6 +37,7 @@ PHP_METHOD(Stub_Exceptions, testException1) { zval *this_ptr = getThis(); + ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(stub_exception_ce, "hello1", "stub/exceptions.zep", 11); return; @@ -47,6 +48,7 @@ PHP_METHOD(Stub_Exceptions, testExceptionStringEscape) { zval *this_ptr = getThis(); + ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(stub_exception_ce, "hello \"simple code\" test", "stub/exceptions.zep", 16); return; @@ -62,13 +64,14 @@ PHP_METHOD(Stub_Exceptions, testException2) { ZVAL_UNDEF(&msg); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&msg); ZVAL_STRING(&msg, "hello2"); ZEPHIR_INIT_VAR(&_0); object_init_ex(&_0, stub_exception_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 26, &msg); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 28, &msg); zephir_check_call_status(); zephir_throw_exception_debug(&_0, "stub/exceptions.zep", 23); ZEPHIR_MM_RESTORE(); @@ -86,13 +89,14 @@ PHP_METHOD(Stub_Exceptions, testException3) { ZVAL_UNDEF(&ex); ZVAL_UNDEF(&msg); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&msg); ZVAL_STRING(&msg, "hello3"); ZEPHIR_INIT_VAR(&ex); object_init_ex(&ex, stub_exception_ce); - ZEPHIR_CALL_METHOD(NULL, &ex, "__construct", NULL, 26, &msg); + ZEPHIR_CALL_METHOD(NULL, &ex, "__construct", NULL, 28, &msg); zephir_check_call_status(); zephir_throw_exception_debug(&ex, "stub/exceptions.zep", 31); ZEPHIR_MM_RESTORE(); @@ -109,12 +113,13 @@ PHP_METHOD(Stub_Exceptions, getException) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); object_init_ex(return_value, stub_exception_ce); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "hello4"); - ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 26, &_0); + ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", NULL, 28, &_0); zephir_check_call_status(); RETURN_MM(); @@ -129,6 +134,7 @@ PHP_METHOD(Stub_Exceptions, testException4) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "getexception", NULL, 0); @@ -149,13 +155,14 @@ PHP_METHOD(Stub_Exceptions, testException5) { ZVAL_UNDEF(&exception); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&exception); object_init_ex(&exception, stub_exception_ce); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "hello5"); - ZEPHIR_CALL_METHOD(NULL, &exception, "__construct", NULL, 26, &_0); + ZEPHIR_CALL_METHOD(NULL, &exception, "__construct", NULL, 28, &_0); zephir_check_call_status(); zephir_throw_exception_debug(&exception, "stub/exceptions.zep", 49); ZEPHIR_MM_RESTORE(); @@ -171,6 +178,14 @@ PHP_METHOD(Stub_Exceptions, testExceptionLiteral) { zval *this_ptr = getThis(); ZVAL_UNDEF(&type); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(type) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &type_param); @@ -180,19 +195,19 @@ PHP_METHOD(Stub_Exceptions, testExceptionLiteral) { do { if (ZEPHIR_IS_STRING(&type, "string")) { - ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_exception_get_default(), "Test", "stub/exceptions.zep", 56); + ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_ce_exception, "Test", "stub/exceptions.zep", 56); return; } if (ZEPHIR_IS_STRING(&type, "char")) { - ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_exception_get_default(), "t", "stub/exceptions.zep", 58); + ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_ce_exception, "t", "stub/exceptions.zep", 58); return; } if (ZEPHIR_IS_STRING(&type, "int")) { - ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_exception_get_default(), "123", "stub/exceptions.zep", 60); + ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_ce_exception, "123", "stub/exceptions.zep", 60); return; } if (ZEPHIR_IS_STRING(&type, "double")) { - ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_exception_get_default(), "123.123", "stub/exceptions.zep", 62); + ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_ce_exception, "123.123", "stub/exceptions.zep", 62); return; } } while(0); @@ -212,6 +227,14 @@ PHP_METHOD(Stub_Exceptions, testExceptionSprintf) { ZVAL_UNDEF(&name); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(name) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &name_param); @@ -221,7 +244,7 @@ PHP_METHOD(Stub_Exceptions, testExceptionSprintf) { ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "Hello, %s"); - ZEPHIR_CALL_FUNCTION(&_1, "sprintf", NULL, 15, &_0, &name); + ZEPHIR_CALL_FUNCTION(&_1, "sprintf", NULL, 17, &_0, &name); zephir_check_call_status(); zephir_throw_exception_debug(&_1, "stub/exceptions.zep", 68); ZEPHIR_MM_RESTORE(); @@ -239,6 +262,15 @@ PHP_METHOD(Stub_Exceptions, testExceptionConcat) { ZVAL_UNDEF(&framework); ZVAL_UNDEF(&language); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(framework) + Z_PARAM_STR(language) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &framework_param, &language_param); @@ -265,6 +297,7 @@ PHP_METHOD(Stub_Exceptions, testExceptionRethrow) { ZVAL_UNDEF(&e); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); @@ -279,7 +312,7 @@ PHP_METHOD(Stub_Exceptions, testExceptionRethrow) { ZEPHIR_INIT_VAR(&_0); ZVAL_OBJ(&_0, EG(exception)); Z_ADDREF_P(&_0); - if (zephir_instance_of_ev(&_0, zend_exception_get_default())) { + if (zephir_instance_of_ev(&_0, zend_ce_exception)) { zend_clear_exception(); ZEPHIR_CPY_WRT(&e, &_0); zephir_throw_exception_debug(&e, "stub/exceptions.zep", 83); @@ -310,6 +343,15 @@ PHP_METHOD(Stub_Exceptions, testMultiException) { ZVAL_UNDEF(&_4$$7); ZVAL_UNDEF(&_6$$10); ZVAL_UNDEF(&_8$$13); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(returnValue) + Z_PARAM_ZVAL(exception) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &returnValue, &exception); @@ -349,7 +391,7 @@ PHP_METHOD(Stub_Exceptions, testMultiException) { return; } } else { - if (zephir_instance_of_ev(&_0, zend_exception_get_default())) { + if (zephir_instance_of_ev(&_0, zend_ce_exception)) { zend_clear_exception(); ZEPHIR_CPY_WRT(&e, &_0); _3$$7 = zephir_is_callable(&exc); @@ -417,12 +459,13 @@ PHP_METHOD(Stub_Exceptions, issue1325) { ZVAL_UNDEF(&status); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); /* try_start_1: */ - ZEPHIR_CALL_METHOD(&status, this_ptr, "donoopexception", NULL, 27); + ZEPHIR_CALL_METHOD(&status, this_ptr, "donoopexception", NULL, 29); zephir_check_call_status_or_jump(try_end_1); try_end_1: @@ -431,7 +474,7 @@ PHP_METHOD(Stub_Exceptions, issue1325) { ZEPHIR_INIT_VAR(&_0); ZVAL_OBJ(&_0, EG(exception)); Z_ADDREF_P(&_0); - if (zephir_instance_of_ev(&_0, zend_exception_get_default())) { + if (zephir_instance_of_ev(&_0, zend_ce_exception)) { zend_clear_exception(); ZEPHIR_CPY_WRT(&e, &_0); ZEPHIR_INIT_NVAR(&status); @@ -447,7 +490,8 @@ PHP_METHOD(Stub_Exceptions, doNoopException) { zval *this_ptr = getThis(); - ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(zend_exception_get_default(), "I am exception", "stub/exceptions.zep", 140); + + ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(zend_ce_exception, "I am exception", "stub/exceptions.zep", 140); return; } diff --git a/ext/stub/exceptions.zep.h b/ext/stub/exceptions.zep.h index 6d2ee751b8..1a6edfd7ec 100644 --- a/ext/stub/exceptions.zep.h +++ b/ext/stub/exceptions.zep.h @@ -40,32 +40,16 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_exceptions_testexception5, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_exceptions_testexceptionliteral, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, type, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, type) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_exceptions_testexceptionsprintf, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, name) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_exceptions_testexceptionconcat, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, framework, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, framework) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, language, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, language) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_exceptions_testexceptionrethrow, 0, 0, 0) @@ -83,19 +67,59 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_exceptions_donoopexception, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_exceptions_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Exceptions, testException1, arginfo_stub_exceptions_testexception1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Exceptions, testException1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Exceptions, testExceptionStringEscape, arginfo_stub_exceptions_testexceptionstringescape, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Exceptions, testExceptionStringEscape, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Exceptions, testException2, arginfo_stub_exceptions_testexception2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Exceptions, testException2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Exceptions, testException3, arginfo_stub_exceptions_testexception3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Exceptions, testException3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Exceptions, getException, arginfo_stub_exceptions_getexception, ZEND_ACC_PROTECTED) +#else + PHP_ME(Stub_Exceptions, getException, NULL, ZEND_ACC_PROTECTED) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Exceptions, testException4, arginfo_stub_exceptions_testexception4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Exceptions, testException4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Exceptions, testException5, arginfo_stub_exceptions_testexception5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Exceptions, testException5, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Exceptions, testExceptionLiteral, arginfo_stub_exceptions_testexceptionliteral, ZEND_ACC_PUBLIC) PHP_ME(Stub_Exceptions, testExceptionSprintf, arginfo_stub_exceptions_testexceptionsprintf, ZEND_ACC_PUBLIC) PHP_ME(Stub_Exceptions, testExceptionConcat, arginfo_stub_exceptions_testexceptionconcat, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Exceptions, testExceptionRethrow, arginfo_stub_exceptions_testexceptionrethrow, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Exceptions, testExceptionRethrow, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Exceptions, testMultiException, arginfo_stub_exceptions_testmultiexception, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Exceptions, issue1325, arginfo_stub_exceptions_issue1325, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Exceptions, issue1325, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Exceptions, doNoopException, arginfo_stub_exceptions_donoopexception, ZEND_ACC_PRIVATE) +#else + PHP_ME(Stub_Exceptions, doNoopException, NULL, ZEND_ACC_PRIVATE) +#endif PHP_FE_END }; diff --git a/ext/stub/exists.zep.c b/ext/stub/exists.zep.c index f9403037e3..a2c45e7ed5 100644 --- a/ext/stub/exists.zep.c +++ b/ext/stub/exists.zep.c @@ -34,6 +34,16 @@ PHP_METHOD(Stub_Exists, testClassExists) { ZVAL_UNDEF(&className_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(className) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(autoload) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 1, &className, &autoload_param); @@ -57,6 +67,16 @@ PHP_METHOD(Stub_Exists, testInterfaceExists) { ZVAL_UNDEF(&interfaceName_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(interfaceName) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(autoload) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 1, &interfaceName, &autoload_param); @@ -79,6 +99,15 @@ PHP_METHOD(Stub_Exists, testMethodExists) { ZVAL_UNDEF(&obj_sub); ZVAL_UNDEF(&methodName_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(obj) + Z_PARAM_ZVAL(methodName) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &obj, &methodName); @@ -94,6 +123,14 @@ PHP_METHOD(Stub_Exists, testFileExists) { zval *this_ptr = getThis(); ZVAL_UNDEF(&fileName_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(fileName) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &fileName); diff --git a/ext/stub/exists.zep.h b/ext/stub/exists.zep.h index e27d3fe1ee..4f60482f1f 100644 --- a/ext/stub/exists.zep.h +++ b/ext/stub/exists.zep.h @@ -8,46 +8,22 @@ PHP_METHOD(Stub_Exists, testInterfaceExists); PHP_METHOD(Stub_Exists, testMethodExists); PHP_METHOD(Stub_Exists, testFileExists); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exists_testclassexists, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exists_testclassexists, 0, 1, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_INFO(0, className) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, autoload, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, autoload) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exists_testinterfaceexists, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exists_testinterfaceexists, 0, 1, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_INFO(0, interfaceName) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, autoload, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, autoload) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exists_testmethodexists, 0, 2, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exists_testmethodexists, 0, 2, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_INFO(0, obj) ZEND_ARG_INFO(0, methodName) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exists_testfileexists, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exists_testfileexists, 0, 1, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_INFO(0, fileName) ZEND_END_ARG_INFO() diff --git a/ext/stub/exitdie.zep.c b/ext/stub/exitdie.zep.c index e004e2dbb6..4d2bee24dd 100644 --- a/ext/stub/exitdie.zep.c +++ b/ext/stub/exitdie.zep.c @@ -33,6 +33,15 @@ PHP_METHOD(Stub_ExitDie, testExit) { ZVAL_UNDEF(¶m_sub); ZVAL_NULL(&__$null); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, ¶m); @@ -56,6 +65,15 @@ PHP_METHOD(Stub_ExitDie, testDie) { ZVAL_UNDEF(¶m_sub); ZVAL_NULL(&__$null); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, ¶m); diff --git a/ext/stub/exitdie.zep.h b/ext/stub/exitdie.zep.h index c93020afe3..b35f643626 100644 --- a/ext/stub/exitdie.zep.h +++ b/ext/stub/exitdie.zep.h @@ -6,30 +6,12 @@ ZEPHIR_INIT_CLASS(Stub_ExitDie); PHP_METHOD(Stub_ExitDie, testExit); PHP_METHOD(Stub_ExitDie, testDie); -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exitdie_testexit, 0, 0, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exitdie_testexit, 0, 0, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_exitdie_testexit, 0, 0, 0) -#define arginfo_stub_exitdie_testexit NULL -#endif ZEND_ARG_INFO(0, param) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exitdie_testdie, 0, 0, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_exitdie_testdie, 0, 0, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_exitdie_testdie, 0, 0, 0) -#define arginfo_stub_exitdie_testdie NULL -#endif ZEND_ARG_INFO(0, param) ZEND_END_ARG_INFO() diff --git a/ext/stub/extendedinterface.zep.c b/ext/stub/extendedinterface.zep.c index e0715a6fc0..e07aa1fa47 100644 --- a/ext/stub/extendedinterface.zep.c +++ b/ext/stub/extendedinterface.zep.c @@ -16,8 +16,8 @@ ZEPHIR_INIT_CLASS(Stub_ExtendedInterface) { ZEPHIR_REGISTER_INTERFACE(Stub, ExtendedInterface, stub, extendedinterface, NULL); - zend_class_implements(stub_extendedinterface_ce, 1, zend_ce_aggregate); - zend_class_implements(stub_extendedinterface_ce, 1, spl_ce_Countable); + zend_class_implements(stub_extendedinterface_ce, 1, zephir_get_internal_ce(SL("iteratoraggregate"))); + zend_class_implements(stub_extendedinterface_ce, 1, zend_ce_countable); return SUCCESS; } diff --git a/ext/stub/factorial.zep.c b/ext/stub/factorial.zep.c index ede28ebbaf..8562edc8b6 100644 --- a/ext/stub/factorial.zep.c +++ b/ext/stub/factorial.zep.c @@ -34,6 +34,14 @@ PHP_METHOD(Stub_Factorial, intIterativeFactorial) { zend_long n, _1, _2; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &n_param); @@ -73,6 +81,14 @@ PHP_METHOD(Stub_Factorial, intRecursiveFactorial) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &num_param); @@ -89,7 +105,7 @@ PHP_METHOD(Stub_Factorial, intRecursiveFactorial) { ZVAL_LONG(&_0, 1); } else { ZVAL_LONG(&_3, (num - 1)); - ZEPHIR_CALL_METHOD(&_2, this_ptr, "intrecursivefactorial", NULL, 28, &_3); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "intrecursivefactorial", NULL, 30, &_3); zephir_check_call_status(); ZVAL_LONG(&_0, (num * zephir_get_numberval(&_2))); } diff --git a/ext/stub/factorial.zep.h b/ext/stub/factorial.zep.h index 778f9fbcd2..536d90e4cd 100644 --- a/ext/stub/factorial.zep.h +++ b/ext/stub/factorial.zep.h @@ -6,28 +6,12 @@ ZEPHIR_INIT_CLASS(Stub_Factorial); PHP_METHOD(Stub_Factorial, intIterativeFactorial); PHP_METHOD(Stub_Factorial, intRecursiveFactorial); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_factorial_intiterativefactorial, 0, 1, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_factorial_intiterativefactorial, 0, 1, IS_LONG, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, n) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_factorial_intrecursivefactorial, 0, 1, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_factorial_intrecursivefactorial, 0, 1, IS_LONG, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_factorial_method_entry) { diff --git a/ext/stub/fannkuch.zep.c b/ext/stub/fannkuch.zep.c index fa0cc87e02..457d3e9d11 100644 --- a/ext/stub/fannkuch.zep.c +++ b/ext/stub/fannkuch.zep.c @@ -57,6 +57,14 @@ PHP_METHOD(Stub_Fannkuch, process) { ZVAL_UNDEF(&_17$$13); ZVAL_UNDEF(&_18$$13); ZVAL_UNDEF(&_19$$13); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n_param); diff --git a/ext/stub/fannkuch.zep.h b/ext/stub/fannkuch.zep.h index 71d28597ce..7995ec363a 100644 --- a/ext/stub/fannkuch.zep.h +++ b/ext/stub/fannkuch.zep.h @@ -6,11 +6,7 @@ ZEPHIR_INIT_CLASS(Stub_Fannkuch); PHP_METHOD(Stub_Fannkuch, process); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fannkuch_process, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, n) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_fannkuch_method_entry) { diff --git a/ext/stub/fasta.zep.c b/ext/stub/fasta.zep.c index 4c0d21aa10..2062395905 100644 --- a/ext/stub/fasta.zep.c +++ b/ext/stub/fasta.zep.c @@ -64,6 +64,15 @@ PHP_METHOD(Stub_Fasta, fastaRepeat) { ZVAL_UNDEF(&seq); ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_5); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(n) + Z_PARAM_STR(seq) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &n, &seq_param); @@ -150,6 +159,7 @@ PHP_METHOD(Stub_Fasta, fastRandom) { + } PHP_METHOD(Stub_Fasta, main) { @@ -166,6 +176,14 @@ PHP_METHOD(Stub_Fasta, main) { ZVAL_UNDEF(&homoSap); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n); diff --git a/ext/stub/fasta.zep.h b/ext/stub/fasta.zep.h index 7823a7a56d..acc0cf9d48 100644 --- a/ext/stub/fasta.zep.h +++ b/ext/stub/fasta.zep.h @@ -9,11 +9,7 @@ PHP_METHOD(Stub_Fasta, main); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fasta_fastarepeat, 0, 0, 2) ZEND_ARG_INFO(0, n) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, seq, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, seq) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fasta_fastrandom, 0, 0, 0) @@ -25,7 +21,11 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_fasta_method_entry) { PHP_ME(Stub_Fasta, fastaRepeat, arginfo_stub_fasta_fastarepeat, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Fasta, fastRandom, arginfo_stub_fasta_fastrandom, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Fasta, fastRandom, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Fasta, main, arginfo_stub_fasta_main, ZEND_ACC_PUBLIC) PHP_FE_END }; diff --git a/ext/stub/fcall.zep.c b/ext/stub/fcall.zep.c index 3f5bf9f460..598c07be6a 100644 --- a/ext/stub/fcall.zep.c +++ b/ext/stub/fcall.zep.c @@ -48,6 +48,7 @@ PHP_METHOD(Stub_Fcall, testCall1) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -68,6 +69,7 @@ PHP_METHOD(Stub_Fcall, testCall2) { ZVAL_UNDEF(&_1$$3); + while (1) { ZVAL_LONG(&_0$$3, 0); ZVAL_LONG(&_1$$3, 100); @@ -91,24 +93,25 @@ PHP_METHOD(Stub_Fcall, testCall3) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_3$$4); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "inputfile.txt"); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "r"); - ZEPHIR_CALL_FUNCTION(&handle, "fopen", &_2, 29, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&handle, "fopen", &_2, 31, &_0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "outputfile.txt"); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "w"); - ZEPHIR_CALL_FUNCTION(&handle2, "fopen", &_2, 29, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&handle2, "fopen", &_2, 31, &_0, &_1); zephir_check_call_status(); if (zephir_is_true(&handle)) { while (1) { ZVAL_LONG(&_3$$4, 4096); - ZEPHIR_CALL_FUNCTION(&buffer, "fgets", &_4, 30, &handle, &_3$$4); + ZEPHIR_CALL_FUNCTION(&buffer, "fgets", &_4, 32, &handle, &_3$$4); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&buffer)) { break; @@ -137,24 +140,25 @@ PHP_METHOD(Stub_Fcall, testCall4) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_3$$4); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "r"); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "inputfile.txt"); - ZEPHIR_CALL_FUNCTION(&handle, "fopen", &_2, 29, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&handle, "fopen", &_2, 31, &_0, &_1); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, "outputfile.txt"); ZEPHIR_INIT_NVAR(&_1); ZVAL_STRING(&_1, "w"); - ZEPHIR_CALL_FUNCTION(&handle2, "fopen", &_2, 29, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&handle2, "fopen", &_2, 31, &_0, &_1); zephir_check_call_status(); if (zephir_is_true(&handle)) { while (1) { ZVAL_LONG(&_3$$4, 4096); - ZEPHIR_CALL_FUNCTION(&buffer, "fgets", &_4, 30, &handle, &_3$$4); + ZEPHIR_CALL_FUNCTION(&buffer, "fgets", &_4, 32, &handle, &_3$$4); zephir_check_call_status(); if (ZEPHIR_IS_FALSE_IDENTICAL(&buffer)) { break; @@ -177,13 +181,22 @@ PHP_METHOD(Stub_Fcall, testCall5) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); - ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", NULL, 19, a, b); + ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", NULL, 21, a, b); zephir_check_call_status(); RETURN_MM(); @@ -196,9 +209,10 @@ PHP_METHOD(Stub_Fcall, testCall6) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); - ZEPHIR_RETURN_CALL_FUNCTION("rand", NULL, 31); + ZEPHIR_RETURN_CALL_FUNCTION("rand", NULL, 33); zephir_check_call_status(); RETURN_MM(); @@ -211,9 +225,10 @@ PHP_METHOD(Stub_Fcall, testCall7) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); - ZEPHIR_CALL_FUNCTION(NULL, "memory_get_usage", NULL, 32); + ZEPHIR_CALL_FUNCTION(NULL, "memory_get_usage", NULL, 34); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -229,6 +244,16 @@ PHP_METHOD(Stub_Fcall, zvalFcallWith1Parameter) { ZVAL_UNDEF(&callback_sub); ZVAL_UNDEF(¶m1_sub); ZVAL_NULL(&__$null); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(callback) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(param1) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &callback, ¶m1); @@ -255,13 +280,22 @@ PHP_METHOD(Stub_Fcall, testCall8) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); ZVAL_UNDEF(&x); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); - ZEPHIR_CALL_FUNCTION(&x, "str_repeat", NULL, 19, a, b); + ZEPHIR_CALL_FUNCTION(&x, "str_repeat", NULL, 21, a, b); zephir_check_call_status(); RETURN_CCTOR(&x); @@ -278,6 +312,7 @@ PHP_METHOD(Stub_Fcall, testCall1FromVar) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&funcName); @@ -297,6 +332,7 @@ PHP_METHOD(Stub_Fcall, testStrtokFalse) { zval *this_ptr = getThis(); + RETURN_BOOL(0); } @@ -310,6 +346,14 @@ PHP_METHOD(Stub_Fcall, testStrtokVarBySlash) { ZVAL_UNDEF(&value_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &value); @@ -318,7 +362,7 @@ PHP_METHOD(Stub_Fcall, testStrtokVarBySlash) { ZEPHIR_INIT_VAR(&_0); ZVAL_STRING(&_0, "/"); - ZEPHIR_RETURN_CALL_FUNCTION("strtok", NULL, 33, value, &_0); + ZEPHIR_RETURN_CALL_FUNCTION("strtok", NULL, 35, value, &_0); zephir_check_call_status(); RETURN_MM(); @@ -331,6 +375,15 @@ PHP_METHOD(Stub_Fcall, testFunctionGetArgs) { ZVAL_UNDEF(¶m1_sub); ZVAL_UNDEF(¶m2_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(param1) + Z_PARAM_ZVAL(param2) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, ¶m1, ¶m2); @@ -346,6 +399,7 @@ PHP_METHOD(Stub_Fcall, testFunctionGetArgsAllExtra) { zval *this_ptr = getThis(); + zephir_get_args(return_value); return; @@ -356,6 +410,7 @@ PHP_METHOD(Stub_Fcall, testStaticFunctionGetArgsAllExtra) { zval *this_ptr = getThis(); + zephir_get_args(return_value); return; @@ -372,6 +427,15 @@ PHP_METHOD(Stub_Fcall, testFunctionGetArg) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(param1) + Z_PARAM_ZVAL(param2) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, ¶m1, ¶m2); @@ -401,6 +465,7 @@ PHP_METHOD(Stub_Fcall, testFunctionGetArgAllExtra) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); zephir_create_array(return_value, 2, 0); @@ -426,6 +491,7 @@ PHP_METHOD(Stub_Fcall, testStaticFunctionGetArgAllExtra) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); zephir_create_array(return_value, 2, 0); @@ -455,19 +521,20 @@ PHP_METHOD(Stub_Fcall, testArrayFill) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, 5); ZEPHIR_INIT_VAR(&_2); ZVAL_STRING(&_2, "?"); - ZEPHIR_CALL_FUNCTION(&v1, "array_fill", &_3, 34, &_0, &_1, &_2); + ZEPHIR_CALL_FUNCTION(&v1, "array_fill", &_3, 36, &_0, &_1, &_2); zephir_check_call_status(); ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, 6); ZEPHIR_INIT_NVAR(&_2); ZVAL_STRING(&_2, "?"); - ZEPHIR_CALL_FUNCTION(&v2, "array_fill", &_3, 34, &_0, &_1, &_2); + ZEPHIR_CALL_FUNCTION(&v2, "array_fill", &_3, 36, &_0, &_1, &_2); zephir_check_call_status(); zephir_create_array(return_value, 2, 0); zephir_array_fast_append(return_value, &v1); @@ -482,6 +549,14 @@ PHP_FUNCTION(g_stub_zephir_global_method_test) { zval *str, str_sub, _0; ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str); @@ -494,7 +569,7 @@ PHP_FUNCTION(g_stub_zephir_global_method_test) { ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 0); zephir_check_call_status(); } - ZEPHIR_RETURN_CALL_METHOD(&_0, "teststrtokvarbyslash", NULL, 35, str); + ZEPHIR_RETURN_CALL_METHOD(&_0, "teststrtokvarbyslash", NULL, 37, str); zephir_check_call_status(); RETURN_MM(); @@ -503,6 +578,14 @@ PHP_FUNCTION(g_stub_zephir_global_method_test) { PHP_FUNCTION(g_stub_zephir_global_method_with_type_casting) { zval *variable, variable_sub; ZVAL_UNDEF(&variable_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(variable) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &variable); @@ -520,6 +603,14 @@ PHP_FUNCTION(f_Stub_zephir_namespaced_method_test) { ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &str); @@ -533,7 +624,7 @@ PHP_FUNCTION(f_Stub_zephir_namespaced_method_test) { zephir_check_call_status(); } ZVAL_LONG(&_1, 5); - ZEPHIR_RETURN_CALL_METHOD(&_0, "testcall5", NULL, 36, str, &_1); + ZEPHIR_RETURN_CALL_METHOD(&_0, "testcall5", NULL, 38, str, &_1); zephir_check_call_status(); RETURN_MM(); @@ -542,6 +633,14 @@ PHP_FUNCTION(f_Stub_zephir_namespaced_method_test) { PHP_FUNCTION(f_Stub_test_call_relative_object_hint) { zval *a, a_sub; ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -554,6 +653,14 @@ PHP_FUNCTION(f_Stub_test_call_relative_object_hint) { PHP_FUNCTION(f_Stub_zephir_namespaced_method_with_type_casting) { zval *variable, variable_sub; ZVAL_UNDEF(&variable_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(variable) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &variable); @@ -567,6 +674,14 @@ PHP_FUNCTION(f_Stub_zephir_namespaced_method_with_type_casting) { PHP_FUNCTION(f_Stub_test_call_object_hint) { zval *a, a_sub; ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); diff --git a/ext/stub/fcall.zep.h b/ext/stub/fcall.zep.h index 0300ff5abd..47e875729a 100644 --- a/ext/stub/fcall.zep.h +++ b/ext/stub/fcall.zep.h @@ -23,18 +23,10 @@ PHP_METHOD(Stub_Fcall, testFunctionGetArgAllExtra); PHP_METHOD(Stub_Fcall, testStaticFunctionGetArgAllExtra); PHP_METHOD(Stub_Fcall, testArrayFill); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testcall1, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testcall1, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testcall2, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testcall2, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fcall_testcall3, 0, 0, 0) @@ -64,89 +56,65 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fcall_testcall8, 0, 0, 2) ZEND_ARG_INFO(0, b) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testcall1fromvar, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testcall1fromvar, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_teststrtokfalse, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_teststrtokfalse, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_teststrtokvarbyslash, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_teststrtokvarbyslash, 0, 1, IS_STRING, NULL, 0) -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testfunctiongetargs, 0, 2, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testfunctiongetargs, 0, 2, IS_ARRAY, NULL, 0) -#endif ZEND_ARG_INFO(0, param1) ZEND_ARG_INFO(0, param2) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testfunctiongetargsallextra, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testfunctiongetargsallextra, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_teststaticfunctiongetargsallextra, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_teststaticfunctiongetargsallextra, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testfunctiongetarg, 0, 2, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testfunctiongetarg, 0, 2, IS_ARRAY, NULL, 0) -#endif ZEND_ARG_INFO(0, param1) ZEND_ARG_INFO(0, param2) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testfunctiongetargallextra, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testfunctiongetargallextra, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_teststaticfunctiongetargallextra, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_teststaticfunctiongetargallextra, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testarrayfill, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fcall_testarrayfill, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_fcall_method_entry) { PHP_ME(Stub_Fcall, testCall1, arginfo_stub_fcall_testcall1, ZEND_ACC_PUBLIC) PHP_ME(Stub_Fcall, testCall2, arginfo_stub_fcall_testcall2, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Fcall, testCall3, arginfo_stub_fcall_testcall3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Fcall, testCall3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Fcall, testCall4, arginfo_stub_fcall_testcall4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Fcall, testCall4, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Fcall, testCall5, arginfo_stub_fcall_testcall5, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Fcall, testCall6, arginfo_stub_fcall_testcall6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Fcall, testCall6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Fcall, testCall7, arginfo_stub_fcall_testcall7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Fcall, testCall7, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Fcall, zvalFcallWith1Parameter, arginfo_stub_fcall_zvalfcallwith1parameter, ZEND_ACC_PUBLIC) PHP_ME(Stub_Fcall, testCall8, arginfo_stub_fcall_testcall8, ZEND_ACC_PUBLIC) PHP_ME(Stub_Fcall, testCall1FromVar, arginfo_stub_fcall_testcall1fromvar, ZEND_ACC_PUBLIC) diff --git a/ext/stub/fetchtest.zep.c b/ext/stub/fetchtest.zep.c index 947d635ab0..8762896cf3 100644 --- a/ext/stub/fetchtest.zep.c +++ b/ext/stub/fetchtest.zep.c @@ -37,6 +37,14 @@ PHP_METHOD(Stub_FetchTest, setValues) { zval *this_ptr = getThis(); ZVAL_UNDEF(&values_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(values) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &values); @@ -52,6 +60,7 @@ PHP_METHOD(Stub_FetchTest, getValues) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "values"); } @@ -64,6 +73,15 @@ PHP_METHOD(Stub_FetchTest, testFetchArray1) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); ZVAL_UNDEF(&c); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); @@ -81,6 +99,15 @@ PHP_METHOD(Stub_FetchTest, testFetchArray2) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -101,6 +128,15 @@ PHP_METHOD(Stub_FetchTest, testFetchArray3) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&c); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_LONG(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b_param); @@ -119,6 +155,15 @@ PHP_METHOD(Stub_FetchTest, testFetchArray4) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_LONG(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b_param); @@ -142,6 +187,15 @@ PHP_METHOD(Stub_FetchTest, testFetchArray5) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&c); ZVAL_UNDEF(&b); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_STR(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b_param); @@ -162,6 +216,15 @@ PHP_METHOD(Stub_FetchTest, testFetchArray6) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_STR(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b_param); @@ -184,6 +247,15 @@ PHP_METHOD(Stub_FetchTest, testFetchObject1) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); ZVAL_UNDEF(&c); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -203,6 +275,15 @@ PHP_METHOD(Stub_FetchTest, testFetchObject2) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -223,6 +304,14 @@ PHP_METHOD(Stub_FetchTest, testFetchPost) { ZVAL_UNDEF(&b_sub); ZVAL_UNDEF(&_POST); ZVAL_UNDEF(&c); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_get_global(&_POST, SL("_POST")); zephir_fetch_params_without_memory_grow(1, 0, &b); @@ -246,6 +335,14 @@ PHP_METHOD(Stub_FetchTest, hasValue) { ZVAL_UNDEF(&name); ZVAL_UNDEF(&_POST); ZVAL_UNDEF(&_0$$4); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(name) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_get_global(&_POST, SL("_POST")); @@ -277,6 +374,14 @@ PHP_METHOD(Stub_FetchTest, getValue) { ZVAL_UNDEF(&_POST); ZVAL_UNDEF(&value); ZVAL_UNDEF(&_0$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(name) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_get_global(&_POST, SL("_POST")); diff --git a/ext/stub/fetchtest.zep.h b/ext/stub/fetchtest.zep.h index 01e875f696..0787fec806 100644 --- a/ext/stub/fetchtest.zep.h +++ b/ext/stub/fetchtest.zep.h @@ -36,38 +36,22 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fetchtest_testfetcharray3, 0, 0, 2) ZEND_ARG_INFO(0, a) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fetchtest_testfetcharray4, 0, 0, 2) ZEND_ARG_INFO(0, a) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fetchtest_testfetcharray5, 0, 0, 2) ZEND_ARG_INFO(0, a) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fetchtest_testfetcharray6, 0, 0, 2) ZEND_ARG_INFO(0, a) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fetchtest_testfetchobject1, 0, 0, 2) @@ -84,29 +68,21 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fetchtest_testfetchpost, 0, 0, 1) ZEND_ARG_INFO(0, b) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fetchtest_hasvalue, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fetchtest_hasvalue, 0, 1, _IS_BOOL, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, name) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fetchtest_getvalue, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, name) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_fetchtest_method_entry) { PHP_ME(Stub_FetchTest, setValues, arginfo_stub_fetchtest_setvalues, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_FetchTest, getValues, arginfo_stub_fetchtest_getvalues, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_FetchTest, getValues, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_FetchTest, testFetchArray1, arginfo_stub_fetchtest_testfetcharray1, ZEND_ACC_PUBLIC) PHP_ME(Stub_FetchTest, testFetchArray2, arginfo_stub_fetchtest_testfetcharray2, ZEND_ACC_PUBLIC) PHP_ME(Stub_FetchTest, testFetchArray3, arginfo_stub_fetchtest_testfetcharray3, ZEND_ACC_PUBLIC) diff --git a/ext/stub/fibonnaci.zep.c b/ext/stub/fibonnaci.zep.c index 4ae023f298..149f427b38 100644 --- a/ext/stub/fibonnaci.zep.c +++ b/ext/stub/fibonnaci.zep.c @@ -34,6 +34,7 @@ PHP_METHOD(Stub_Fibonnaci, fibInt) { + z = 0; x = 1; y = 2; @@ -57,6 +58,7 @@ PHP_METHOD(Stub_Fibonnaci, fibDouble) { + z = 0.0; x = 1.0; y = 2.0; @@ -86,6 +88,7 @@ PHP_METHOD(Stub_Fibonnaci, fibArray) { ZVAL_UNDEF(&c); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&fib); @@ -128,6 +131,7 @@ PHP_METHOD(Stub_Fibonnaci, fibArray2) { ZVAL_UNDEF(&_2$$3); ZVAL_UNDEF(&_3$$3); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&fib); @@ -166,6 +170,14 @@ PHP_METHOD(Stub_Fibonnaci, fibonacciRecursive) { ZVAL_UNDEF(&_0$$6); ZVAL_UNDEF(&_1$$6); ZVAL_UNDEF(&_3$$6); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n_param); @@ -180,10 +192,10 @@ PHP_METHOD(Stub_Fibonnaci, fibonacciRecursive) { RETURN_MM_LONG(1); } else { ZVAL_LONG(&_1$$6, (n - 1)); - ZEPHIR_CALL_METHOD(&_0$$6, this_ptr, "fibonaccirecursive", &_2, 37, &_1$$6); + ZEPHIR_CALL_METHOD(&_0$$6, this_ptr, "fibonaccirecursive", &_2, 39, &_1$$6); zephir_check_call_status(); ZVAL_LONG(&_1$$6, (n - 2)); - ZEPHIR_CALL_METHOD(&_3$$6, this_ptr, "fibonaccirecursive", &_2, 37, &_1$$6); + ZEPHIR_CALL_METHOD(&_3$$6, this_ptr, "fibonaccirecursive", &_2, 39, &_1$$6); zephir_check_call_status(); zephir_add_function(return_value, &_0$$6, &_3$$6); RETURN_MM(); @@ -203,6 +215,14 @@ PHP_METHOD(Stub_Fibonnaci, fibonacciFinalRecursive) { ZVAL_UNDEF(&_0$$6); ZVAL_UNDEF(&_1$$6); ZVAL_UNDEF(&_3$$6); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n_param); @@ -217,10 +237,10 @@ PHP_METHOD(Stub_Fibonnaci, fibonacciFinalRecursive) { RETURN_MM_LONG(1); } else { ZVAL_LONG(&_1$$6, (n - 1)); - ZEPHIR_CALL_METHOD(&_0$$6, this_ptr, "fibonaccifinalrecursive", &_2, 38, &_1$$6); + ZEPHIR_CALL_METHOD(&_0$$6, this_ptr, "fibonaccifinalrecursive", &_2, 40, &_1$$6); zephir_check_call_status(); ZVAL_LONG(&_1$$6, (n - 2)); - ZEPHIR_CALL_METHOD(&_3$$6, this_ptr, "fibonaccifinalrecursive", &_2, 38, &_1$$6); + ZEPHIR_CALL_METHOD(&_3$$6, this_ptr, "fibonaccifinalrecursive", &_2, 40, &_1$$6); zephir_check_call_status(); zephir_add_function(return_value, &_0$$6, &_3$$6); RETURN_MM(); diff --git a/ext/stub/fibonnaci.zep.h b/ext/stub/fibonnaci.zep.h index be784953df..b9a1847d7f 100644 --- a/ext/stub/fibonnaci.zep.h +++ b/ext/stub/fibonnaci.zep.h @@ -23,26 +23,34 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fibonnaci_fibarray2, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fibonnaci_fibonaccirecursive, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, n) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_fibonnaci_fibonaccifinalrecursive, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, n) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_fibonnaci_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Fibonnaci, fibInt, arginfo_stub_fibonnaci_fibint, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Fibonnaci, fibInt, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Fibonnaci, fibDouble, arginfo_stub_fibonnaci_fibdouble, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Fibonnaci, fibDouble, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Fibonnaci, fibArray, arginfo_stub_fibonnaci_fibarray, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Fibonnaci, fibArray, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Fibonnaci, fibArray2, arginfo_stub_fibonnaci_fibarray2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Fibonnaci, fibArray2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Fibonnaci, fibonacciRecursive, arginfo_stub_fibonnaci_fibonaccirecursive, ZEND_ACC_PRIVATE) PHP_ME(Stub_Fibonnaci, fibonacciFinalRecursive, arginfo_stub_fibonnaci_fibonaccifinalrecursive, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL) PHP_FE_END diff --git a/ext/stub/flow.zep.c b/ext/stub/flow.zep.c index f2dca568ef..95c3d56108 100644 --- a/ext/stub/flow.zep.c +++ b/ext/stub/flow.zep.c @@ -40,6 +40,7 @@ PHP_METHOD(Stub_Flow, testIf1) { + a = 1; if (a) { RETURN_LONG(1); @@ -55,6 +56,7 @@ PHP_METHOD(Stub_Flow, testIf2) { + a = 0; if (a) { RETURN_LONG(1); @@ -70,6 +72,7 @@ PHP_METHOD(Stub_Flow, testIf3) { + a = (double) (1); if (a) { RETURN_LONG(1); @@ -85,6 +88,7 @@ PHP_METHOD(Stub_Flow, testIf4) { + a = (double) (0); if (a) { RETURN_LONG(1); @@ -100,6 +104,7 @@ PHP_METHOD(Stub_Flow, testIf5) { + a = ((1) ? 1 : 0); if (a) { RETURN_LONG(1); @@ -115,6 +120,7 @@ PHP_METHOD(Stub_Flow, testIf6) { + a = ((0) ? 1 : 0); if (a) { RETURN_LONG(1); @@ -130,6 +136,7 @@ PHP_METHOD(Stub_Flow, testIf7) { + a = 1; if (a) { RETURN_LONG(1); @@ -146,6 +153,7 @@ PHP_METHOD(Stub_Flow, testIf8) { + a = 0; if (a) { RETURN_LONG(1); @@ -164,6 +172,7 @@ PHP_METHOD(Stub_Flow, testIf9) { + a = 1; if (a) { b = (double) (1); @@ -187,6 +196,7 @@ PHP_METHOD(Stub_Flow, testIf10) { + a = 1; if (a) { b = (double) (1); @@ -215,6 +225,7 @@ PHP_METHOD(Stub_Flow, testIf12) { + a = 1; if (a) { b = (double) (1); @@ -241,6 +252,7 @@ PHP_METHOD(Stub_Flow, testIf13) { + a = 1; b = 2; if ((a + b)) { @@ -257,6 +269,7 @@ PHP_METHOD(Stub_Flow, testIf14) { + a = 1; b = 2; if ((a + b)) { @@ -273,6 +286,7 @@ PHP_METHOD(Stub_Flow, testIf15) { + a = 1; b = 2; c = 3; @@ -289,6 +303,14 @@ PHP_METHOD(Stub_Flow, testIf16) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -307,6 +329,14 @@ PHP_METHOD(Stub_Flow, testIf17) { zval *this_ptr = getThis(); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &b); @@ -326,6 +356,7 @@ PHP_METHOD(Stub_Flow, testLoop1) { + a = 1; while (1) { if (a) { @@ -343,6 +374,7 @@ PHP_METHOD(Stub_Flow, testLoop2) { + a = 1; while (1) { a = (a + 1); @@ -361,6 +393,7 @@ PHP_METHOD(Stub_Flow, testLoop3) { + a = 1; while (1) { a = (a + 1); @@ -383,6 +416,7 @@ PHP_METHOD(Stub_Flow, testLoop4) { + a = 1; while (1) { a = (a + 1); @@ -405,6 +439,7 @@ PHP_METHOD(Stub_Flow, testWhile1) { + a = 5; while (1) { if (!(a)) { @@ -423,6 +458,7 @@ PHP_METHOD(Stub_Flow, testWhile2) { + a = 5; while (1) { if (!(a)) { @@ -442,6 +478,7 @@ PHP_METHOD(Stub_Flow, testWhile3) { + a = 5; b = 0; while (1) { @@ -470,6 +507,7 @@ PHP_METHOD(Stub_Flow, testWhile4) { + a = 5; b = 0; while (1) { @@ -497,6 +535,7 @@ PHP_METHOD(Stub_Flow, testWhile5) { + a = 5; while (1) { if (!(a)) { @@ -515,6 +554,7 @@ PHP_METHOD(Stub_Flow, testWhile6) { + a = 5; while (1) { if (!(a)) { @@ -533,6 +573,7 @@ PHP_METHOD(Stub_Flow, testWhile7) { + a = (double) (5); while (1) { if (!(a)) { @@ -551,6 +592,7 @@ PHP_METHOD(Stub_Flow, testWhile8) { + a = (double) (5); while (1) { if (!(a)) { @@ -570,6 +612,7 @@ PHP_METHOD(Stub_Flow, testWhile9) { + a = 5; b = 0; while (1) { @@ -599,6 +642,14 @@ PHP_METHOD(Stub_Flow, testWhile10) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a); @@ -636,6 +687,15 @@ PHP_METHOD(Stub_Flow, testWhile11) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&d_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(d) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &d); @@ -673,6 +733,7 @@ PHP_METHOD(Stub_Flow, testWhile12) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -700,6 +761,7 @@ PHP_METHOD(Stub_Flow, testWhile13) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); a = 5; @@ -722,6 +784,7 @@ PHP_METHOD(Stub_Flow, testDoWhile1) { zval *this_ptr = getThis(); + do { } while (1); @@ -739,6 +802,14 @@ PHP_METHOD(Stub_Flow, testWhileNextTest) { ZVAL_UNDEF(&returnValue); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_2$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(variable) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &variable); @@ -749,13 +820,13 @@ PHP_METHOD(Stub_Flow, testWhileNextTest) { array_init(&returnValue); while (1) { ZEPHIR_MAKE_REF(variable); - ZEPHIR_CALL_FUNCTION(&_0, "next", &_1, 39, variable); + ZEPHIR_CALL_FUNCTION(&_0, "next", &_1, 41, variable); ZEPHIR_UNREF(variable); zephir_check_call_status(); if (!(zephir_is_true(&_0))) { break; } - ZEPHIR_CALL_FUNCTION(&_2$$3, "current", &_3, 40, variable); + ZEPHIR_CALL_FUNCTION(&_2$$3, "current", &_3, 42, variable); zephir_check_call_status(); zephir_array_append(&returnValue, &_2$$3, PH_SEPARATE, "stub/flow.zep", 420); } @@ -775,6 +846,14 @@ PHP_METHOD(Stub_Flow, testWhileDoNextTest) { ZVAL_UNDEF(&returnValue); ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_0$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(variable) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &variable); @@ -784,11 +863,11 @@ PHP_METHOD(Stub_Flow, testWhileDoNextTest) { ZEPHIR_INIT_VAR(&returnValue); array_init(&returnValue); do { - ZEPHIR_CALL_FUNCTION(&_0$$3, "current", &_1, 40, variable); + ZEPHIR_CALL_FUNCTION(&_0$$3, "current", &_1, 42, variable); zephir_check_call_status(); zephir_array_append(&returnValue, &_0$$3, PH_SEPARATE, "stub/flow.zep", 430); ZEPHIR_MAKE_REF(variable); - ZEPHIR_CALL_FUNCTION(&_2, "next", &_3, 39, variable); + ZEPHIR_CALL_FUNCTION(&_2, "next", &_3, 41, variable); ZEPHIR_UNREF(variable); zephir_check_call_status(); } while (zephir_is_true(&_2)); @@ -808,6 +887,7 @@ PHP_METHOD(Stub_Flow, testFor1) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); c = 0; @@ -870,6 +950,7 @@ PHP_METHOD(Stub_Flow, testFor2) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); c = (double) (0); @@ -938,6 +1019,7 @@ PHP_METHOD(Stub_Flow, testFor3) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&c); @@ -996,6 +1078,7 @@ PHP_METHOD(Stub_Flow, testFor4) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1030,6 +1113,7 @@ PHP_METHOD(Stub_Flow, testFor5) { + b = 0; _2 = 10; _1 = 1; @@ -1063,6 +1147,7 @@ PHP_METHOD(Stub_Flow, testFor6) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1097,6 +1182,7 @@ PHP_METHOD(Stub_Flow, testFor7) { + b = 0; _2 = 10; _1 = _2; @@ -1127,6 +1213,7 @@ PHP_METHOD(Stub_Flow, testFor8) { + b = 0; c = 1; d = 10; @@ -1159,6 +1246,7 @@ PHP_METHOD(Stub_Flow, testFor9) { + b = 0; c = 1; d = 10; @@ -1194,6 +1282,7 @@ PHP_METHOD(Stub_Flow, testFor10) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1232,6 +1321,7 @@ PHP_METHOD(Stub_Flow, testFor11) { ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1267,6 +1357,7 @@ PHP_METHOD(Stub_Flow, testFor12) { ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1302,6 +1393,7 @@ PHP_METHOD(Stub_Flow, testFor13) { ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1337,6 +1429,7 @@ PHP_METHOD(Stub_Flow, testFor14) { ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1369,6 +1462,15 @@ PHP_METHOD(Stub_Flow, testFor15) { zend_long c, d, a = 0, b = 0, _1, _2; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_LONG(c) + Z_PARAM_LONG(d) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &c_param, &d_param); @@ -1411,6 +1513,7 @@ PHP_METHOD(Stub_Flow, testFor16) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&c); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&c); @@ -1454,6 +1557,7 @@ PHP_METHOD(Stub_Flow, testFor17) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&c); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&c); @@ -1496,6 +1600,7 @@ PHP_METHOD(Stub_Flow, testFor18) { ZVAL_UNDEF(&c); ZVAL_UNDEF(&_4$$3); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&c); @@ -1537,6 +1642,7 @@ PHP_METHOD(Stub_Flow, testFor19) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1574,6 +1680,7 @@ PHP_METHOD(Stub_Flow, testFor20) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1611,6 +1718,7 @@ PHP_METHOD(Stub_Flow, testFor21) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1648,6 +1756,7 @@ PHP_METHOD(Stub_Flow, testFor22) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1686,6 +1795,7 @@ PHP_METHOD(Stub_Flow, testFor23) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1728,6 +1838,7 @@ PHP_METHOD(Stub_Flow, testFor24) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1788,6 +1899,7 @@ PHP_METHOD(Stub_Flow, testFor30) { ZVAL_UNDEF(&_1$$3); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1817,6 +1929,7 @@ PHP_METHOD(Stub_Flow, testFor31) { ZVAL_UNDEF(&_1$$3); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1845,6 +1958,14 @@ PHP_METHOD(Stub_Flow, testFor32) { ZVAL_UNDEF(&e_sub); ZVAL_UNDEF(&v); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(e) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &e); @@ -1891,6 +2012,14 @@ PHP_METHOD(Stub_Flow, testFor33) { ZVAL_UNDEF(&e_sub); ZVAL_UNDEF(&v); ZVAL_UNDEF(&result); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(e, zend_ce_iterator) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &e); @@ -1923,6 +2052,15 @@ PHP_METHOD(Stub_Flow, testFor34) { ZVAL_NULL(&__$null); ZVAL_UNDEF(&v); ZVAL_UNDEF(&result); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_OBJECT_OF_CLASS_OR_NULL(e, zend_ce_iterator) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &e); @@ -1957,6 +2095,14 @@ PHP_METHOD(Stub_Flow, testFor35Aux) { zval *this_ptr = getThis(); ZVAL_UNDEF(&hello_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(hello) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &hello); @@ -1978,6 +2124,7 @@ PHP_METHOD(Stub_Flow, testFor35) { ZVAL_UNDEF(&i); ZVAL_UNDEF(&_3$$3); + ZEPHIR_MM_GROW(); _2 = 100; @@ -2011,6 +2158,14 @@ PHP_METHOD(Stub_Flow, testFor36Aux) { zval *this_ptr = getThis(); ZVAL_UNDEF(&hello_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(hello) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &hello); @@ -2034,6 +2189,7 @@ PHP_METHOD(Stub_Flow, testFor36) { ZVAL_UNDEF(&i); ZVAL_UNDEF(&_3$$3); + ZEPHIR_MM_GROW(); _2 = 100; @@ -2069,6 +2225,7 @@ PHP_METHOD(Stub_Flow, testFor37) { + i = 0; _2 = 10; _1 = 1; @@ -2102,6 +2259,7 @@ PHP_METHOD(Stub_Flow, testFor38) { ZVAL_UNDEF(&v); + ZEPHIR_MM_GROW(); i = 0; @@ -2141,6 +2299,7 @@ PHP_METHOD(Stub_Flow, testFor39) { ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); i = 0; @@ -2166,6 +2325,7 @@ PHP_METHOD(Stub_Flow, testFor40) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&_3$$3); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -2206,6 +2366,7 @@ PHP_METHOD(Stub_Flow, testUnrechable1) { ZVAL_UNDEF(&d); + ZEPHIR_MM_GROW(); a = 0; @@ -2245,6 +2406,7 @@ PHP_METHOD(Stub_Flow, testUnrechable2) { ZVAL_UNDEF(&d); + ZEPHIR_MM_GROW(); a = 1; @@ -2289,6 +2451,7 @@ PHP_METHOD(Stub_Flow, testUnrechable3) { + if (3 < 1) { if (1 > 2) { a = 0; diff --git a/ext/stub/flow.zep.h b/ext/stub/flow.zep.h index 7912c40bc4..a999bf1759 100644 --- a/ext/stub/flow.zep.h +++ b/ext/stub/flow.zep.h @@ -238,16 +238,8 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_flow_testfor14, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_flow_testfor15, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, c, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, c) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, d, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, d) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_flow_testfor16, 0, 0, 0) @@ -331,81 +323,337 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_flow_testunrechable3, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_flow_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf1, arginfo_stub_flow_testif1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf2, arginfo_stub_flow_testif2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf3, arginfo_stub_flow_testif3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf4, arginfo_stub_flow_testif4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf5, arginfo_stub_flow_testif5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf6, arginfo_stub_flow_testif6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf7, arginfo_stub_flow_testif7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf7, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf8, arginfo_stub_flow_testif8, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf8, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf9, arginfo_stub_flow_testif9, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf9, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf10, arginfo_stub_flow_testif10, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf10, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf12, arginfo_stub_flow_testif12, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf12, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf13, arginfo_stub_flow_testif13, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf13, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf14, arginfo_stub_flow_testif14, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf14, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testIf15, arginfo_stub_flow_testif15, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testIf15, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Flow, testIf16, arginfo_stub_flow_testif16, ZEND_ACC_PUBLIC) PHP_ME(Stub_Flow, testIf17, arginfo_stub_flow_testif17, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testLoop1, arginfo_stub_flow_testloop1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testLoop1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testLoop2, arginfo_stub_flow_testloop2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testLoop2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testLoop3, arginfo_stub_flow_testloop3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testLoop3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testLoop4, arginfo_stub_flow_testloop4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testLoop4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testWhile1, arginfo_stub_flow_testwhile1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testWhile1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testWhile2, arginfo_stub_flow_testwhile2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testWhile2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testWhile3, arginfo_stub_flow_testwhile3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testWhile3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testWhile4, arginfo_stub_flow_testwhile4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testWhile4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testWhile5, arginfo_stub_flow_testwhile5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testWhile5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testWhile6, arginfo_stub_flow_testwhile6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testWhile6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testWhile7, arginfo_stub_flow_testwhile7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testWhile7, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testWhile8, arginfo_stub_flow_testwhile8, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testWhile8, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testWhile9, arginfo_stub_flow_testwhile9, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testWhile9, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Flow, testWhile10, arginfo_stub_flow_testwhile10, ZEND_ACC_PUBLIC) PHP_ME(Stub_Flow, testWhile11, arginfo_stub_flow_testwhile11, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testWhile12, arginfo_stub_flow_testwhile12, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testWhile12, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testWhile13, arginfo_stub_flow_testwhile13, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testWhile13, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testDoWhile1, arginfo_stub_flow_testdowhile1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testDoWhile1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Flow, testWhileNextTest, arginfo_stub_flow_testwhilenexttest, ZEND_ACC_PUBLIC) PHP_ME(Stub_Flow, testWhileDoNextTest, arginfo_stub_flow_testwhiledonexttest, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor1, arginfo_stub_flow_testfor1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor2, arginfo_stub_flow_testfor2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor3, arginfo_stub_flow_testfor3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor4, arginfo_stub_flow_testfor4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor5, arginfo_stub_flow_testfor5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor6, arginfo_stub_flow_testfor6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor7, arginfo_stub_flow_testfor7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor7, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor8, arginfo_stub_flow_testfor8, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor8, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor9, arginfo_stub_flow_testfor9, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor9, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor10, arginfo_stub_flow_testfor10, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor10, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor11, arginfo_stub_flow_testfor11, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor11, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor12, arginfo_stub_flow_testfor12, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor12, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor13, arginfo_stub_flow_testfor13, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor13, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor14, arginfo_stub_flow_testfor14, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor14, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Flow, testFor15, arginfo_stub_flow_testfor15, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor16, arginfo_stub_flow_testfor16, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor16, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor17, arginfo_stub_flow_testfor17, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor17, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor18, arginfo_stub_flow_testfor18, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor18, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor19, arginfo_stub_flow_testfor19, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor19, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor20, arginfo_stub_flow_testfor20, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor20, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor21, arginfo_stub_flow_testfor21, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor21, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor22, arginfo_stub_flow_testfor22, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor22, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor23, arginfo_stub_flow_testfor23, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor23, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor24, arginfo_stub_flow_testfor24, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor24, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor30, arginfo_stub_flow_testfor30, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor30, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor31, arginfo_stub_flow_testfor31, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor31, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Flow, testFor32, arginfo_stub_flow_testfor32, ZEND_ACC_PUBLIC) PHP_ME(Stub_Flow, testFor33, arginfo_stub_flow_testfor33, ZEND_ACC_PUBLIC) PHP_ME(Stub_Flow, testFor34, arginfo_stub_flow_testfor34, ZEND_ACC_PUBLIC) PHP_ME(Stub_Flow, testFor35Aux, arginfo_stub_flow_testfor35aux, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor35, arginfo_stub_flow_testfor35, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor35, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Flow, testFor36Aux, arginfo_stub_flow_testfor36aux, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor36, arginfo_stub_flow_testfor36, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor36, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor37, arginfo_stub_flow_testfor37, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor37, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor38, arginfo_stub_flow_testfor38, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor38, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor39, arginfo_stub_flow_testfor39, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor39, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testFor40, arginfo_stub_flow_testfor40, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testFor40, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testUnrechable1, arginfo_stub_flow_testunrechable1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testUnrechable1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testUnrechable2, arginfo_stub_flow_testunrechable2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testUnrechable2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow, testUnrechable3, arginfo_stub_flow_testunrechable3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow, testUnrechable3, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/flow/switchflow.zep.c b/ext/stub/flow/switchflow.zep.c index 5550baad49..ad96eaa67b 100644 --- a/ext/stub/flow/switchflow.zep.c +++ b/ext/stub/flow/switchflow.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch1) { + a = 10; RETURN_LONG(a); @@ -45,6 +46,7 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch2) { + a = 10; do { if (a == 10) { @@ -63,6 +65,7 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch3) { + a = 10; do { if (a == 5) { @@ -81,6 +84,7 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch4) { + a = 10; do { if (a == 5) { @@ -100,6 +104,7 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch5) { + a = 10; do { if (a == 10) { @@ -119,6 +124,7 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch6) { + a = 10; do { if (a == 10 || a == 4) { @@ -137,6 +143,7 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch7) { + a = 4; do { if (a == 10 || a == 4) { @@ -155,6 +162,7 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch8) { + a = 5; do { if (a == 10 || a == 4) { @@ -173,6 +181,7 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch9) { + a = 5; do { if (a == 3 || a == 4) { @@ -194,6 +203,7 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch10) { + a = 5; do { if (a == 3 || a == 4) { @@ -215,6 +225,7 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch11) { + a = 1; do { if (a == 2) { @@ -234,6 +245,15 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch12) { ZVAL_UNDEF(&var1_sub); ZVAL_UNDEF(&var2_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(var1) + Z_PARAM_ZVAL(var2) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &var1, &var2); @@ -269,6 +289,14 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch13) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a_param); @@ -298,6 +326,15 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch14) { ZVAL_UNDEF(&ret); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(result_type) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &result_type); diff --git a/ext/stub/flow/switchflow.zep.h b/ext/stub/flow/switchflow.zep.h index 013833ffb2..6ad791d370 100644 --- a/ext/stub/flow/switchflow.zep.h +++ b/ext/stub/flow/switchflow.zep.h @@ -18,74 +18,34 @@ PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch12); PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch13); PHP_METHOD(Stub_Flow_SwitchFlow, testSwitch14); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch1, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch1, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch2, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch2, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch3, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch3, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch4, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch4, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch5, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch5, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch6, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch6, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch7, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch7, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch8, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch8, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch9, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch9, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch10, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_flow_switchflow_testswitch10, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_flow_switchflow_testswitch11, 0, 0, 0) @@ -97,11 +57,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_flow_switchflow_testswitch12, 0, 0, 2) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_flow_switchflow_testswitch13, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_flow_switchflow_testswitch14, 0, 0, 0) @@ -119,7 +75,11 @@ ZEPHIR_INIT_FUNCS(stub_flow_switchflow_method_entry) { PHP_ME(Stub_Flow_SwitchFlow, testSwitch8, arginfo_stub_flow_switchflow_testswitch8, ZEND_ACC_PUBLIC) PHP_ME(Stub_Flow_SwitchFlow, testSwitch9, arginfo_stub_flow_switchflow_testswitch9, ZEND_ACC_PUBLIC) PHP_ME(Stub_Flow_SwitchFlow, testSwitch10, arginfo_stub_flow_switchflow_testswitch10, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Flow_SwitchFlow, testSwitch11, arginfo_stub_flow_switchflow_testswitch11, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Flow_SwitchFlow, testSwitch11, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Flow_SwitchFlow, testSwitch12, arginfo_stub_flow_switchflow_testswitch12, ZEND_ACC_PUBLIC) PHP_ME(Stub_Flow_SwitchFlow, testSwitch13, arginfo_stub_flow_switchflow_testswitch13, ZEND_ACC_PUBLIC) PHP_ME(Stub_Flow_SwitchFlow, testSwitch14, arginfo_stub_flow_switchflow_testswitch14, ZEND_ACC_PUBLIC) diff --git a/ext/stub/fortytwo.zep.c b/ext/stub/fortytwo.zep.c index 236216eaca..83827a74de 100644 --- a/ext/stub/fortytwo.zep.c +++ b/ext/stub/fortytwo.zep.c @@ -48,6 +48,7 @@ PHP_METHOD(Stub_FortyTwo, proof) { ZVAL_UNDEF(&_11$$7); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&box); diff --git a/ext/stub/fortytwo.zep.h b/ext/stub/fortytwo.zep.h index ce3bb51f8f..9d044add87 100644 --- a/ext/stub/fortytwo.zep.h +++ b/ext/stub/fortytwo.zep.h @@ -5,16 +5,8 @@ ZEPHIR_INIT_CLASS(Stub_FortyTwo); PHP_METHOD(Stub_FortyTwo, proof); -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fortytwo_proof, 0, 0, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_fortytwo_proof, 0, 0, IS_VOID, NULL, 0) -#endif ZEND_END_ARG_INFO() -#else -#define arginfo_stub_fortytwo_proof NULL -#endif ZEPHIR_INIT_FUNCS(stub_fortytwo_method_entry) { PHP_ME(Stub_FortyTwo, proof, arginfo_stub_fortytwo_proof, ZEND_ACC_PUBLIC) diff --git a/ext/stub/functional.zep.c b/ext/stub/functional.zep.c index 38cc8ee92d..e9e43425cd 100644 --- a/ext/stub/functional.zep.c +++ b/ext/stub/functional.zep.c @@ -37,6 +37,14 @@ PHP_METHOD(Stub_Functional, map1) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); @@ -64,6 +72,15 @@ PHP_METHOD(Stub_Functional, map2) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ARRAY(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a_param, &b); diff --git a/ext/stub/functionexists.zep.c b/ext/stub/functionexists.zep.c index 9a09bea43a..f3b061508e 100644 --- a/ext/stub/functionexists.zep.c +++ b/ext/stub/functionexists.zep.c @@ -35,6 +35,14 @@ PHP_METHOD(Stub_FunctionExists, testWithPassedName) { zval *this_ptr = getThis(); ZVAL_UNDEF(&func); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(func) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &func_param); @@ -42,7 +50,7 @@ PHP_METHOD(Stub_FunctionExists, testWithPassedName) { zephir_get_strval(&func, func_param); - RETURN_MM_BOOL((zephir_function_exists(&func) == SUCCESS)); + RETURN_MM_BOOL((zephir_function_exists(&func) == SUCCESS)); } @@ -62,6 +70,7 @@ PHP_METHOD(Stub_FunctionExists, testBuiltInFunctions) { ZVAL_UNDEF(&result); ZVAL_UNDEF(&functions); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&result); @@ -99,7 +108,7 @@ PHP_METHOD(Stub_FunctionExists, testBuiltInFunctions) { ZEPHIR_INIT_NVAR(&func); ZVAL_COPY(&func, _1); ZEPHIR_INIT_NVAR(&_3$$3); - ZVAL_BOOL(&_3$$3, (zephir_function_exists(&func) == SUCCESS)); + ZVAL_BOOL(&_3$$3, (zephir_function_exists(&func) == SUCCESS)); zephir_array_update_zval(&result, &func, &_3$$3, PH_COPY | PH_SEPARATE); } ZEND_HASH_FOREACH_END(); } else { @@ -114,7 +123,7 @@ PHP_METHOD(Stub_FunctionExists, testBuiltInFunctions) { ZEPHIR_CALL_METHOD(&func, &functions, "current", NULL, 0); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_4$$4); - ZVAL_BOOL(&_4$$4, (zephir_function_exists(&func) == SUCCESS)); + ZVAL_BOOL(&_4$$4, (zephir_function_exists(&func) == SUCCESS)); zephir_array_update_zval(&result, &func, &_4$$4, PH_COPY | PH_SEPARATE); ZEPHIR_CALL_METHOD(NULL, &functions, "next", NULL, 0); zephir_check_call_status(); @@ -130,6 +139,7 @@ PHP_METHOD(Stub_FunctionExists, testWithString) { zval *this_ptr = getThis(); + RETURN_BOOL((zephir_function_exists_ex(ZEND_STRL("substr")) == SUCCESS)); } diff --git a/ext/stub/functionexists.zep.h b/ext/stub/functionexists.zep.h index 526842cb57..fad0a789e2 100644 --- a/ext/stub/functionexists.zep.h +++ b/ext/stub/functionexists.zep.h @@ -7,30 +7,14 @@ PHP_METHOD(Stub_FunctionExists, testWithPassedName); PHP_METHOD(Stub_FunctionExists, testBuiltInFunctions); PHP_METHOD(Stub_FunctionExists, testWithString); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_functionexists_testwithpassedname, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_functionexists_testwithpassedname, 0, 1, _IS_BOOL, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, func, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, func) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_functionexists_testbuiltinfunctions, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_functionexists_testbuiltinfunctions, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_functionexists_testwithstring, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_functionexists_testwithstring, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_functionexists_method_entry) { diff --git a/ext/stub/functions.zep.c b/ext/stub/functions.zep.c new file mode 100644 index 0000000000..eef040da4c --- /dev/null +++ b/ext/stub/functions.zep.c @@ -0,0 +1,84 @@ + +#ifdef HAVE_CONFIG_H +#include "../ext_config.h" +#endif + +#include +#include "../php_ext.h" +#include "../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/memory.h" +#include "kernel/fcall.h" +#include "kernel/operators.h" +#include "kernel/object.h" + + +ZEPHIR_INIT_CLASS(Stub_Functions) { + + ZEPHIR_REGISTER_CLASS(Stub, Functions, stub, functions, stub_functions_method_entry, 0); + + return SUCCESS; + +} + +/** + * @issue https://github.com/phalcon/zephir/issues/658 + */ +PHP_METHOD(Stub_Functions, filterVar1) { + + zval ret, _0, _1, _2; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&ret); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + + + ZEPHIR_MM_GROW(); + + ZEPHIR_INIT_VAR(&ret); + ZVAL_STRING(&ret, "0"); + ZVAL_LONG(&_0, 259); + ZVAL_LONG(&_1, 20480); + ZEPHIR_CALL_FUNCTION(&_2, "filter_var", NULL, 43, &ret, &_0, &_1); + zephir_check_call_status(); + RETURN_MM_BOOL(ZEPHIR_IS_FALSE_IDENTICAL(&_2)); + +} + +/** + * @issue https://github.com/phalcon/zephir/issues/658 + */ +PHP_METHOD(Stub_Functions, filterVar2) { + + zval ret, _0, _1, _2; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&ret); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_2); + + + ZEPHIR_MM_GROW(); + + ZEPHIR_INIT_VAR(&ret); + ZVAL_STRING(&ret, "0"); + ZVAL_LONG(&_0, 259); + ZVAL_LONG(&_1, 20480); + ZEPHIR_CALL_FUNCTION(&_2, "filter_var", NULL, 43, &ret, &_0, &_1); + zephir_check_call_status(); + RETURN_MM_BOOL(ZEPHIR_IS_FALSE(&_2)); + +} + diff --git a/ext/stub/functions.zep.h b/ext/stub/functions.zep.h new file mode 100644 index 0000000000..178624a43d --- /dev/null +++ b/ext/stub/functions.zep.h @@ -0,0 +1,19 @@ + +extern zend_class_entry *stub_functions_ce; + +ZEPHIR_INIT_CLASS(Stub_Functions); + +PHP_METHOD(Stub_Functions, filterVar1); +PHP_METHOD(Stub_Functions, filterVar2); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_functions_filtervar1, 0, 0, _IS_BOOL, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_functions_filtervar2, 0, 0, _IS_BOOL, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(stub_functions_method_entry) { + PHP_ME(Stub_Functions, filterVar1, arginfo_stub_functions_filtervar1, ZEND_ACC_PUBLIC) + PHP_ME(Stub_Functions, filterVar2, arginfo_stub_functions_filtervar2, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/stub/geometry.zep.c b/ext/stub/geometry.zep.c index 198fb74c42..2f59fe1a10 100644 --- a/ext/stub/geometry.zep.c +++ b/ext/stub/geometry.zep.c @@ -46,6 +46,15 @@ PHP_METHOD(Stub_Geometry, run) { ZVAL_UNDEF(&_6$$3); ZVAL_UNDEF(&_7$$3); ZVAL_UNDEF(&_8$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ARRAY(list) + Z_PARAM_LONG(count) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &list_param, &count_param); @@ -90,6 +99,15 @@ PHP_METHOD(Stub_Geometry, runOptimize) { ZVAL_UNDEF(&_2$$3); ZVAL_UNDEF(&_3$$3); ZVAL_UNDEF(&_4$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ARRAY(list) + Z_PARAM_LONG(count) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &list_param, &count_param); @@ -124,6 +142,17 @@ PHP_METHOD(Stub_Geometry, distanceStatic) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(4, 4) + Z_PARAM_ZVAL(x1) + Z_PARAM_ZVAL(y1) + Z_PARAM_ZVAL(x2) + Z_PARAM_ZVAL(y2) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(4, 0, &x1_param, &y1_param, &x2_param, &y2_param); diff --git a/ext/stub/geometry.zep.h b/ext/stub/geometry.zep.h index 19acd1f1c5..7abc803912 100644 --- a/ext/stub/geometry.zep.h +++ b/ext/stub/geometry.zep.h @@ -7,69 +7,23 @@ PHP_METHOD(Stub_Geometry, run); PHP_METHOD(Stub_Geometry, runOptimize); PHP_METHOD(Stub_Geometry, distanceStatic); -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_geometry_run, 0, 2, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_geometry_run, 0, 2, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_geometry_run, 0, 0, 2) -#define arginfo_stub_geometry_run NULL -#endif ZEND_ARG_ARRAY_INFO(0, list, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, count, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, count) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_geometry_runoptimize, 0, 2, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_geometry_runoptimize, 0, 2, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_geometry_runoptimize, 0, 0, 2) -#define arginfo_stub_geometry_runoptimize NULL -#endif ZEND_ARG_ARRAY_INFO(0, list, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, count, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, count) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_geometry_distancestatic, 0, 4, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_geometry_distancestatic, 0, 4, IS_DOUBLE, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, x1, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, x1) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, y1, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, y1) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, x2, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, x2) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, y2, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, y2) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_geometry_method_entry) { diff --git a/ext/stub/globals.zep.c b/ext/stub/globals.zep.c index b31238e9e3..7d6df309ab 100644 --- a/ext/stub/globals.zep.c +++ b/ext/stub/globals.zep.c @@ -30,6 +30,14 @@ PHP_METHOD(Stub_Globals, setBoolValueUsingDotNotation) { zval *this_ptr = getThis(); ZVAL_UNDEF(&value_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &value); @@ -45,6 +53,14 @@ PHP_METHOD(Stub_Globals, setIntValueUsingDotNotation) { zval *this_ptr = getThis(); ZVAL_UNDEF(&value_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &value); @@ -60,6 +76,14 @@ PHP_METHOD(Stub_Globals, setCharValue) { zval *this_ptr = getThis(); ZVAL_UNDEF(&value_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &value); @@ -75,6 +99,14 @@ PHP_METHOD(Stub_Globals, setBoolValue) { zval *this_ptr = getThis(); ZVAL_UNDEF(&value_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &value); @@ -90,6 +122,14 @@ PHP_METHOD(Stub_Globals, setDefaultGlobalsOrmCacheLevel) { zval *this_ptr = getThis(); ZVAL_UNDEF(&value_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &value); @@ -107,6 +147,7 @@ PHP_METHOD(Stub_Globals, getDefaultGlobals1) { zval *this_ptr = getThis(); + RETURN_BOOL(ZEPHIR_GLOBAL(db).my_setting_1); } @@ -119,6 +160,7 @@ PHP_METHOD(Stub_Globals, getDefaultGlobals2) { zval *this_ptr = getThis(); + RETURN_LONG(ZEPHIR_GLOBAL(db).my_setting_2); } @@ -131,6 +173,7 @@ PHP_METHOD(Stub_Globals, getDefaultGlobals3) { zval *this_ptr = getThis(); + RETURN_DOUBLE(ZEPHIR_GLOBAL(db).my_setting_3); } @@ -143,6 +186,7 @@ PHP_METHOD(Stub_Globals, getDefaultGlobals4) { zval *this_ptr = getThis(); + RETURN_BOOL(ZEPHIR_GLOBAL(my_setting_1)); } @@ -155,6 +199,7 @@ PHP_METHOD(Stub_Globals, getDefaultGlobals5) { zval *this_ptr = getThis(); + RETURN_LONG(ZEPHIR_GLOBAL(my_setting_2)); } @@ -167,6 +212,7 @@ PHP_METHOD(Stub_Globals, getDefaultGlobals6) { zval *this_ptr = getThis(); + RETURN_DOUBLE(ZEPHIR_GLOBAL(my_setting_3)); } @@ -179,6 +225,7 @@ PHP_METHOD(Stub_Globals, getDefaultGlobals7) { zval *this_ptr = getThis(); + RETURN_LONG(ZEPHIR_GLOBAL(my_setting_4)); } @@ -191,6 +238,7 @@ PHP_METHOD(Stub_Globals, getDefaultGlobalsOrmCacheLevel) { zval *this_ptr = getThis(); + RETURN_LONG(ZEPHIR_GLOBAL(orm).cache_level); } diff --git a/ext/stub/globals.zep.h b/ext/stub/globals.zep.h index 46d86b7d83..25887d0210 100644 --- a/ext/stub/globals.zep.h +++ b/ext/stub/globals.zep.h @@ -17,72 +17,27 @@ PHP_METHOD(Stub_Globals, getDefaultGlobals6); PHP_METHOD(Stub_Globals, getDefaultGlobals7); PHP_METHOD(Stub_Globals, getDefaultGlobalsOrmCacheLevel); -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_setboolvalueusingdotnotation, 0, 1, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_setboolvalueusingdotnotation, 0, 1, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_setboolvalueusingdotnotation, 0, 0, 1) -#define arginfo_stub_globals_setboolvalueusingdotnotation NULL -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_setintvalueusingdotnotation, 0, 1, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_setintvalueusingdotnotation, 0, 1, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_setintvalueusingdotnotation, 0, 0, 1) -#define arginfo_stub_globals_setintvalueusingdotnotation NULL -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_setcharvalue, 0, 1, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_setcharvalue, 0, 1, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_setcharvalue, 0, 0, 1) -#define arginfo_stub_globals_setcharvalue NULL -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_setboolvalue, 0, 1, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_setboolvalue, 0, 1, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_setboolvalue, 0, 0, 1) -#define arginfo_stub_globals_setboolvalue NULL -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_setdefaultglobalsormcachelevel, 0, 1, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_setdefaultglobalsormcachelevel, 0, 1, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_setdefaultglobalsormcachelevel, 0, 0, 1) -#define arginfo_stub_globals_setdefaultglobalsormcachelevel NULL -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() @@ -117,13 +72,45 @@ ZEPHIR_INIT_FUNCS(stub_globals_method_entry) { PHP_ME(Stub_Globals, setCharValue, arginfo_stub_globals_setcharvalue, ZEND_ACC_PUBLIC) PHP_ME(Stub_Globals, setBoolValue, arginfo_stub_globals_setboolvalue, ZEND_ACC_PUBLIC) PHP_ME(Stub_Globals, setDefaultGlobalsOrmCacheLevel, arginfo_stub_globals_setdefaultglobalsormcachelevel, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Globals, getDefaultGlobals1, arginfo_stub_globals_getdefaultglobals1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Globals, getDefaultGlobals1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Globals, getDefaultGlobals2, arginfo_stub_globals_getdefaultglobals2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Globals, getDefaultGlobals2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Globals, getDefaultGlobals3, arginfo_stub_globals_getdefaultglobals3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Globals, getDefaultGlobals3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Globals, getDefaultGlobals4, arginfo_stub_globals_getdefaultglobals4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Globals, getDefaultGlobals4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Globals, getDefaultGlobals5, arginfo_stub_globals_getdefaultglobals5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Globals, getDefaultGlobals5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Globals, getDefaultGlobals6, arginfo_stub_globals_getdefaultglobals6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Globals, getDefaultGlobals6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Globals, getDefaultGlobals7, arginfo_stub_globals_getdefaultglobals7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Globals, getDefaultGlobals7, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Globals, getDefaultGlobalsOrmCacheLevel, arginfo_stub_globals_getdefaultglobalsormcachelevel, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Globals, getDefaultGlobalsOrmCacheLevel, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/globals/env.zep.c b/ext/stub/globals/env.zep.c index 1d7a1e43a6..bec3da2c8e 100644 --- a/ext/stub/globals/env.zep.c +++ b/ext/stub/globals/env.zep.c @@ -36,6 +36,14 @@ PHP_METHOD(Stub_Globals_Env, read) { ZVAL_UNDEF(&name); ZVAL_UNDEF(&_ENV); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(name) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_get_global(&_ENV, SL("_ENV")); diff --git a/ext/stub/globals/env.zep.h b/ext/stub/globals/env.zep.h index bc332428fb..0252aa82fe 100644 --- a/ext/stub/globals/env.zep.h +++ b/ext/stub/globals/env.zep.h @@ -6,11 +6,7 @@ ZEPHIR_INIT_CLASS(Stub_Globals_Env); PHP_METHOD(Stub_Globals_Env, read); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_env_read, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, name) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_globals_env_method_entry) { diff --git a/ext/stub/globals/post.zep.c b/ext/stub/globals/post.zep.c index 9e2ad3c1c6..b9d00e2230 100644 --- a/ext/stub/globals/post.zep.c +++ b/ext/stub/globals/post.zep.c @@ -40,6 +40,14 @@ PHP_METHOD(Stub_Globals_Post, hasValue) { ZVAL_UNDEF(&name); ZVAL_UNDEF(&_POST); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(name) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_get_global(&_POST, SL("_POST")); diff --git a/ext/stub/globals/post.zep.h b/ext/stub/globals/post.zep.h index 89b3fa5842..3f30d9ee31 100644 --- a/ext/stub/globals/post.zep.h +++ b/ext/stub/globals/post.zep.h @@ -5,16 +5,8 @@ ZEPHIR_INIT_CLASS(Stub_Globals_Post); PHP_METHOD(Stub_Globals_Post, hasValue); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_post_hasvalue, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_post_hasvalue, 0, 1, _IS_BOOL, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, name) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_globals_post_method_entry) { diff --git a/ext/stub/globals/server.zep.c b/ext/stub/globals/server.zep.c index 0107420078..0da3bda045 100644 --- a/ext/stub/globals/server.zep.c +++ b/ext/stub/globals/server.zep.c @@ -40,6 +40,7 @@ PHP_METHOD(Stub_Globals_Server, f1) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); zephir_get_global(&_SERVER, SL("_SERVER")); @@ -61,6 +62,7 @@ PHP_METHOD(Stub_Globals_Server, f2) { ZVAL_UNDEF(&_SERVER); ZVAL_UNDEF(&_0); + zephir_get_global(&_SERVER, SL("_SERVER")); zephir_array_fetch_string(&_0, &_SERVER, SL("SCRIPT_NAME"), PH_NOISY | PH_READONLY, "stub/globals/server.zep", 17); @@ -79,6 +81,7 @@ PHP_METHOD(Stub_Globals_Server, check) { ZVAL_UNDEF(&_SERVER); ZVAL_UNDEF(&_0); + zephir_get_global(&_SERVER, SL("_SERVER")); zephir_array_fetch_string(&_0, &_SERVER, SL("HTTP_USER_AGENT"), PH_NOISY | PH_READONLY, "stub/globals/server.zep", 25); diff --git a/ext/stub/globals/server.zep.h b/ext/stub/globals/server.zep.h index f2bd1feb7c..d2e0a123ad 100644 --- a/ext/stub/globals/server.zep.h +++ b/ext/stub/globals/server.zep.h @@ -7,27 +7,11 @@ PHP_METHOD(Stub_Globals_Server, f1); PHP_METHOD(Stub_Globals_Server, f2); PHP_METHOD(Stub_Globals_Server, check); -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_server_f1, 0, 0, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_server_f1, 0, 0, IS_VOID, NULL, 0) -#endif ZEND_END_ARG_INFO() -#else -#define arginfo_stub_globals_server_f1 NULL -#endif -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_server_f2, 0, 0, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_server_f2, 0, 0, IS_VOID, NULL, 0) -#endif ZEND_END_ARG_INFO() -#else -#define arginfo_stub_globals_server_f2 NULL -#endif ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_server_check, 0, 0, 0) ZEND_END_ARG_INFO() @@ -35,6 +19,10 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_globals_server_method_entry) { PHP_ME(Stub_Globals_Server, f1, arginfo_stub_globals_server_f1, ZEND_ACC_PUBLIC) PHP_ME(Stub_Globals_Server, f2, arginfo_stub_globals_server_f2, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Globals_Server, check, arginfo_stub_globals_server_check, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Globals_Server, check, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/globals/serverrequestfactory.zep.c b/ext/stub/globals/serverrequestfactory.zep.c index 07b9bd2ad2..d26a8d31b8 100644 --- a/ext/stub/globals/serverrequestfactory.zep.c +++ b/ext/stub/globals/serverrequestfactory.zep.c @@ -59,6 +59,19 @@ PHP_METHOD(Stub_Globals_ServerRequestFactory, load) { ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); ZVAL_UNDEF(&_5); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 5) + Z_PARAM_OPTIONAL + Z_PARAM_ARRAY_OR_NULL(server) + Z_PARAM_ARRAY_OR_NULL(get) + Z_PARAM_ARRAY_OR_NULL(post) + Z_PARAM_ARRAY_OR_NULL(cookies) + Z_PARAM_ARRAY_OR_NULL(files) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_get_global(&_SERVER, SL("_SERVER")); @@ -125,19 +138,19 @@ PHP_METHOD(Stub_Globals_ServerRequestFactory, load) { if (!(ZEPHIR_IS_EMPTY(&_SERVER))) { ZEPHIR_CPY_WRT(&globalServer, &_SERVER); } - ZEPHIR_CALL_METHOD(&_0, this_ptr, "checknullarray", &_1, 41, &server, &globalServer); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "checknullarray", &_1, 44, &server, &globalServer); zephir_check_call_status(); ZEPHIR_CPY_WRT(&server, &_0); - ZEPHIR_CALL_METHOD(&_2, this_ptr, "checknullarray", &_1, 41, &files, &globalFiles); + ZEPHIR_CALL_METHOD(&_2, this_ptr, "checknullarray", &_1, 44, &files, &globalFiles); zephir_check_call_status(); ZEPHIR_CPY_WRT(&files, &_2); - ZEPHIR_CALL_METHOD(&_3, this_ptr, "checknullarray", &_1, 41, &cookies, &globalCookies); + ZEPHIR_CALL_METHOD(&_3, this_ptr, "checknullarray", &_1, 44, &cookies, &globalCookies); zephir_check_call_status(); ZEPHIR_CPY_WRT(&cookies, &_3); - ZEPHIR_CALL_METHOD(&_4, this_ptr, "checknullarray", &_1, 41, &get, &globalGet); + ZEPHIR_CALL_METHOD(&_4, this_ptr, "checknullarray", &_1, 44, &get, &globalGet); zephir_check_call_status(); ZEPHIR_CPY_WRT(&get, &_4); - ZEPHIR_CALL_METHOD(&_5, this_ptr, "checknullarray", &_1, 41, &post, &globalPost); + ZEPHIR_CALL_METHOD(&_5, this_ptr, "checknullarray", &_1, 44, &post, &globalPost); zephir_check_call_status(); ZEPHIR_CPY_WRT(&post, &_5); zephir_create_array(return_value, 5, 0); @@ -163,6 +176,15 @@ PHP_METHOD(Stub_Globals_ServerRequestFactory, checkNullArray) { ZVAL_UNDEF(&source_sub); ZVAL_UNDEF(&super); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(source) + Z_PARAM_ARRAY(super) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &source, &super_param); diff --git a/ext/stub/globals/serverrequestfactory.zep.h b/ext/stub/globals/serverrequestfactory.zep.h index 6e193eda79..7f2ea8985d 100644 --- a/ext/stub/globals/serverrequestfactory.zep.h +++ b/ext/stub/globals/serverrequestfactory.zep.h @@ -6,11 +6,7 @@ ZEPHIR_INIT_CLASS(Stub_Globals_ServerRequestFactory); PHP_METHOD(Stub_Globals_ServerRequestFactory, load); PHP_METHOD(Stub_Globals_ServerRequestFactory, checkNullArray); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_serverrequestfactory_load, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_serverrequestfactory_load, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_ARG_ARRAY_INFO(0, server, 1) ZEND_ARG_ARRAY_INFO(0, get, 1) ZEND_ARG_ARRAY_INFO(0, post, 1) @@ -18,11 +14,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_serverrequestfactor ZEND_ARG_ARRAY_INFO(0, files, 1) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_serverrequestfactory_checknullarray, 0, 2, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_globals_serverrequestfactory_checknullarray, 0, 2, IS_ARRAY, NULL, 0) -#endif ZEND_ARG_INFO(0, source) ZEND_ARG_ARRAY_INFO(0, super, 0) ZEND_END_ARG_INFO() diff --git a/ext/stub/globals/session/base.zep.c b/ext/stub/globals/session/base.zep.c index 68cc0a81ed..0fb712b76a 100644 --- a/ext/stub/globals/session/base.zep.c +++ b/ext/stub/globals/session/base.zep.c @@ -37,6 +37,15 @@ PHP_METHOD(Stub_Globals_Session_Base, set) { ZVAL_UNDEF(&index); ZVAL_UNDEF(&value_sub); ZVAL_UNDEF(&_SESSION); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(index) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_get_global(&_SESSION, SL("_SESSION")); @@ -60,6 +69,14 @@ PHP_METHOD(Stub_Globals_Session_Base, remove) { ZVAL_UNDEF(&index); ZVAL_UNDEF(&_SESSION); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_get_global(&_SESSION, SL("_SESSION")); @@ -83,6 +100,15 @@ PHP_METHOD(Stub_Globals_Session_Base, __set) { ZVAL_UNDEF(&index); ZVAL_UNDEF(&value_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(index) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &index_param, &value); @@ -105,6 +131,14 @@ PHP_METHOD(Stub_Globals_Session_Base, __unset) { zval *this_ptr = getThis(); ZVAL_UNDEF(&index); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &index_param); @@ -132,6 +166,7 @@ PHP_METHOD(Stub_Globals_Session_Base, removeSessionData) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); zephir_get_global(&_SESSION, SL("_SESSION")); diff --git a/ext/stub/globals/session/base.zep.h b/ext/stub/globals/session/base.zep.h index 5234721e22..d1bad5eb87 100644 --- a/ext/stub/globals/session/base.zep.h +++ b/ext/stub/globals/session/base.zep.h @@ -10,37 +10,21 @@ PHP_METHOD(Stub_Globals_Session_Base, __unset); PHP_METHOD(Stub_Globals_Session_Base, removeSessionData); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_session_base_set, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, index, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, index) -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_session_base_remove, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, index, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, index) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_session_base___set, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, index, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, index) -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_session_base___unset, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, index, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, index) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_session_base_removesessiondata, 0, 0, 0) @@ -51,6 +35,10 @@ ZEPHIR_INIT_FUNCS(stub_globals_session_base_method_entry) { PHP_ME(Stub_Globals_Session_Base, remove, arginfo_stub_globals_session_base_remove, ZEND_ACC_PUBLIC) PHP_ME(Stub_Globals_Session_Base, __set, arginfo_stub_globals_session_base___set, ZEND_ACC_PUBLIC) PHP_ME(Stub_Globals_Session_Base, __unset, arginfo_stub_globals_session_base___unset, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Globals_Session_Base, removeSessionData, arginfo_stub_globals_session_base_removesessiondata, ZEND_ACC_PROTECTED) +#else + PHP_ME(Stub_Globals_Session_Base, removeSessionData, NULL, ZEND_ACC_PROTECTED) +#endif PHP_FE_END }; diff --git a/ext/stub/globals/session/child.zep.c b/ext/stub/globals/session/child.zep.c index 56d58570e8..1ca82031ad 100644 --- a/ext/stub/globals/session/child.zep.c +++ b/ext/stub/globals/session/child.zep.c @@ -32,6 +32,7 @@ PHP_METHOD(Stub_Globals_Session_Child, destroy) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "removesessiondata", NULL, 0); diff --git a/ext/stub/globals/session/child.zep.h b/ext/stub/globals/session/child.zep.h index f252715149..d490cd0a8e 100644 --- a/ext/stub/globals/session/child.zep.h +++ b/ext/stub/globals/session/child.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_globals_session_child_destroy, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_globals_session_child_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Globals_Session_Child, destroy, arginfo_stub_globals_session_child_destroy, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Globals_Session_Child, destroy, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/instance.zep.c b/ext/stub/instance.zep.c index 2a1ae89980..7bbc90c50a 100644 --- a/ext/stub/instance.zep.c +++ b/ext/stub/instance.zep.c @@ -14,6 +14,7 @@ #include "kernel/main.h" #include "kernel/memory.h" #include "kernel/object.h" +#include "ext/spl/spl_array.h" #include "kernel/array.h" #include "kernel/fcall.h" #include "kernel/operators.h" @@ -46,6 +47,24 @@ PHP_METHOD(Stub_Instance, __construct) { ZVAL_UNDEF(&a9_sub); ZVAL_UNDEF(&a10_sub); ZVAL_UNDEF(&a11_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(11, 11) + Z_PARAM_OBJECT_OF_CLASS(a1, stub_arithmetic_ce) + Z_PARAM_OBJECT_OF_CLASS(a2, spl_ce_ArrayObject) + Z_PARAM_OBJECT_OF_CLASS(a3, stub_assign_ce) + Z_PARAM_OBJECT_OF_CLASS(a4, stub_bitwise_ce) + Z_PARAM_OBJECT_OF_CLASS(a5, stub_branchprediction_ce) + Z_PARAM_OBJECT_OF_CLASS(a6, stub_cast_ce) + Z_PARAM_OBJECT_OF_CLASS(a7, stub_cblock_ce) + Z_PARAM_OBJECT_OF_CLASS(a8, stub_chars_ce) + Z_PARAM_OBJECT_OF_CLASS(a9, stub_closures_ce) + Z_PARAM_OBJECT_OF_CLASS(a10, stub_compare_ce) + Z_PARAM_OBJECT_OF_CLASS(a11, stub_concat_ce) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(11, 0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10, &a11); @@ -64,6 +83,7 @@ PHP_METHOD(Stub_Instance, testIssue1339) { ZVAL_UNDEF(¶meters); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(¶meters); @@ -77,7 +97,7 @@ PHP_METHOD(Stub_Instance, testIssue1339) { zephir_array_fast_append(¶meters, &_0); ZEPHIR_INIT_NVAR(&_0); object_init_ex(&_0, stub_arrayobject_ce); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 42); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 45); zephir_check_call_status(); zephir_array_fast_append(¶meters, &_0); ZEPHIR_INIT_NVAR(&_0); @@ -160,6 +180,14 @@ PHP_METHOD(Stub_Instance, testInstanceCreate) { zval *this_ptr = getThis(); ZVAL_UNDEF(&className); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(className) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &className_param); diff --git a/ext/stub/instance.zep.h b/ext/stub/instance.zep.h index 0eecff8187..462b76736b 100644 --- a/ext/stub/instance.zep.h +++ b/ext/stub/instance.zep.h @@ -21,23 +21,11 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_instance___construct, 0, 0, 11) ZEND_ARG_OBJ_INFO(0, a11, Stub\\Concat, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_instance_testissue1339, 0, 0, Stub\\Instance, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instance_testissue1339, 0, 0, IS_OBJECT, "Stub\\Instance", 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_instance_testinstancecreate, 0, 1, Stub\\Instance, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instance_testinstancecreate, 0, 1, IS_OBJECT, "Stub\\Instance", 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, className, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, className) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_instance_method_entry) { diff --git a/ext/stub/instanceoff.zep.c b/ext/stub/instanceoff.zep.c index c635de740d..9188e07248 100644 --- a/ext/stub/instanceoff.zep.c +++ b/ext/stub/instanceoff.zep.c @@ -37,6 +37,7 @@ PHP_METHOD(Stub_Instanceoff, testInstanceOf1) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -54,6 +55,7 @@ PHP_METHOD(Stub_Instanceoff, testInstanceOf2) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -74,6 +76,7 @@ PHP_METHOD(Stub_Instanceoff, testInstanceOf3) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -88,6 +91,14 @@ PHP_METHOD(Stub_Instanceoff, testInstanceOf4) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -106,6 +117,14 @@ PHP_METHOD(Stub_Instanceoff, testInstanceOf5) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -127,6 +146,7 @@ PHP_METHOD(Stub_Instanceoff, testInstanceOf6) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -145,6 +165,14 @@ PHP_METHOD(Stub_Instanceoff, testInstanceOf7) { zval *this_ptr = getThis(); ZVAL_UNDEF(&test_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT(test) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &test); @@ -164,6 +192,14 @@ PHP_METHOD(Stub_Instanceoff, testInstanceOf8) { ZVAL_UNDEF(&test); ZVAL_UNDEF(&a); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(test) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &test_param); @@ -190,6 +226,15 @@ PHP_METHOD(Stub_Instanceoff, testInstanceOf9) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&test); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_OBJECT(a) + Z_PARAM_STR(test) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &test_param); diff --git a/ext/stub/instanceoff.zep.h b/ext/stub/instanceoff.zep.h index 56f7f4ff7f..ea1c94f79f 100644 --- a/ext/stub/instanceoff.zep.h +++ b/ext/stub/instanceoff.zep.h @@ -13,81 +13,37 @@ PHP_METHOD(Stub_Instanceoff, testInstanceOf7); PHP_METHOD(Stub_Instanceoff, testInstanceOf8); PHP_METHOD(Stub_Instanceoff, testInstanceOf9); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof1, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof1, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof2, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof2, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof3, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof3, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof4, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof4, 0, 1, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_INFO(0, a) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof5, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof5, 0, 1, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_INFO(0, a) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof6, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof6, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof7, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof7, 0, 1, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_INFO(0, test) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof8, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof8, 0, 1, _IS_BOOL, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, test, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, test) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof9, 0, 2, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_instanceoff_testinstanceof9, 0, 2, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_INFO(0, a) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, test, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, test) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_instanceoff_method_entry) { diff --git a/ext/stub/interfaces/implementint.zep.c b/ext/stub/interfaces/implementint.zep.c new file mode 100644 index 0000000000..d37f248435 --- /dev/null +++ b/ext/stub/interfaces/implementint.zep.c @@ -0,0 +1,67 @@ + +#ifdef HAVE_CONFIG_H +#include "../../ext_config.h" +#endif + +#include +#include "../../php_ext.h" +#include "../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/object.h" +#include "kernel/memory.h" +#include "kernel/operators.h" + + +ZEPHIR_INIT_CLASS(Stub_Interfaces_ImplementInt) { + + ZEPHIR_REGISTER_CLASS(Stub\\Interfaces, ImplementInt, stub, interfaces_implementint, stub_interfaces_implementint_method_entry, 0); + + zend_declare_property_null(stub_interfaces_implementint_ce, SL("val"), ZEND_ACC_PROTECTED); + + zend_class_implements(stub_interfaces_implementint_ce, 1, stub_interfaces_interfaceint_ce); + return SUCCESS; + +} + +PHP_METHOD(Stub_Interfaces_ImplementInt, set) { + + zval *val_param = NULL, _0; + zend_long val; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(val) + ZEND_PARSE_PARAMETERS_END(); + +#endif + + + zephir_fetch_params_without_memory_grow(1, 0, &val_param); + + val = zephir_get_intval(val_param); + + + ZEPHIR_INIT_ZVAL_NREF(_0); + ZVAL_LONG(&_0, val); + zephir_update_property_zval(this_ptr, ZEND_STRL("val"), &_0); + +} + +PHP_METHOD(Stub_Interfaces_ImplementInt, get) { + + zval *this_ptr = getThis(); + + + + RETURN_MEMBER(getThis(), "val"); + +} + diff --git a/ext/stub/interfaces/implementint.zep.h b/ext/stub/interfaces/implementint.zep.h new file mode 100644 index 0000000000..aa8ff04d39 --- /dev/null +++ b/ext/stub/interfaces/implementint.zep.h @@ -0,0 +1,21 @@ + +extern zend_class_entry *stub_interfaces_implementint_ce; + +ZEPHIR_INIT_CLASS(Stub_Interfaces_ImplementInt); + +PHP_METHOD(Stub_Interfaces_ImplementInt, set); +PHP_METHOD(Stub_Interfaces_ImplementInt, get); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_interfaces_implementint_set, 0, 1, IS_VOID, 0) + + ZEND_ARG_TYPE_INFO(0, val, IS_LONG, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_interfaces_implementint_get, 0, 0, IS_LONG, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(stub_interfaces_implementint_method_entry) { + PHP_ME(Stub_Interfaces_ImplementInt, set, arginfo_stub_interfaces_implementint_set, ZEND_ACC_PUBLIC) + PHP_ME(Stub_Interfaces_ImplementInt, get, arginfo_stub_interfaces_implementint_get, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/stub/interfaces/implementinterface.zep.c b/ext/stub/interfaces/implementinterface.zep.c new file mode 100644 index 0000000000..061aa76cf5 --- /dev/null +++ b/ext/stub/interfaces/implementinterface.zep.c @@ -0,0 +1,91 @@ + +#ifdef HAVE_CONFIG_H +#include "../../ext_config.h" +#endif + +#include +#include "../../php_ext.h" +#include "../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/fcall.h" +#include "kernel/memory.h" +#include "kernel/object.h" + + +ZEPHIR_INIT_CLASS(Stub_Interfaces_ImplementInterface) { + + ZEPHIR_REGISTER_CLASS(Stub\\Interfaces, ImplementInterface, stub, interfaces_implementinterface, stub_interfaces_implementinterface_method_entry, 0); + + zend_declare_property_null(stub_interfaces_implementinterface_ce, SL("obj"), ZEND_ACC_PROTECTED); + + zend_class_implements(stub_interfaces_implementinterface_ce, 1, stub_interfaces_interfaceintsignature_ce); + return SUCCESS; + +} + +PHP_METHOD(Stub_Interfaces_ImplementInterface, get) { + + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *obj, obj_sub; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&obj_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(obj, stub_interfaces_interfaceint_ce) + ZEND_PARSE_PARAMETERS_END(); + +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &obj); + + + + ZEPHIR_RETURN_CALL_METHOD(obj, "get", NULL, 0); + zephir_check_call_status(); + RETURN_MM(); + +} + +PHP_METHOD(Stub_Interfaces_ImplementInterface, getVoid) { + + zval *obj, obj_sub; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&obj_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(obj, stub_interfaces_interfaceint_ce) + ZEND_PARSE_PARAMETERS_END(); + +#endif + + + zephir_fetch_params_without_memory_grow(1, 0, &obj); + + + + zephir_update_property_zval(this_ptr, ZEND_STRL("obj"), obj); + +} + +PHP_METHOD(Stub_Interfaces_ImplementInterface, getObj) { + + zval *this_ptr = getThis(); + + + + RETURN_MEMBER(getThis(), "obj"); + +} + diff --git a/ext/stub/interfaces/implementinterface.zep.h b/ext/stub/interfaces/implementinterface.zep.h new file mode 100644 index 0000000000..ce42ba4b7b --- /dev/null +++ b/ext/stub/interfaces/implementinterface.zep.h @@ -0,0 +1,27 @@ + +extern zend_class_entry *stub_interfaces_implementinterface_ce; + +ZEPHIR_INIT_CLASS(Stub_Interfaces_ImplementInterface); + +PHP_METHOD(Stub_Interfaces_ImplementInterface, get); +PHP_METHOD(Stub_Interfaces_ImplementInterface, getVoid); +PHP_METHOD(Stub_Interfaces_ImplementInterface, getObj); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_interfaces_implementinterface_get, 0, 1, IS_LONG, 0) + ZEND_ARG_OBJ_INFO(0, obj, Stub\\Interfaces\\InterfaceInt, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_interfaces_implementinterface_getvoid, 0, 1, IS_VOID, 0) + + ZEND_ARG_OBJ_INFO(0, obj, Stub\\Interfaces\\InterfaceInt, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_interfaces_implementinterface_getobj, 0, 0, Stub\\Interfaces\\InterfaceInt, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(stub_interfaces_implementinterface_method_entry) { + PHP_ME(Stub_Interfaces_ImplementInterface, get, arginfo_stub_interfaces_implementinterface_get, ZEND_ACC_PUBLIC) + PHP_ME(Stub_Interfaces_ImplementInterface, getVoid, arginfo_stub_interfaces_implementinterface_getvoid, ZEND_ACC_PUBLIC) + PHP_ME(Stub_Interfaces_ImplementInterface, getObj, arginfo_stub_interfaces_implementinterface_getobj, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/stub/interfaces/interfaceint.zep.c b/ext/stub/interfaces/interfaceint.zep.c new file mode 100644 index 0000000000..a1ba4790fc --- /dev/null +++ b/ext/stub/interfaces/interfaceint.zep.c @@ -0,0 +1,24 @@ + +#ifdef HAVE_CONFIG_H +#include "../../ext_config.h" +#endif + +#include +#include "../../php_ext.h" +#include "../../ext.h" + +#include + +#include "kernel/main.h" + + +ZEPHIR_INIT_CLASS(Stub_Interfaces_InterfaceInt) { + + ZEPHIR_REGISTER_INTERFACE(Stub\\Interfaces, InterfaceInt, stub, interfaces_interfaceint, stub_interfaces_interfaceint_method_entry); + + return SUCCESS; + +} + +ZEPHIR_DOC_METHOD(Stub_Interfaces_InterfaceInt, set); +ZEPHIR_DOC_METHOD(Stub_Interfaces_InterfaceInt, get); diff --git a/ext/stub/interfaces/interfaceint.zep.h b/ext/stub/interfaces/interfaceint.zep.h new file mode 100644 index 0000000000..b70e2858e9 --- /dev/null +++ b/ext/stub/interfaces/interfaceint.zep.h @@ -0,0 +1,18 @@ + +extern zend_class_entry *stub_interfaces_interfaceint_ce; + +ZEPHIR_INIT_CLASS(Stub_Interfaces_InterfaceInt); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_interfaces_interfaceint_set, 0, 1, IS_VOID, 0) + + ZEND_ARG_TYPE_INFO(0, val, IS_LONG, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_interfaces_interfaceint_get, 0, 0, IS_LONG, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(stub_interfaces_interfaceint_method_entry) { + PHP_ABSTRACT_ME(Stub_Interfaces_InterfaceInt, set, arginfo_stub_interfaces_interfaceint_set) + PHP_ABSTRACT_ME(Stub_Interfaces_InterfaceInt, get, arginfo_stub_interfaces_interfaceint_get) + PHP_FE_END +}; diff --git a/ext/stub/interfaces/interfaceintsignature.zep.c b/ext/stub/interfaces/interfaceintsignature.zep.c new file mode 100644 index 0000000000..1f63b3d656 --- /dev/null +++ b/ext/stub/interfaces/interfaceintsignature.zep.c @@ -0,0 +1,23 @@ + +#ifdef HAVE_CONFIG_H +#include "../../ext_config.h" +#endif + +#include +#include "../../php_ext.h" +#include "../../ext.h" + +#include + +#include "kernel/main.h" + + +ZEPHIR_INIT_CLASS(Stub_Interfaces_InterfaceIntSignature) { + + ZEPHIR_REGISTER_INTERFACE(Stub\\Interfaces, InterfaceIntSignature, stub, interfaces_interfaceintsignature, stub_interfaces_interfaceintsignature_method_entry); + + return SUCCESS; + +} + +ZEPHIR_DOC_METHOD(Stub_Interfaces_InterfaceIntSignature, get); diff --git a/ext/stub/interfaces/interfaceintsignature.zep.h b/ext/stub/interfaces/interfaceintsignature.zep.h new file mode 100644 index 0000000000..560592badf --- /dev/null +++ b/ext/stub/interfaces/interfaceintsignature.zep.h @@ -0,0 +1,13 @@ + +extern zend_class_entry *stub_interfaces_interfaceintsignature_ce; + +ZEPHIR_INIT_CLASS(Stub_Interfaces_InterfaceIntSignature); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_interfaces_interfaceintsignature_get, 0, 1, IS_LONG, 0) + ZEND_ARG_OBJ_INFO(0, obj, Stub\\Interfaces\\InterfaceInt, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(stub_interfaces_interfaceintsignature_method_entry) { + PHP_ABSTRACT_ME(Stub_Interfaces_InterfaceIntSignature, get, arginfo_stub_interfaces_interfaceintsignature_get) + PHP_FE_END +}; diff --git a/ext/stub/internalclasses.zep.c b/ext/stub/internalclasses.zep.c index 4c0a6ffabe..7f4b0f2d8e 100644 --- a/ext/stub/internalclasses.zep.c +++ b/ext/stub/internalclasses.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(Stub_InternalClasses, testStaticCall) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); _0 = zephir_fetch_class_str_ex(SL("Phalcon\\Di"), ZEND_FETCH_CLASS_AUTO); @@ -47,6 +48,7 @@ PHP_METHOD(Stub_InternalClasses, testStaticPropertyFetch) { zval *this_ptr = getThis(); + RETURN_LONG(303); } diff --git a/ext/stub/internalclasses.zep.h b/ext/stub/internalclasses.zep.h index 89edd51d8f..1148679325 100644 --- a/ext/stub/internalclasses.zep.h +++ b/ext/stub/internalclasses.zep.h @@ -13,7 +13,15 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_internalclasses_teststaticpropertyfetch, 0, ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_internalclasses_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_InternalClasses, testStaticCall, arginfo_stub_internalclasses_teststaticcall, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_InternalClasses, testStaticCall, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_InternalClasses, testStaticPropertyFetch, arginfo_stub_internalclasses_teststaticpropertyfetch, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_InternalClasses, testStaticPropertyFetch, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/internalinterfaces.zep.c b/ext/stub/internalinterfaces.zep.c index 8379e5e31e..fc030f42d2 100644 --- a/ext/stub/internalinterfaces.zep.c +++ b/ext/stub/internalinterfaces.zep.c @@ -12,7 +12,6 @@ #include #include "kernel/main.h" -#include "ext/spl/spl_iterators.h" #include "kernel/object.h" @@ -20,7 +19,7 @@ ZEPHIR_INIT_CLASS(Stub_InternalInterfaces) { ZEPHIR_REGISTER_CLASS(Stub, InternalInterfaces, stub, internalinterfaces, stub_internalinterfaces_method_entry, 0); - zend_class_implements(stub_internalinterfaces_ce, 1, spl_ce_Countable); + zend_class_implements(stub_internalinterfaces_ce, 1, zend_ce_countable); return SUCCESS; } @@ -31,5 +30,6 @@ PHP_METHOD(Stub_InternalInterfaces, count) { + } diff --git a/ext/stub/internalinterfaces.zep.h b/ext/stub/internalinterfaces.zep.h index 987e87647d..3083366114 100644 --- a/ext/stub/internalinterfaces.zep.h +++ b/ext/stub/internalinterfaces.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_internalinterfaces_count, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_internalinterfaces_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_InternalInterfaces, count, arginfo_stub_internalinterfaces_count, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_InternalInterfaces, count, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/invoke.zep.c b/ext/stub/invoke.zep.c index 7e65dfd277..05637b212e 100644 --- a/ext/stub/invoke.zep.c +++ b/ext/stub/invoke.zep.c @@ -35,6 +35,7 @@ PHP_METHOD(Stub_Invoke, __construct) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -53,6 +54,7 @@ PHP_METHOD(Stub_Invoke, __invoke) { ZVAL_UNDEF(&_0); + zephir_read_property(&_0, this_ptr, ZEND_STRL("a"), PH_NOISY_CC | PH_READONLY); zephir_gettype(return_value, &_0); return; @@ -68,11 +70,12 @@ PHP_METHOD(Stub_Invoke, test) { ZVAL_UNDEF(&func); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&func); object_init_ex(&func, stub_invoke_ce); - ZEPHIR_CALL_METHOD(NULL, &func, "__construct", NULL, 43); + ZEPHIR_CALL_METHOD(NULL, &func, "__construct", NULL, 46); zephir_check_call_status(); ZEPHIR_RETURN_CALL_ZVAL_FUNCTION(&func, NULL, 0); zephir_check_call_status(); diff --git a/ext/stub/invoke.zep.h b/ext/stub/invoke.zep.h index 9087239497..523313d408 100644 --- a/ext/stub/invoke.zep.h +++ b/ext/stub/invoke.zep.h @@ -10,22 +10,18 @@ PHP_METHOD(Stub_Invoke, test); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_invoke___construct, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_invoke___invoke, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_invoke___invoke, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_invoke_test, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_invoke_test, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_invoke_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Invoke, __construct, arginfo_stub_invoke___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#else + PHP_ME(Stub_Invoke, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#endif PHP_ME(Stub_Invoke, __invoke, arginfo_stub_invoke___invoke, ZEND_ACC_PUBLIC) PHP_ME(Stub_Invoke, test, arginfo_stub_invoke_test, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) PHP_FE_END diff --git a/ext/stub/invokes/abstractinvoker.zep.c b/ext/stub/invokes/abstractinvoker.zep.c new file mode 100644 index 0000000000..ba6d5d3825 --- /dev/null +++ b/ext/stub/invokes/abstractinvoker.zep.c @@ -0,0 +1,56 @@ + +#ifdef HAVE_CONFIG_H +#include "../../ext_config.h" +#endif + +#include +#include "../../php_ext.h" +#include "../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/fcall.h" +#include "kernel/object.h" +#include "kernel/memory.h" + + +ZEPHIR_INIT_CLASS(Stub_Invokes_AbstractInvoker) { + + ZEPHIR_REGISTER_CLASS_EX(Stub\\Invokes, AbstractInvoker, stub, invokes_abstractinvoker, stub_invokes_abstractprotected_ce, stub_invokes_abstractinvoker_method_entry, ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); + + return SUCCESS; + +} + +PHP_METHOD(Stub_Invokes_AbstractInvoker, __toString) { + + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&_0); + + + ZEPHIR_MM_GROW(); + + zephir_read_property(&_0, this_ptr, ZEND_STRL("text"), PH_NOISY_CC | PH_READONLY); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "renderarrayelements", NULL, 0, &_0); + zephir_check_call_status(); + RETURN_MM(); + +} + +PHP_METHOD(Stub_Invokes_AbstractInvoker, __invoke) { + + zval *this_ptr = getThis(); + + + + RETURN_THISW(); + +} + diff --git a/ext/stub/invokes/abstractinvoker.zep.h b/ext/stub/invokes/abstractinvoker.zep.h new file mode 100644 index 0000000000..4c0eb0c35a --- /dev/null +++ b/ext/stub/invokes/abstractinvoker.zep.h @@ -0,0 +1,27 @@ + +extern zend_class_entry *stub_invokes_abstractinvoker_ce; + +ZEPHIR_INIT_CLASS(Stub_Invokes_AbstractInvoker); + +PHP_METHOD(Stub_Invokes_AbstractInvoker, __toString); +PHP_METHOD(Stub_Invokes_AbstractInvoker, __invoke); + +#if PHP_VERSION_ID >= 80000 +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_invokes_abstractinvoker___tostring, 0, 0, IS_STRING, 0) +#else +ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_invokes_abstractinvoker___tostring, 0, 0, 0) +#endif +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_invokes_abstractinvoker___invoke, 0, 0, Stub\\Invokes\\AbstractInvoker, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(stub_invokes_abstractinvoker_method_entry) { +#if PHP_VERSION_ID >= 80000 + PHP_ME(Stub_Invokes_AbstractInvoker, __toString, arginfo_stub_invokes_abstractinvoker___tostring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Invokes_AbstractInvoker, __toString, NULL, ZEND_ACC_PUBLIC) +#endif + PHP_ME(Stub_Invokes_AbstractInvoker, __invoke, arginfo_stub_invokes_abstractinvoker___invoke, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/stub/invokes/abstractinvokercomplex.zep.c b/ext/stub/invokes/abstractinvokercomplex.zep.c new file mode 100644 index 0000000000..24cd2fa62e --- /dev/null +++ b/ext/stub/invokes/abstractinvokercomplex.zep.c @@ -0,0 +1,56 @@ + +#ifdef HAVE_CONFIG_H +#include "../../ext_config.h" +#endif + +#include +#include "../../php_ext.h" +#include "../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/fcall.h" +#include "kernel/object.h" +#include "kernel/memory.h" + + +ZEPHIR_INIT_CLASS(Stub_Invokes_AbstractInvokerComplex) { + + ZEPHIR_REGISTER_CLASS_EX(Stub\\Invokes, AbstractInvokerComplex, stub, invokes_abstractinvokercomplex, stub_invokes_abstractprotected_ce, stub_invokes_abstractinvokercomplex_method_entry, ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); + + return SUCCESS; + +} + +PHP_METHOD(Stub_Invokes_AbstractInvokerComplex, __toString) { + + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&_0); + + + ZEPHIR_MM_GROW(); + + zephir_read_property(&_0, this_ptr, ZEND_STRL("text"), PH_NOISY_CC | PH_READONLY); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "renderarrayelementscomplex", NULL, 0, &_0); + zephir_check_call_status(); + RETURN_MM(); + +} + +PHP_METHOD(Stub_Invokes_AbstractInvokerComplex, __invoke) { + + zval *this_ptr = getThis(); + + + + RETURN_THISW(); + +} + diff --git a/ext/stub/invokes/abstractinvokercomplex.zep.h b/ext/stub/invokes/abstractinvokercomplex.zep.h new file mode 100644 index 0000000000..f32ec8339b --- /dev/null +++ b/ext/stub/invokes/abstractinvokercomplex.zep.h @@ -0,0 +1,27 @@ + +extern zend_class_entry *stub_invokes_abstractinvokercomplex_ce; + +ZEPHIR_INIT_CLASS(Stub_Invokes_AbstractInvokerComplex); + +PHP_METHOD(Stub_Invokes_AbstractInvokerComplex, __toString); +PHP_METHOD(Stub_Invokes_AbstractInvokerComplex, __invoke); + +#if PHP_VERSION_ID >= 80000 +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_invokes_abstractinvokercomplex___tostring, 0, 0, IS_STRING, 0) +#else +ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_invokes_abstractinvokercomplex___tostring, 0, 0, 0) +#endif +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_invokes_abstractinvokercomplex___invoke, 0, 0, Stub\\Invokes\\AbstractInvoker, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(stub_invokes_abstractinvokercomplex_method_entry) { +#if PHP_VERSION_ID >= 80000 + PHP_ME(Stub_Invokes_AbstractInvokerComplex, __toString, arginfo_stub_invokes_abstractinvokercomplex___tostring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Invokes_AbstractInvokerComplex, __toString, NULL, ZEND_ACC_PUBLIC) +#endif + PHP_ME(Stub_Invokes_AbstractInvokerComplex, __invoke, arginfo_stub_invokes_abstractinvokercomplex___invoke, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/stub/invokes/abstractprotected.zep.c b/ext/stub/invokes/abstractprotected.zep.c new file mode 100644 index 0000000000..60dec1c489 --- /dev/null +++ b/ext/stub/invokes/abstractprotected.zep.c @@ -0,0 +1,252 @@ + +#ifdef HAVE_CONFIG_H +#include "../../ext_config.h" +#endif + +#include +#include "../../php_ext.h" +#include "../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/concat.h" +#include "kernel/memory.h" +#include "kernel/operators.h" +#include "kernel/object.h" +#include "kernel/array.h" +#include "kernel/fcall.h" + + +ZEPHIR_INIT_CLASS(Stub_Invokes_AbstractProtected) { + + ZEPHIR_REGISTER_CLASS(Stub\\Invokes, AbstractProtected, stub, invokes_abstractprotected, stub_invokes_abstractprotected_method_entry, ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); + + zend_declare_property_null(stub_invokes_abstractprotected_ce, SL("text"), ZEND_ACC_PROTECTED); + + return SUCCESS; + +} + +PHP_METHOD(Stub_Invokes_AbstractProtected, protectedMethod1) { + + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zval *text_param = NULL, ret; + zval text, _0; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&text); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&ret); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(text) + ZEND_PARSE_PARAMETERS_END(); + +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &text_param); + + zephir_get_strval(&text, text_param); + + + ZEPHIR_INIT_VAR(&_0); + ZEPHIR_CONCAT_VS(&_0, &text, "1"); + ZEPHIR_CPY_WRT(&ret, &_0); + RETURN_CCTOR(&ret); + +} + +PHP_METHOD(Stub_Invokes_AbstractProtected, protectedMethod2) { + + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zval *text_param = NULL, ret; + zval text, _0; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&text); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&ret); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(text) + ZEND_PARSE_PARAMETERS_END(); + +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &text_param); + + zephir_get_strval(&text, text_param); + + + ZEPHIR_INIT_VAR(&_0); + ZEPHIR_CONCAT_VS(&_0, &text, "2"); + ZEPHIR_CPY_WRT(&ret, &_0); + RETURN_CCTOR(&ret); + +} + +PHP_METHOD(Stub_Invokes_AbstractProtected, renderArrayElements) { + + zval _0, _2; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *text_param = NULL, _1; + zval text; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&text); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(text) + ZEND_PARSE_PARAMETERS_END(); + +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &text_param); + + zephir_get_strval(&text, text_param); + + + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 2, 0); + zephir_array_fast_append(&_0, this_ptr); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "protectedMethod2"); + zephir_array_fast_append(&_0, &_1); + ZEPHIR_INIT_VAR(&_2); + zephir_create_array(&_2, 1, 0); + zephir_array_fast_append(&_2, &text); + ZEPHIR_CALL_USER_FUNC_ARRAY(return_value, &_0, &_2); + zephir_check_call_status(); + RETURN_MM(); + +} + +PHP_METHOD(Stub_Invokes_AbstractProtected, renderArrayElementsComplex) { + + zval elements, _0, _2, _6$$3, _10$$4; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *text_param = NULL, item, _1, *_3, _4, _5$$3, _7$$3, _8$$3, _9$$4, _11$$4, _12$$4; + zval text, result; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&text); + ZVAL_UNDEF(&result); + ZVAL_UNDEF(&item); + ZVAL_UNDEF(&_1); + ZVAL_UNDEF(&_4); + ZVAL_UNDEF(&_5$$3); + ZVAL_UNDEF(&_7$$3); + ZVAL_UNDEF(&_8$$3); + ZVAL_UNDEF(&_9$$4); + ZVAL_UNDEF(&_11$$4); + ZVAL_UNDEF(&_12$$4); + ZVAL_UNDEF(&elements); + ZVAL_UNDEF(&_0); + ZVAL_UNDEF(&_2); + ZVAL_UNDEF(&_6$$3); + ZVAL_UNDEF(&_10$$4); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(text) + ZEND_PARSE_PARAMETERS_END(); + +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &text_param); + + zephir_get_strval(&text, text_param); + + + ZEPHIR_INIT_VAR(&result); + ZVAL_STRING(&result, ""); + ZEPHIR_INIT_VAR(&elements); + zephir_create_array(&elements, 2, 0); + ZEPHIR_INIT_VAR(&_0); + zephir_create_array(&_0, 2, 0); + ZEPHIR_INIT_VAR(&_1); + ZVAL_STRING(&_1, "protectedMethod1"); + zephir_array_fast_append(&_0, &_1); + ZEPHIR_INIT_VAR(&_2); + zephir_create_array(&_2, 1, 0); + zephir_array_fast_append(&_2, &text); + zephir_array_fast_append(&_0, &_2); + zephir_array_fast_append(&elements, &_0); + ZEPHIR_INIT_NVAR(&_0); + zephir_create_array(&_0, 2, 0); + ZEPHIR_INIT_NVAR(&_1); + ZVAL_STRING(&_1, "protectedMethod2"); + zephir_array_fast_append(&_0, &_1); + ZEPHIR_INIT_NVAR(&_2); + zephir_create_array(&_2, 1, 0); + zephir_array_fast_append(&_2, &text); + zephir_array_fast_append(&_0, &_2); + zephir_array_fast_append(&elements, &_0); + zephir_is_iterable(&elements, 0, "stub/invokes/abstractprotected.zep", 49); + if (Z_TYPE_P(&elements) == IS_ARRAY) { + ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(&elements), _3) + { + ZEPHIR_INIT_NVAR(&item); + ZVAL_COPY(&item, _3); + ZEPHIR_INIT_NVAR(&_5$$3); + ZEPHIR_INIT_NVAR(&_6$$3); + zephir_create_array(&_6$$3, 2, 0); + zephir_array_fast_append(&_6$$3, this_ptr); + ZEPHIR_OBS_NVAR(&_7$$3); + zephir_array_fetch_long(&_7$$3, &item, 0, PH_NOISY, "stub/invokes/abstractprotected.zep", 46); + zephir_array_fast_append(&_6$$3, &_7$$3); + zephir_array_fetch_long(&_8$$3, &item, 1, PH_NOISY | PH_READONLY, "stub/invokes/abstractprotected.zep", 46); + ZEPHIR_CALL_USER_FUNC_ARRAY(&_5$$3, &_6$$3, &_8$$3); + zephir_check_call_status(); + zephir_concat_self(&result, &_5$$3); + } ZEND_HASH_FOREACH_END(); + } else { + ZEPHIR_CALL_METHOD(NULL, &elements, "rewind", NULL, 0); + zephir_check_call_status(); + while (1) { + ZEPHIR_CALL_METHOD(&_4, &elements, "valid", NULL, 0); + zephir_check_call_status(); + if (!zend_is_true(&_4)) { + break; + } + ZEPHIR_CALL_METHOD(&item, &elements, "current", NULL, 0); + zephir_check_call_status(); + ZEPHIR_INIT_NVAR(&_9$$4); + ZEPHIR_INIT_NVAR(&_10$$4); + zephir_create_array(&_10$$4, 2, 0); + zephir_array_fast_append(&_10$$4, this_ptr); + ZEPHIR_OBS_NVAR(&_11$$4); + zephir_array_fetch_long(&_11$$4, &item, 0, PH_NOISY, "stub/invokes/abstractprotected.zep", 46); + zephir_array_fast_append(&_10$$4, &_11$$4); + zephir_array_fetch_long(&_12$$4, &item, 1, PH_NOISY | PH_READONLY, "stub/invokes/abstractprotected.zep", 46); + ZEPHIR_CALL_USER_FUNC_ARRAY(&_9$$4, &_10$$4, &_12$$4); + zephir_check_call_status(); + zephir_concat_self(&result, &_9$$4); + ZEPHIR_CALL_METHOD(NULL, &elements, "next", NULL, 0); + zephir_check_call_status(); + } + } + ZEPHIR_INIT_NVAR(&item); + RETURN_CTOR(&result); + +} + diff --git a/ext/stub/invokes/abstractprotected.zep.h b/ext/stub/invokes/abstractprotected.zep.h new file mode 100644 index 0000000000..4e52f7b514 --- /dev/null +++ b/ext/stub/invokes/abstractprotected.zep.h @@ -0,0 +1,33 @@ + +extern zend_class_entry *stub_invokes_abstractprotected_ce; + +ZEPHIR_INIT_CLASS(Stub_Invokes_AbstractProtected); + +PHP_METHOD(Stub_Invokes_AbstractProtected, protectedMethod1); +PHP_METHOD(Stub_Invokes_AbstractProtected, protectedMethod2); +PHP_METHOD(Stub_Invokes_AbstractProtected, renderArrayElements); +PHP_METHOD(Stub_Invokes_AbstractProtected, renderArrayElementsComplex); + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_invokes_abstractprotected_protectedmethod1, 0, 1, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, text, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_invokes_abstractprotected_protectedmethod2, 0, 1, IS_STRING, 0) + ZEND_ARG_TYPE_INFO(0, text, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_invokes_abstractprotected_renderarrayelements, 0, 0, 1) + ZEND_ARG_TYPE_INFO(0, text, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_invokes_abstractprotected_renderarrayelementscomplex, 0, 0, 1) + ZEND_ARG_TYPE_INFO(0, text, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(stub_invokes_abstractprotected_method_entry) { + PHP_ME(Stub_Invokes_AbstractProtected, protectedMethod1, arginfo_stub_invokes_abstractprotected_protectedmethod1, ZEND_ACC_PROTECTED) + PHP_ME(Stub_Invokes_AbstractProtected, protectedMethod2, arginfo_stub_invokes_abstractprotected_protectedmethod2, ZEND_ACC_PROTECTED) + PHP_ME(Stub_Invokes_AbstractProtected, renderArrayElements, arginfo_stub_invokes_abstractprotected_renderarrayelements, ZEND_ACC_PROTECTED) + PHP_ME(Stub_Invokes_AbstractProtected, renderArrayElementsComplex, arginfo_stub_invokes_abstractprotected_renderarrayelementscomplex, ZEND_ACC_PROTECTED) + PHP_FE_END +}; diff --git a/ext/stub/invokes/invokeprotected.zep.c b/ext/stub/invokes/invokeprotected.zep.c new file mode 100644 index 0000000000..aea25ceff7 --- /dev/null +++ b/ext/stub/invokes/invokeprotected.zep.c @@ -0,0 +1,55 @@ + +#ifdef HAVE_CONFIG_H +#include "../../ext_config.h" +#endif + +#include +#include "../../php_ext.h" +#include "../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/object.h" +#include "kernel/operators.h" +#include "kernel/memory.h" + + +ZEPHIR_INIT_CLASS(Stub_Invokes_InvokeProtected) { + + ZEPHIR_REGISTER_CLASS_EX(Stub\\Invokes, InvokeProtected, stub, invokes_invokeprotected, stub_invokes_abstractinvoker_ce, stub_invokes_invokeprotected_method_entry, 0); + + return SUCCESS; + +} + +PHP_METHOD(Stub_Invokes_InvokeProtected, __construct) { + + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zval *text_param = NULL; + zval text; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&text); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(text) + ZEND_PARSE_PARAMETERS_END(); + +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &text_param); + + zephir_get_strval(&text, text_param); + + + zephir_update_property_zval(this_ptr, ZEND_STRL("text"), &text); + ZEPHIR_MM_RESTORE(); + +} + diff --git a/ext/stub/invokes/invokeprotected.zep.h b/ext/stub/invokes/invokeprotected.zep.h new file mode 100644 index 0000000000..0963c97372 --- /dev/null +++ b/ext/stub/invokes/invokeprotected.zep.h @@ -0,0 +1,15 @@ + +extern zend_class_entry *stub_invokes_invokeprotected_ce; + +ZEPHIR_INIT_CLASS(Stub_Invokes_InvokeProtected); + +PHP_METHOD(Stub_Invokes_InvokeProtected, __construct); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_invokes_invokeprotected___construct, 0, 0, 1) + ZEND_ARG_TYPE_INFO(0, text, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(stub_invokes_invokeprotected_method_entry) { + PHP_ME(Stub_Invokes_InvokeProtected, __construct, arginfo_stub_invokes_invokeprotected___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_FE_END +}; diff --git a/ext/stub/invokes/invokeprotectedcomplex.zep.c b/ext/stub/invokes/invokeprotectedcomplex.zep.c new file mode 100644 index 0000000000..55cad9e8fb --- /dev/null +++ b/ext/stub/invokes/invokeprotectedcomplex.zep.c @@ -0,0 +1,55 @@ + +#ifdef HAVE_CONFIG_H +#include "../../ext_config.h" +#endif + +#include +#include "../../php_ext.h" +#include "../../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/object.h" +#include "kernel/operators.h" +#include "kernel/memory.h" + + +ZEPHIR_INIT_CLASS(Stub_Invokes_InvokeProtectedComplex) { + + ZEPHIR_REGISTER_CLASS_EX(Stub\\Invokes, InvokeProtectedComplex, stub, invokes_invokeprotectedcomplex, stub_invokes_abstractinvokercomplex_ce, stub_invokes_invokeprotectedcomplex_method_entry, 0); + + return SUCCESS; + +} + +PHP_METHOD(Stub_Invokes_InvokeProtectedComplex, __construct) { + + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zval *text_param = NULL; + zval text; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&text); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(text) + ZEND_PARSE_PARAMETERS_END(); + +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &text_param); + + zephir_get_strval(&text, text_param); + + + zephir_update_property_zval(this_ptr, ZEND_STRL("text"), &text); + ZEPHIR_MM_RESTORE(); + +} + diff --git a/ext/stub/invokes/invokeprotectedcomplex.zep.h b/ext/stub/invokes/invokeprotectedcomplex.zep.h new file mode 100644 index 0000000000..4faaebaced --- /dev/null +++ b/ext/stub/invokes/invokeprotectedcomplex.zep.h @@ -0,0 +1,15 @@ + +extern zend_class_entry *stub_invokes_invokeprotectedcomplex_ce; + +ZEPHIR_INIT_CLASS(Stub_Invokes_InvokeProtectedComplex); + +PHP_METHOD(Stub_Invokes_InvokeProtectedComplex, __construct); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_invokes_invokeprotectedcomplex___construct, 0, 0, 1) + ZEND_ARG_TYPE_INFO(0, text, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(stub_invokes_invokeprotectedcomplex_method_entry) { + PHP_ME(Stub_Invokes_InvokeProtectedComplex, __construct, arginfo_stub_invokes_invokeprotectedcomplex___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) + PHP_FE_END +}; diff --git a/ext/stub/issettest.zep.c b/ext/stub/issettest.zep.c index 6d61634dd3..aeffcb5116 100644 --- a/ext/stub/issettest.zep.c +++ b/ext/stub/issettest.zep.c @@ -39,6 +39,15 @@ PHP_METHOD(Stub_IssetTest, testIssetArray1) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); @@ -55,6 +64,15 @@ PHP_METHOD(Stub_IssetTest, testIssetArray2) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_LONG(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b_param); @@ -74,6 +92,15 @@ PHP_METHOD(Stub_IssetTest, testIssetArray3) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_STR(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b_param); @@ -91,6 +118,14 @@ PHP_METHOD(Stub_IssetTest, testIssetArray4) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -106,6 +141,14 @@ PHP_METHOD(Stub_IssetTest, testIssetArray5) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -121,6 +164,14 @@ PHP_METHOD(Stub_IssetTest, testIssetProperty1) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -137,6 +188,15 @@ PHP_METHOD(Stub_IssetTest, testIssetProperty2) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); @@ -152,6 +212,14 @@ PHP_METHOD(Stub_IssetTest, testIssetProperty3) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -169,6 +237,7 @@ PHP_METHOD(Stub_IssetTest, testIssetDynamicProperty1) { ZVAL_UNDEF(&g); + ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(&g); @@ -188,6 +257,14 @@ PHP_METHOD(Stub_IssetTest, testIssetDynamicProperty2) { ZVAL_UNDEF(&inp_sub); ZVAL_UNDEF(&g); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(inp) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &inp); @@ -210,6 +287,7 @@ zend_object *zephir_init_properties_Stub_IssetTest(zend_class_entry *class_type) zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1$$3); + ZEPHIR_MM_GROW(); diff --git a/ext/stub/issettest.zep.h b/ext/stub/issettest.zep.h index 94b2c3598c..dc9eca31d3 100644 --- a/ext/stub/issettest.zep.h +++ b/ext/stub/issettest.zep.h @@ -22,20 +22,12 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_issettest_testissetarray2, 0, 0, 2) ZEND_ARG_INFO(0, a) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_issettest_testissetarray3, 0, 0, 2) ZEND_ARG_INFO(0, a) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_issettest_testissetarray4, 0, 0, 1) @@ -78,7 +70,11 @@ ZEPHIR_INIT_FUNCS(stub_issettest_method_entry) { PHP_ME(Stub_IssetTest, testIssetProperty1, arginfo_stub_issettest_testissetproperty1, ZEND_ACC_PUBLIC) PHP_ME(Stub_IssetTest, testIssetProperty2, arginfo_stub_issettest_testissetproperty2, ZEND_ACC_PUBLIC) PHP_ME(Stub_IssetTest, testIssetProperty3, arginfo_stub_issettest_testissetproperty3, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_IssetTest, testIssetDynamicProperty1, arginfo_stub_issettest_testissetdynamicproperty1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_IssetTest, testIssetDynamicProperty1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_IssetTest, testIssetDynamicProperty2, arginfo_stub_issettest_testissetdynamicproperty2, ZEND_ACC_PUBLIC) PHP_FE_END }; diff --git a/ext/stub/issue1404.zep.c b/ext/stub/issue1404.zep.c index 782798a0cd..26c0d48c9f 100644 --- a/ext/stub/issue1404.zep.c +++ b/ext/stub/issue1404.zep.c @@ -28,6 +28,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsingInteger70000) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70000)); } @@ -37,6 +38,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsingDouble70100) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70100)); } @@ -46,6 +48,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsingLong70000) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(21474836470000)); } @@ -55,6 +58,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsingString70000) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70000)); } @@ -64,6 +68,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsingZero) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(0)); } @@ -73,6 +78,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing50000) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(50000)); } @@ -82,6 +88,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing50500) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(50500)); } @@ -91,6 +98,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing50600) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(50600)); } @@ -100,6 +108,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70101) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70101)); } @@ -109,6 +118,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70102) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70102)); } @@ -118,6 +128,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70103) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70103)); } @@ -127,6 +138,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70104) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70104)); } @@ -136,6 +148,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70105) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70105)); } @@ -145,6 +158,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70106) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70106)); } @@ -154,6 +168,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70107) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70107)); } @@ -163,6 +178,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70108) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70108)); } @@ -172,6 +188,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70109) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70109)); } @@ -181,6 +198,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70110) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70110)); } @@ -190,6 +208,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70111) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70111)); } @@ -199,6 +218,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70112) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70112)); } @@ -208,6 +228,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70113) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70113)); } @@ -217,6 +238,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70114) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70114)); } @@ -226,6 +248,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70115) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70115)); } @@ -235,6 +258,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70116) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70116)); } @@ -244,6 +268,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70117) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70117)); } @@ -253,6 +278,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70100) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70100)); } @@ -262,6 +288,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70200) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70200)); } @@ -271,6 +298,7 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70300) { zval *this_ptr = getThis(); + RETURN_BOOL(zephir_is_php_version(70300)); } diff --git a/ext/stub/issue1404.zep.h b/ext/stub/issue1404.zep.h index 30cc14d183..774717af88 100644 --- a/ext/stub/issue1404.zep.h +++ b/ext/stub/issue1404.zep.h @@ -32,200 +32,88 @@ PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70100); PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70200); PHP_METHOD(Stub_Issue1404, testIsPhpVersionUsing70300); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusinginteger70000, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusinginteger70000, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusingdouble70100, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusingdouble70100, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusinglong70000, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusinglong70000, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusingstring70000, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusingstring70000, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusingzero, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusingzero, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing50000, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing50000, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing50500, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing50500, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing50600, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing50600, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70101, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70101, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70102, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70102, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70103, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70103, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70104, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70104, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70105, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70105, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70106, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70106, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70107, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70107, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70108, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70108, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70109, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70109, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70110, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70110, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70111, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70111, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70112, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70112, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70113, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70113, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70114, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70114, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70115, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70115, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70116, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70116, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70117, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70117, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70100, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70100, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70200, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70200, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70300, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_issue1404_testisphpversionusing70300, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_issue1404_method_entry) { diff --git a/ext/stub/issue1521.zep.c b/ext/stub/issue1521.zep.c index ae8b179fa3..cd65d25f89 100644 --- a/ext/stub/issue1521.zep.c +++ b/ext/stub/issue1521.zep.c @@ -35,6 +35,7 @@ PHP_METHOD(Stub_Issue1521, test) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); diff --git a/ext/stub/issue1521.zep.h b/ext/stub/issue1521.zep.h index 18a6e4683d..518615b996 100644 --- a/ext/stub/issue1521.zep.h +++ b/ext/stub/issue1521.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_issue1521_test, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_issue1521_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Issue1521, test, arginfo_stub_issue1521_test, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Issue1521, test, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/issues.zep.c b/ext/stub/issues.zep.c index 74bbe6d1bb..a4197b8ece 100644 --- a/ext/stub/issues.zep.c +++ b/ext/stub/issues.zep.c @@ -33,6 +33,14 @@ PHP_METHOD(Stub_Issues, setAdapter) { zval *this_ptr = getThis(); ZVAL_UNDEF(&adapter_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(adapter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &adapter); @@ -51,6 +59,14 @@ PHP_METHOD(Stub_Issues, someMethod) { ZVAL_UNDEF(&methodName_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(methodName) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &methodName); @@ -69,6 +85,7 @@ PHP_METHOD(Stub_Issues, test) { zval *this_ptr = getThis(); + php_printf("%s", "test"); } diff --git a/ext/stub/issues.zep.h b/ext/stub/issues.zep.h index 8f73bb530c..d9cd5f2551 100644 --- a/ext/stub/issues.zep.h +++ b/ext/stub/issues.zep.h @@ -21,6 +21,10 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_issues_method_entry) { PHP_ME(Stub_Issues, setAdapter, arginfo_stub_issues_setadapter, ZEND_ACC_PUBLIC) PHP_ME(Stub_Issues, someMethod, arginfo_stub_issues_somemethod, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Issues, test, arginfo_stub_issues_test, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Issues, test, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/json.zep.c b/ext/stub/json.zep.c index 9fefdd191c..dabe3f31d6 100644 --- a/ext/stub/json.zep.c +++ b/ext/stub/json.zep.c @@ -35,6 +35,7 @@ PHP_METHOD(Stub_Json, testEncodeObject) { ZVAL_UNDEF(&obj); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&obj); @@ -56,6 +57,7 @@ PHP_METHOD(Stub_Json, testEncodeArray) { ZVAL_UNDEF(&arr); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&arr); @@ -84,6 +86,7 @@ PHP_METHOD(Stub_Json, testEncodeOptions) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&arr); @@ -114,6 +117,7 @@ PHP_METHOD(Stub_Json, testDecodeObject) { ZVAL_UNDEF(&obj); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&obj); @@ -132,6 +136,7 @@ PHP_METHOD(Stub_Json, testDecodeObject2) { ZVAL_BOOL(&__$true, 1); ZVAL_UNDEF(&obj); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&obj); @@ -149,6 +154,7 @@ PHP_METHOD(Stub_Json, testDecodeArray) { ZVAL_UNDEF(&arr); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&arr); diff --git a/ext/stub/json.zep.h b/ext/stub/json.zep.h index 541fe1ae06..1b30db4d7e 100644 --- a/ext/stub/json.zep.h +++ b/ext/stub/json.zep.h @@ -29,11 +29,35 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_json_testdecodearray, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_json_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Json, testEncodeObject, arginfo_stub_json_testencodeobject, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Json, testEncodeObject, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Json, testEncodeArray, arginfo_stub_json_testencodearray, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Json, testEncodeArray, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Json, testEncodeOptions, arginfo_stub_json_testencodeoptions, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Json, testEncodeOptions, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Json, testDecodeObject, arginfo_stub_json_testdecodeobject, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Json, testDecodeObject, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Json, testDecodeObject2, arginfo_stub_json_testdecodeobject2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Json, testDecodeObject2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Json, testDecodeArray, arginfo_stub_json_testdecodearray, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Json, testDecodeArray, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/logical.zep.c b/ext/stub/logical.zep.c index 876993b0ea..a7d0f58681 100644 --- a/ext/stub/logical.zep.c +++ b/ext/stub/logical.zep.c @@ -37,6 +37,7 @@ PHP_METHOD(Stub_Logical, testAnd1) { + _0 = ((0) ? 1 : 0); if (_0) { _0 = ((0) ? 1 : 0); @@ -52,6 +53,7 @@ PHP_METHOD(Stub_Logical, testAnd2) { + _0 = ((0) ? 1 : 0); if (_0) { _0 = ((1.5 != 0.0) ? 1 : 0); @@ -67,6 +69,7 @@ PHP_METHOD(Stub_Logical, testAnd3) { + _0 = ((0) ? 1 : 0); if (_0) { _0 = ((1.5 != 0.0) ? 1 : 0); @@ -86,6 +89,7 @@ PHP_METHOD(Stub_Logical, testAnd4) { + _0 = ((1) ? 1 : 0); if (_0) { _0 = ((0) ? 1 : 0); @@ -107,6 +111,15 @@ PHP_METHOD(Stub_Logical, testAnd9) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&_1$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_LONG(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b_param); @@ -132,6 +145,7 @@ PHP_METHOD(Stub_Logical, testOr1) { + _0 = ((0) ? 1 : 0); if (!(_0)) { _0 = ((1) ? 1 : 0); @@ -147,6 +161,7 @@ PHP_METHOD(Stub_Logical, testOr2) { + _0 = ((0) ? 1 : 0); if (!(_0)) { _0 = 1; @@ -163,6 +178,7 @@ PHP_METHOD(Stub_Logical, testMixed1) { + first = 0; second = 1; _0 = ((first) ? 1 : 0); @@ -190,6 +206,15 @@ PHP_METHOD(Stub_Logical, testMixed2) { ZVAL_UNDEF(&match_sub); ZVAL_UNDEF(&minLength_sub); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(match) + Z_PARAM_ZVAL(minLength) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &match, &minLength); @@ -218,6 +243,7 @@ PHP_METHOD(Stub_Logical, testMixed3) { + _0 = ((0) ? 1 : 0); if (_0) { _0 = ((1) ? 1 : 0); @@ -246,6 +272,15 @@ PHP_METHOD(Stub_Logical, testMixed4) { zend_bool a, b, _0, _1, _2; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_BOOL(a) + Z_PARAM_BOOL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a_param, &b_param); diff --git a/ext/stub/logical.zep.h b/ext/stub/logical.zep.h index 4afd1e71c8..94b84df967 100644 --- a/ext/stub/logical.zep.h +++ b/ext/stub/logical.zep.h @@ -29,11 +29,7 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_logical_testand9, 0, 0, 2) ZEND_ARG_INFO(0, a) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_logical_testor1, 0, 0, 0) @@ -54,29 +50,53 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_logical_testmixed3, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_logical_testmixed4, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, a) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_logical_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Logical, testAnd1, arginfo_stub_logical_testand1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Logical, testAnd1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Logical, testAnd2, arginfo_stub_logical_testand2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Logical, testAnd2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Logical, testAnd3, arginfo_stub_logical_testand3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Logical, testAnd3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Logical, testAnd4, arginfo_stub_logical_testand4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Logical, testAnd4, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Logical, testAnd9, arginfo_stub_logical_testand9, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Logical, testOr1, arginfo_stub_logical_testor1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Logical, testOr1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Logical, testOr2, arginfo_stub_logical_testor2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Logical, testOr2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Logical, testMixed1, arginfo_stub_logical_testmixed1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Logical, testMixed1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Logical, testMixed2, arginfo_stub_logical_testmixed2, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Logical, testMixed3, arginfo_stub_logical_testmixed3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Logical, testMixed3, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Logical, testMixed4, arginfo_stub_logical_testmixed4, ZEND_ACC_PUBLIC) PHP_FE_END }; diff --git a/ext/stub/mcall.zep.c b/ext/stub/mcall.zep.c index 6a37406f11..1c9daa4419 100644 --- a/ext/stub/mcall.zep.c +++ b/ext/stub/mcall.zep.c @@ -37,6 +37,7 @@ PHP_METHOD(Stub_Mcall, testMethod1) { zval *this_ptr = getThis(); + RETURN_STRING("hello public"); } @@ -46,6 +47,7 @@ PHP_METHOD(Stub_Mcall, testMethod2) { zval *this_ptr = getThis(); + RETURN_STRING("hello protected"); } @@ -55,6 +57,7 @@ PHP_METHOD(Stub_Mcall, testMethod3) { zval *this_ptr = getThis(); + RETURN_STRING("hello private"); } @@ -66,6 +69,15 @@ PHP_METHOD(Stub_Mcall, testMethod4) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); @@ -83,6 +95,15 @@ PHP_METHOD(Stub_Mcall, testMethod5) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); @@ -100,6 +121,15 @@ PHP_METHOD(Stub_Mcall, testMethod6) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); @@ -115,6 +145,7 @@ PHP_METHOD(Stub_Mcall, testMethod7) { zval *this_ptr = getThis(); + object_init(return_value); return; @@ -127,6 +158,7 @@ PHP_METHOD(Stub_Mcall, testCall1) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod1", NULL, 0); @@ -142,6 +174,7 @@ PHP_METHOD(Stub_Mcall, testCall2) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod2", NULL, 0); @@ -157,9 +190,10 @@ PHP_METHOD(Stub_Mcall, testCall3) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod3", NULL, 44); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod3", NULL, 47); zephir_check_call_status(); RETURN_MM(); @@ -174,6 +208,15 @@ PHP_METHOD(Stub_Mcall, testCall4) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -195,6 +238,15 @@ PHP_METHOD(Stub_Mcall, testCall5) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -216,13 +268,22 @@ PHP_METHOD(Stub_Mcall, testCall6) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod6", NULL, 45, a, b); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod6", NULL, 48, a, b); zephir_check_call_status(); RETURN_MM(); @@ -240,6 +301,15 @@ PHP_METHOD(Stub_Mcall, testCall7) { ZVAL_UNDEF(&b_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -267,6 +337,15 @@ PHP_METHOD(Stub_Mcall, testCall8) { ZVAL_UNDEF(&b_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -293,13 +372,22 @@ PHP_METHOD(Stub_Mcall, testCall9) { ZVAL_UNDEF(&b_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "testmethod6", NULL, 45, a, b); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "testmethod6", NULL, 48, a, b); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, this_ptr, "testmethod5", NULL, 0, a, b); zephir_check_call_status(); @@ -315,6 +403,7 @@ PHP_METHOD(Stub_Mcall, testCall10) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod1", NULL, 0); @@ -330,6 +419,7 @@ PHP_METHOD(Stub_Mcall, testCall11) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod2", NULL, 0); @@ -345,9 +435,10 @@ PHP_METHOD(Stub_Mcall, testCall12) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod3", NULL, 44); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod3", NULL, 47); zephir_check_call_status(); RETURN_MM(); @@ -362,6 +453,15 @@ PHP_METHOD(Stub_Mcall, testCall13) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -383,6 +483,15 @@ PHP_METHOD(Stub_Mcall, testCall14) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -404,13 +513,22 @@ PHP_METHOD(Stub_Mcall, testCall15) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod6", NULL, 45, a, b); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod6", NULL, 48, a, b); zephir_check_call_status(); RETURN_MM(); @@ -425,6 +543,15 @@ PHP_METHOD(Stub_Mcall, testCall16) { ZVAL_UNDEF(&c_sub); ZVAL_UNDEF(&d_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(c) + Z_PARAM_ZVAL(d) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &c, &d); @@ -446,6 +573,15 @@ PHP_METHOD(Stub_Mcall, testCall17) { ZVAL_UNDEF(&c_sub); ZVAL_UNDEF(&d_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(c) + Z_PARAM_ZVAL(d) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &c, &d); @@ -465,9 +601,10 @@ PHP_METHOD(Stub_Mcall, testCall18) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod7", NULL, 46); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "testmethod7", NULL, 49); zephir_check_call_status(); RETURN_MM(); @@ -479,6 +616,15 @@ PHP_METHOD(Stub_Mcall, testMethod19) { long a, b; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a_param, &b_param); @@ -502,6 +648,15 @@ PHP_METHOD(Stub_Mcall, testCall20) { ZVAL_UNDEF(&p_sub); ZVAL_UNDEF(&_3$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(k) + Z_PARAM_ZVAL(p) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &k_param, &p); @@ -539,6 +694,15 @@ PHP_METHOD(Stub_Mcall, testMethod21) { long a, b; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a_param, &b_param); @@ -562,6 +726,15 @@ PHP_METHOD(Stub_Mcall, testCall22) { ZVAL_UNDEF(&p_sub); ZVAL_UNDEF(&_3$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(k) + Z_PARAM_ZVAL(p) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &k_param, &p); @@ -584,7 +757,7 @@ PHP_METHOD(Stub_Mcall, testCall22) { _0 = 1; } i = _1; - ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "testmethod21", &_4, 47, p, p); + ZEPHIR_CALL_METHOD(&_3$$3, this_ptr, "testmethod21", &_4, 50, p, p); zephir_check_call_status(); j += zephir_get_numberval(&_3$$3); } @@ -601,6 +774,14 @@ PHP_METHOD(Stub_Mcall, optionalRequereString) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, ¶m_param); @@ -629,6 +810,15 @@ PHP_METHOD(Stub_Mcall, optionalParameterString) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_STR(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, ¶m_param); @@ -653,6 +843,15 @@ PHP_METHOD(Stub_Mcall, optionalParameterStringNull) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_STR_OR_NULL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, ¶m_param); @@ -675,6 +874,15 @@ PHP_METHOD(Stub_Mcall, optionalParameterInt) { zend_long param; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_LONG(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, ¶m_param); @@ -696,6 +904,15 @@ PHP_METHOD(Stub_Mcall, optionalParameterVar) { ZVAL_UNDEF(¶m_sub); ZVAL_NULL(&__$null); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, ¶m); @@ -716,6 +933,15 @@ PHP_METHOD(Stub_Mcall, optionalParameterBoolTrue) { zend_bool param; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, ¶m_param); @@ -736,6 +962,15 @@ PHP_METHOD(Stub_Mcall, optionalParameterBoolFalse) { zend_bool param; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, ¶m_param); @@ -756,6 +991,15 @@ PHP_METHOD(Stub_Mcall, optionalParameterBoolean) { zend_bool start; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(start) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, &start_param); @@ -780,6 +1024,15 @@ PHP_METHOD(Stub_Mcall, optionalParameterBooleanNull) { zend_bool value; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL_OR_NULL(value, is_null_true) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, &value_param); @@ -809,6 +1062,15 @@ PHP_METHOD(Stub_Mcall, testArrayParamWithDefaultEmptyArray) { zval *this_ptr = getThis(); ZVAL_UNDEF(&driverOptions); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ARRAY(driverOptions) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &driverOptions_param); @@ -833,6 +1095,15 @@ PHP_METHOD(Stub_Mcall, testArrayParamWithDefaultNullValue) { zval *this_ptr = getThis(); ZVAL_UNDEF(&driverOptions); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ARRAY_OR_NULL(driverOptions) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &driverOptions_param); @@ -857,6 +1128,14 @@ PHP_METHOD(Stub_Mcall, testArrayParam) { zval *this_ptr = getThis(); ZVAL_UNDEF(&driverOptions); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(driverOptions) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &driverOptions_param); @@ -874,6 +1153,14 @@ PHP_METHOD(Stub_Mcall, testObjectParamCastStdClass) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(param, zend_standard_class_def) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, ¶m); @@ -890,6 +1177,14 @@ PHP_METHOD(Stub_Mcall, testObjectParamCastOoParam) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(param, stub_oo_param_ce) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, ¶m); @@ -905,6 +1200,7 @@ PHP_METHOD(Stub_Mcall, bb) { zval *this_ptr = getThis(); + RETURN_STRING("hello"); } @@ -919,6 +1215,7 @@ PHP_METHOD(Stub_Mcall, testCallablePass) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -930,7 +1227,7 @@ PHP_METHOD(Stub_Mcall, testCallablePass) { ZEPHIR_INIT_VAR(&_0); ZEPHIR_INIT_NVAR(&_0); zephir_create_closure_ex(&_0, NULL, stub_11__closure_ce, SL("__invoke")); - ZEPHIR_RETURN_CALL_METHOD(&a, "setcallable", NULL, 48, &_0); + ZEPHIR_RETURN_CALL_METHOD(&a, "setcallable", NULL, 51, &_0); zephir_check_call_status(); RETURN_MM(); @@ -948,6 +1245,7 @@ PHP_METHOD(Stub_Mcall, testCallableArrayThisMethodPass) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -962,7 +1260,7 @@ PHP_METHOD(Stub_Mcall, testCallableArrayThisMethodPass) { ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "bb"); zephir_array_fast_append(&_0, &_1); - ZEPHIR_RETURN_CALL_METHOD(&a, "setcallable", NULL, 48, &_0); + ZEPHIR_RETURN_CALL_METHOD(&a, "setcallable", NULL, 51, &_0); zephir_check_call_status(); RETURN_MM(); @@ -977,6 +1275,7 @@ PHP_METHOD(Stub_Mcall, aa) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -985,7 +1284,7 @@ PHP_METHOD(Stub_Mcall, aa) { ZEPHIR_CALL_METHOD(NULL, &a, "__construct", NULL, 0); zephir_check_call_status(); } - ZEPHIR_RETURN_CALL_METHOD(&a, "bb", NULL, 49); + ZEPHIR_RETURN_CALL_METHOD(&a, "bb", NULL, 52); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/stub/mcall.zep.h b/ext/stub/mcall.zep.h index f22eca9932..d37cc8abf5 100644 --- a/ext/stub/mcall.zep.h +++ b/ext/stub/mcall.zep.h @@ -75,11 +75,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_testmethod6, 0, 0, 2) ZEND_ARG_INFO(0, b) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_mcall_testmethod7, 0, 0, stdClass, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_mcall_testmethod7, 0, 0, IS_OBJECT, "stdClass", 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_testcall1, 0, 0, 0) @@ -159,79 +155,39 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_testcall18, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_testmethod19, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_testcall20, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, k, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, k) -#endif ZEND_ARG_INFO(0, p) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_testmethod21, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_testcall22, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, k, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, k) -#endif ZEND_ARG_INFO(0, p) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_optionalrequerestring, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, param, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, param) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_optionalparameterstring, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, param, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, param) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_optionalparameterstringnull, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, param, IS_STRING, 1) -#else - ZEND_ARG_INFO(0, param) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_optionalparameterint, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, param, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, param) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_optionalparametervar, 0, 0, 0) @@ -239,35 +195,19 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_optionalparametervar, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_optionalparameterbooltrue, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, param, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, param) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_optionalparameterboolfalse, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, param, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, param) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_optionalparameterboolean, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, start, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, start) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_optionalparameterbooleannull, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, value, _IS_BOOL, 1) -#else - ZEND_ARG_INFO(0, value) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_testarrayparamwithdefaultemptyarray, 0, 0, 0) @@ -303,31 +243,71 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_aa, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_mcall_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testMethod1, arginfo_stub_mcall_testmethod1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Mcall, testMethod1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testMethod2, arginfo_stub_mcall_testmethod2, ZEND_ACC_PROTECTED) +#else + PHP_ME(Stub_Mcall, testMethod2, NULL, ZEND_ACC_PROTECTED) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testMethod3, arginfo_stub_mcall_testmethod3, ZEND_ACC_PRIVATE) +#else + PHP_ME(Stub_Mcall, testMethod3, NULL, ZEND_ACC_PRIVATE) +#endif PHP_ME(Stub_Mcall, testMethod4, arginfo_stub_mcall_testmethod4, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testMethod5, arginfo_stub_mcall_testmethod5, ZEND_ACC_PROTECTED) PHP_ME(Stub_Mcall, testMethod6, arginfo_stub_mcall_testmethod6, ZEND_ACC_PRIVATE) PHP_ME(Stub_Mcall, testMethod7, arginfo_stub_mcall_testmethod7, ZEND_ACC_PRIVATE) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testCall1, arginfo_stub_mcall_testcall1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Mcall, testCall1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testCall2, arginfo_stub_mcall_testcall2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Mcall, testCall2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testCall3, arginfo_stub_mcall_testcall3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Mcall, testCall3, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Mcall, testCall4, arginfo_stub_mcall_testcall4, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testCall5, arginfo_stub_mcall_testcall5, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testCall6, arginfo_stub_mcall_testcall6, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testCall7, arginfo_stub_mcall_testcall7, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testCall8, arginfo_stub_mcall_testcall8, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testCall9, arginfo_stub_mcall_testcall9, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testCall10, arginfo_stub_mcall_testcall10, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Mcall, testCall10, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testCall11, arginfo_stub_mcall_testcall11, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Mcall, testCall11, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testCall12, arginfo_stub_mcall_testcall12, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Mcall, testCall12, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Mcall, testCall13, arginfo_stub_mcall_testcall13, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testCall14, arginfo_stub_mcall_testcall14, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testCall15, arginfo_stub_mcall_testcall15, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testCall16, arginfo_stub_mcall_testcall16, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testCall17, arginfo_stub_mcall_testcall17, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testCall18, arginfo_stub_mcall_testcall18, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Mcall, testCall18, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Mcall, testMethod19, arginfo_stub_mcall_testmethod19, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testCall20, arginfo_stub_mcall_testcall20, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testMethod21, arginfo_stub_mcall_testmethod21, ZEND_ACC_PRIVATE) @@ -346,9 +326,25 @@ ZEPHIR_INIT_FUNCS(stub_mcall_method_entry) { PHP_ME(Stub_Mcall, testArrayParam, arginfo_stub_mcall_testarrayparam, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testObjectParamCastStdClass, arginfo_stub_mcall_testobjectparamcaststdclass, ZEND_ACC_PUBLIC) PHP_ME(Stub_Mcall, testObjectParamCastOoParam, arginfo_stub_mcall_testobjectparamcastooparam, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, bb, arginfo_stub_mcall_bb, ZEND_ACC_PRIVATE) +#else + PHP_ME(Stub_Mcall, bb, NULL, ZEND_ACC_PRIVATE) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testCallablePass, arginfo_stub_mcall_testcallablepass, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Mcall, testCallablePass, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, testCallableArrayThisMethodPass, arginfo_stub_mcall_testcallablearraythismethodpass, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Mcall, testCallableArrayThisMethodPass, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Mcall, aa, arginfo_stub_mcall_aa, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Mcall, aa, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/mcall/caller.zep.c b/ext/stub/mcall/caller.zep.c index f7e6262244..100a8e322e 100644 --- a/ext/stub/mcall/caller.zep.c +++ b/ext/stub/mcall/caller.zep.c @@ -33,6 +33,14 @@ PHP_METHOD(Stub_Mcall_Caller, start) { zval *this_ptr = getThis(); ZVAL_UNDEF(&f_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(f) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &f); @@ -50,6 +58,7 @@ PHP_METHOD(Stub_Mcall_Caller, perform) { zval *this_ptr = getThis(); + RETURN_STRING("Caller:perform"); } diff --git a/ext/stub/mcall/caller.zep.h b/ext/stub/mcall/caller.zep.h index 3cb187c012..7f35a9e806 100644 --- a/ext/stub/mcall/caller.zep.h +++ b/ext/stub/mcall/caller.zep.h @@ -10,11 +10,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcall_caller_start, 0, 0, 1) ZEND_ARG_INFO(0, f) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_mcall_caller_perform, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_mcall_caller_perform, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_mcall_caller_method_entry) { diff --git a/ext/stub/mcallchained.zep.c b/ext/stub/mcallchained.zep.c index 1862682135..a8b00cffc1 100644 --- a/ext/stub/mcallchained.zep.c +++ b/ext/stub/mcallchained.zep.c @@ -35,6 +35,7 @@ PHP_METHOD(Stub_McallChained, testMethod1) { zval *this_ptr = getThis(); + RETURN_THISW(); } @@ -44,6 +45,7 @@ PHP_METHOD(Stub_McallChained, testMethod2) { zval *this_ptr = getThis(); + RETURN_THISW(); } @@ -53,6 +55,7 @@ PHP_METHOD(Stub_McallChained, testMethod3) { zval *this_ptr = getThis(); + RETURN_THISW(); } @@ -66,6 +69,7 @@ PHP_METHOD(Stub_McallChained, testChained1) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "testmethod1", NULL, 0); @@ -86,6 +90,7 @@ PHP_METHOD(Stub_McallChained, testChained2) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "testmethod1", NULL, 0); @@ -108,9 +113,10 @@ PHP_METHOD(Stub_McallChained, testChained3) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); - ZEPHIR_CALL_METHOD(&_0, this_ptr, "testmethod3", NULL, 50); + ZEPHIR_CALL_METHOD(&_0, this_ptr, "testmethod3", NULL, 53); zephir_check_call_status(); ZEPHIR_CALL_METHOD(&_1, &_0, "testmethod2", NULL, 0); zephir_check_call_status(); @@ -130,6 +136,7 @@ PHP_METHOD(Stub_McallChained, testChained4) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); zephir_update_property_zval(this_ptr, ZEND_STRL("temp"), this_ptr); diff --git a/ext/stub/mcallchained.zep.h b/ext/stub/mcallchained.zep.h index c9fde99771..f090ac8d60 100644 --- a/ext/stub/mcallchained.zep.h +++ b/ext/stub/mcallchained.zep.h @@ -33,12 +33,40 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcallchained_testchained4, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_mcallchained_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallChained, testMethod1, arginfo_stub_mcallchained_testmethod1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallChained, testMethod1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallChained, testMethod2, arginfo_stub_mcallchained_testmethod2, ZEND_ACC_PROTECTED) +#else + PHP_ME(Stub_McallChained, testMethod2, NULL, ZEND_ACC_PROTECTED) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallChained, testMethod3, arginfo_stub_mcallchained_testmethod3, ZEND_ACC_PRIVATE) +#else + PHP_ME(Stub_McallChained, testMethod3, NULL, ZEND_ACC_PRIVATE) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallChained, testChained1, arginfo_stub_mcallchained_testchained1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallChained, testChained1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallChained, testChained2, arginfo_stub_mcallchained_testchained2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallChained, testChained2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallChained, testChained3, arginfo_stub_mcallchained_testchained3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallChained, testChained3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallChained, testChained4, arginfo_stub_mcallchained_testchained4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallChained, testChained4, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/mcalldynamic.zep.c b/ext/stub/mcalldynamic.zep.c index 901b9dbcf0..2185e0acfb 100644 --- a/ext/stub/mcalldynamic.zep.c +++ b/ext/stub/mcalldynamic.zep.c @@ -35,6 +35,7 @@ PHP_METHOD(Stub_McallDynamic, testMethod1) { zval *this_ptr = getThis(); + RETURN_LONG(1); } @@ -49,6 +50,7 @@ PHP_METHOD(Stub_McallDynamic, testMagicCall1) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_CALL_METHOD(&_0, this_ptr, "method1", NULL, 0); @@ -70,6 +72,15 @@ PHP_METHOD(Stub_McallDynamic, __call) { ZVAL_UNDEF(&method_sub); ZVAL_UNDEF(&arguments_sub); ZVAL_UNDEF(&realMethod); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(method) + Z_PARAM_ZVAL(arguments) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &method, &arguments); @@ -98,6 +109,7 @@ PHP_METHOD(Stub_McallDynamic, testCallAnonymousFunctionWithContext) { ZVAL_UNDEF(&result); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_1); diff --git a/ext/stub/mcalldynamic.zep.h b/ext/stub/mcalldynamic.zep.h index b875bfacb3..b0eecbaa09 100644 --- a/ext/stub/mcalldynamic.zep.h +++ b/ext/stub/mcalldynamic.zep.h @@ -23,9 +23,21 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcalldynamic_testcallanonymousfunctionwithco ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_mcalldynamic_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallDynamic, testMethod1, arginfo_stub_mcalldynamic_testmethod1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallDynamic, testMethod1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallDynamic, testMagicCall1, arginfo_stub_mcalldynamic_testmagiccall1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallDynamic, testMagicCall1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_McallDynamic, __call, arginfo_stub_mcalldynamic___call, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallDynamic, testCallAnonymousFunctionWithContext, arginfo_stub_mcalldynamic_testcallanonymousfunctionwithcontext, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallDynamic, testCallAnonymousFunctionWithContext, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/mcallinternal.zep.c b/ext/stub/mcallinternal.zep.c index 1fde57fa09..1afaa96b6c 100644 --- a/ext/stub/mcallinternal.zep.c +++ b/ext/stub/mcallinternal.zep.c @@ -36,6 +36,7 @@ void zep_Stub_McallInternal_a(int ht, zend_execute_data *execute_data, zval *ret zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -49,6 +50,15 @@ void zep_Stub_McallInternal_b(int ht, zend_execute_data *execute_data, zval *ret zval *a, a_sub, *b, b_sub; ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + a = a_ext; @@ -64,6 +74,15 @@ void zep_Stub_McallInternal_c(int ht, zend_execute_data *execute_data, zval *ret zval *a_param = NULL, *b_param = NULL; long a, b; +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + a_param = a_param_ext; @@ -86,6 +105,7 @@ PHP_METHOD(Stub_McallInternal, e) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -104,6 +124,7 @@ PHP_METHOD(Stub_McallInternal, d) { ZVAL_UNDEF(&_3$$3); + ZEPHIR_MM_GROW(); a = 0; @@ -141,6 +162,7 @@ PHP_METHOD(Stub_McallInternal, f) { ZVAL_UNDEF(&_3$$3); + ZEPHIR_MM_GROW(); a = 0; @@ -180,6 +202,7 @@ PHP_METHOD(Stub_McallInternal, g) { ZVAL_UNDEF(&_4$$3); ZVAL_UNDEF(&_5$$3); + ZEPHIR_MM_GROW(); a = 0; @@ -212,6 +235,15 @@ void zep_Stub_McallInternal_other(int ht, zend_execute_data *execute_data, zval zval *a_param = NULL, *b_param = NULL; long a, b; +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + a_param = a_param_ext; @@ -240,6 +272,7 @@ PHP_METHOD(Stub_McallInternal, callFibonacci) { ZVAL_UNDEF(&_4$$3); ZVAL_UNDEF(&_5$$3); + ZEPHIR_MM_GROW(); p = (double) (0); @@ -273,6 +306,7 @@ void zep_Stub_McallInternal_test1956(int ht, zend_execute_data *execute_data, zv + RETURN_THISW(); } @@ -284,6 +318,7 @@ PHP_METHOD(Stub_McallInternal, issue1956) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_INTERNAL_METHOD_P0(this_ptr, zep_Stub_McallInternal_test1956); diff --git a/ext/stub/mcallinternal.zep.h b/ext/stub/mcallinternal.zep.h index c833f77b1b..55d3ad272b 100644 --- a/ext/stub/mcallinternal.zep.h +++ b/ext/stub/mcallinternal.zep.h @@ -24,16 +24,8 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcallinternal_b, 0, 0, 2) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcallinternal_c, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcallinternal_e, 0, 0, 0) @@ -48,49 +40,41 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_mcallinternal_g, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_mcallinternal_other, 0, 2, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_mcallinternal_other, 0, 2, IS_DOUBLE, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_mcallinternal_callfibonacci, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_mcallinternal_callfibonacci, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_mcallinternal_test1956, 0, 0, Stub\\McallInternal, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_mcallinternal_test1956, 0, 0, IS_OBJECT, "Stub\\McallInternal", 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_mcallinternal_issue1956, 0, 0, Stub\\McallInternal, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_mcallinternal_issue1956, 0, 0, IS_OBJECT, "Stub\\McallInternal", 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_mcallinternal_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallInternal, e, arginfo_stub_mcallinternal_e, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallInternal, e, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallInternal, d, arginfo_stub_mcallinternal_d, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallInternal, d, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallInternal, f, arginfo_stub_mcallinternal_f, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallInternal, f, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_McallInternal, g, arginfo_stub_mcallinternal_g, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_McallInternal, g, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_McallInternal, callFibonacci, arginfo_stub_mcallinternal_callfibonacci, ZEND_ACC_PUBLIC) PHP_ME(Stub_McallInternal, issue1956, arginfo_stub_mcallinternal_issue1956, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/methodabstract.zep.c b/ext/stub/methodabstract.zep.c index f429a300c8..8309c67513 100644 --- a/ext/stub/methodabstract.zep.c +++ b/ext/stub/methodabstract.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(Stub_MethodAbstract, testInterfaceMetho) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_CALL_METHOD(NULL, this_ptr, "testmethod", NULL, 0); diff --git a/ext/stub/methodabstract.zep.h b/ext/stub/methodabstract.zep.h index efccdb90fa..7ce2010185 100644 --- a/ext/stub/methodabstract.zep.h +++ b/ext/stub/methodabstract.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_methodabstract_testinterfacemetho, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_methodabstract_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_MethodAbstract, testInterfaceMetho, arginfo_stub_methodabstract_testinterfacemetho, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_MethodAbstract, testInterfaceMetho, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/methodargs.zep.c b/ext/stub/methodargs.zep.c index 781b449fd6..c4cf1f1663 100644 --- a/ext/stub/methodargs.zep.c +++ b/ext/stub/methodargs.zep.c @@ -43,6 +43,14 @@ PHP_METHOD(Stub_MethodArgs, setCallable) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -58,6 +66,14 @@ PHP_METHOD(Stub_MethodArgs, setObject) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -73,6 +89,14 @@ PHP_METHOD(Stub_MethodArgs, setCallableStrict) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -92,6 +116,14 @@ PHP_METHOD(Stub_MethodArgs, setObjectStrict) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -111,6 +143,14 @@ PHP_METHOD(Stub_MethodArgs, setResourceStrict) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_RESOURCE(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); @@ -134,6 +174,15 @@ PHP_METHOD(Stub_MethodArgs, methodOptionalValueWithDefaultStaticConstantAccess) zval *this_ptr = getThis(); ZVAL_UNDEF(&method_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(method) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &method); @@ -162,6 +211,15 @@ PHP_METHOD(Stub_MethodArgs, methodOptionalStringValueWithDefaultStaticConstantAc zval *this_ptr = getThis(); ZVAL_UNDEF(¶meter); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_STR(parameter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, ¶meter_param); @@ -188,6 +246,15 @@ PHP_METHOD(Stub_MethodArgs, methodOptionalDoubleValueWithDefaultStaticConstantAc double parameter; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(parameter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, ¶meter_param); @@ -212,6 +279,15 @@ PHP_METHOD(Stub_MethodArgs, methodOptionalBoolValueWithDefaultStaticConstantAcce zend_bool parameter; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(parameter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, ¶meter_param); @@ -236,6 +312,15 @@ PHP_METHOD(Stub_MethodArgs, methodOptionalIntValueWithDefaultStaticConstantAcces zend_long parameter; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_LONG(parameter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, ¶meter_param); diff --git a/ext/stub/methodargs.zep.h b/ext/stub/methodargs.zep.h index d8e5fb7ee9..1332e95993 100644 --- a/ext/stub/methodargs.zep.h +++ b/ext/stub/methodargs.zep.h @@ -39,35 +39,19 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_methodargs_methodoptionalvaluewithdefaultsta ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_methodargs_methodoptionalstringvaluewithdefaultstaticconstantaccess, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, parameter, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, parameter) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_methodargs_methodoptionaldoublevaluewithdefaultstaticconstantaccess, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, parameter, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, parameter) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_methodargs_methodoptionalboolvaluewithdefaultstaticconstantaccess, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, parameter, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, parameter) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_methodargs_methodoptionalintvaluewithdefaultstaticconstantaccess, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, parameter, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, parameter) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_methodargs_method_entry) { diff --git a/ext/stub/methodinterface.zep.c b/ext/stub/methodinterface.zep.c index 2ff6ef57d7..15726502fd 100644 --- a/ext/stub/methodinterface.zep.c +++ b/ext/stub/methodinterface.zep.c @@ -21,4 +21,3 @@ ZEPHIR_INIT_CLASS(Stub_MethodInterface) { } ZEPHIR_DOC_METHOD(Stub_MethodInterface, testMethod); - diff --git a/ext/stub/nativearray.zep.c b/ext/stub/nativearray.zep.c index 83522aa0c3..cb4f165ce8 100644 --- a/ext/stub/nativearray.zep.c +++ b/ext/stub/nativearray.zep.c @@ -39,6 +39,7 @@ PHP_METHOD(Stub_NativeArray, testArray1) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -56,6 +57,7 @@ PHP_METHOD(Stub_NativeArray, testArray2) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -82,6 +84,7 @@ PHP_METHOD(Stub_NativeArray, testArray3) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -109,6 +112,7 @@ PHP_METHOD(Stub_NativeArray, testArray4) { ZVAL_BOOL(&__$true, 1); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -129,6 +133,7 @@ PHP_METHOD(Stub_NativeArray, testArray5) { ZVAL_NULL(&__$null); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -149,6 +154,7 @@ PHP_METHOD(Stub_NativeArray, testArray6) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -176,6 +182,7 @@ PHP_METHOD(Stub_NativeArray, testArray7) { ZVAL_UNDEF(&d); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); a = 1; @@ -206,6 +213,7 @@ PHP_METHOD(Stub_NativeArray, testArray8) { ZVAL_UNDEF(&d); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); a = (double) (1); @@ -236,6 +244,7 @@ PHP_METHOD(Stub_NativeArray, testArray9) { ZVAL_UNDEF(&d); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); a = 1; @@ -268,6 +277,7 @@ PHP_METHOD(Stub_NativeArray, testArray10) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&c); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -296,6 +306,7 @@ PHP_METHOD(Stub_NativeArray, testArray11) { ZVAL_UNDEF(&c); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -339,6 +350,7 @@ PHP_METHOD(Stub_NativeArray, testArray12) { ZVAL_UNDEF(&c); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -370,6 +382,7 @@ PHP_METHOD(Stub_NativeArray, testArray13) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -389,6 +402,7 @@ PHP_METHOD(Stub_NativeArray, testArray14) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -410,6 +424,7 @@ PHP_METHOD(Stub_NativeArray, testArray15) { ZVAL_BOOL(&__$false, 0); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -429,6 +444,7 @@ PHP_METHOD(Stub_NativeArray, testArray16) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -449,6 +465,7 @@ PHP_METHOD(Stub_NativeArray, testArray17) { ZVAL_NULL(&__$null); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -468,6 +485,7 @@ PHP_METHOD(Stub_NativeArray, testArray18) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -489,6 +507,7 @@ PHP_METHOD(Stub_NativeArray, testArray19) { ZVAL_BOOL(&__$false, 0); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -508,6 +527,7 @@ PHP_METHOD(Stub_NativeArray, testArray20) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -528,6 +548,7 @@ PHP_METHOD(Stub_NativeArray, testArray21) { ZVAL_NULL(&__$null); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -547,6 +568,7 @@ PHP_METHOD(Stub_NativeArray, testArray22) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -568,6 +590,7 @@ PHP_METHOD(Stub_NativeArray, testArray23) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); b = 0; @@ -596,6 +619,7 @@ PHP_METHOD(Stub_NativeArray, testArray24) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); b = 0.0; @@ -624,6 +648,7 @@ PHP_METHOD(Stub_NativeArray, testArray25) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); b = 0; @@ -651,6 +676,7 @@ PHP_METHOD(Stub_NativeArray, testArray26) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -674,6 +700,7 @@ PHP_METHOD(Stub_NativeArray, testArray27) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -697,6 +724,7 @@ PHP_METHOD(Stub_NativeArray, testArray28) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -719,6 +747,7 @@ PHP_METHOD(Stub_NativeArray, testArray29) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); b = 1; @@ -739,6 +768,7 @@ PHP_METHOD(Stub_NativeArray, testArray30) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -760,6 +790,7 @@ PHP_METHOD(Stub_NativeArray, testArrayAccess1) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -787,6 +818,7 @@ PHP_METHOD(Stub_NativeArray, testArrayAccess2) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -810,6 +842,7 @@ PHP_METHOD(Stub_NativeArray, testArrayAccess3) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -840,6 +873,7 @@ PHP_METHOD(Stub_NativeArray, testArrayAccess4) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&c); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -864,6 +898,7 @@ PHP_METHOD(Stub_NativeArray, testArrayAccess5) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&c); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -889,6 +924,7 @@ PHP_METHOD(Stub_NativeArray, testArrayAccess6) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -916,6 +952,7 @@ PHP_METHOD(Stub_NativeArray, testArrayMultipleAccess1) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -944,6 +981,7 @@ PHP_METHOD(Stub_NativeArray, testArrayMultipleAccess2) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -978,6 +1016,7 @@ PHP_METHOD(Stub_NativeArray, testArrayMultipleAccess3) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1016,6 +1055,7 @@ PHP_METHOD(Stub_NativeArray, testArrayMultipleAccess4) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1053,6 +1093,7 @@ PHP_METHOD(Stub_NativeArray, testArrayMultipleAccess5) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1081,6 +1122,7 @@ PHP_METHOD(Stub_NativeArray, testArrayUpdate1) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1111,6 +1153,7 @@ PHP_METHOD(Stub_NativeArray, testArrayUpdate2) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1143,6 +1186,7 @@ PHP_METHOD(Stub_NativeArray, testArrayUpdate3) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1177,6 +1221,7 @@ PHP_METHOD(Stub_NativeArray, testArrayUpdate4) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1204,6 +1249,7 @@ PHP_METHOD(Stub_NativeArray, testArrayUpdate5) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1269,6 +1315,7 @@ PHP_METHOD(Stub_NativeArray, testArrayAppend1) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1318,6 +1365,7 @@ PHP_METHOD(Stub_NativeArray, testArrayAppend2) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1365,6 +1413,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate1) { ZVAL_NULL(&__$null); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1383,6 +1432,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate2) { ZVAL_NULL(&__$null); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1401,6 +1451,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate3) { ZVAL_NULL(&__$null); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1419,6 +1470,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate4) { ZVAL_NULL(&__$null); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1437,6 +1489,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate5) { ZVAL_NULL(&__$null); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1455,6 +1508,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate6) { ZVAL_NULL(&__$null); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1474,6 +1528,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate7) { ZVAL_BOOL(&__$false, 0); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1495,6 +1550,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate8) { ZVAL_BOOL(&__$false, 0); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1517,6 +1573,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate9) { ZVAL_BOOL(&__$false, 0); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1539,6 +1596,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate10) { ZVAL_BOOL(&__$false, 0); ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1561,6 +1619,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate11) { ZVAL_UNDEF(&b); ZVAL_UNDEF(&c); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1586,6 +1645,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate12) { ZVAL_UNDEF(&c); ZVAL_UNDEF(&d); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&b); @@ -1616,6 +1676,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayUpdate13) { ZVAL_UNDEF(&d); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&d); @@ -1653,6 +1714,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayAppend1) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1676,6 +1738,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayAppend2) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&x); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1704,6 +1767,7 @@ PHP_METHOD(Stub_NativeArray, testMultipleArrayAppend3) { ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -1740,6 +1804,14 @@ PHP_METHOD(Stub_NativeArray, testArrayKeys) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, ¶m); @@ -1758,6 +1830,14 @@ PHP_METHOD(Stub_NativeArray, testImplodeArray) { ZVAL_UNDEF(¶m_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, ¶m); @@ -1783,6 +1863,7 @@ PHP_METHOD(Stub_NativeArray, issue110) { ZVAL_UNDEF(&byteUnits); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&byteUnits); @@ -1811,6 +1892,14 @@ PHP_METHOD(Stub_NativeArray, issue264) { zval *this_ptr = getThis(); ZVAL_UNDEF(&tokens); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(tokens) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &tokens_param); @@ -1831,6 +1920,14 @@ PHP_METHOD(Stub_NativeArray, issue743a) { ZVAL_UNDEF(¤t743a); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(current743a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, ¤t743a_param); @@ -1854,6 +1951,14 @@ PHP_METHOD(Stub_NativeArray, issue743b) { ZVAL_UNDEF(¤t); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(current) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, ¤t_param); @@ -1878,6 +1983,14 @@ PHP_METHOD(Stub_NativeArray, issue743c) { ZVAL_UNDEF(¤t); ZVAL_UNDEF(&key); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(current) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, ¤t_param); @@ -1912,6 +2025,7 @@ PHP_METHOD(Stub_NativeArray, issue709) { ZVAL_UNDEF(&_4$$3); ZVAL_UNDEF(&_5$$3); + ZEPHIR_MM_GROW(); works = 1; @@ -1938,7 +2052,7 @@ PHP_METHOD(Stub_NativeArray, issue709) { ZEPHIR_INIT_NVAR(&_3$$3); ZVAL_LONG(&_3$$3, 2); zephir_array_fast_append(&arr, &_3$$3); - ZEPHIR_CALL_FUNCTION(&_5$$3, "array_rand", &_6, 51, &arr); + ZEPHIR_CALL_FUNCTION(&_5$$3, "array_rand", &_6, 54, &arr); zephir_check_call_status(); zephir_array_fetch(&_4$$3, &arr, &_5$$3, PH_NOISY | PH_READONLY, "stub/nativearray.zep", 626); ZEPHIR_CPY_WRT(&arr, &_4$$3); @@ -1969,6 +2083,15 @@ PHP_METHOD(Stub_NativeArray, Issue1140) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_1$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(prefix) + Z_PARAM_STR(baseDir) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &prefix_param, &baseDir_param); @@ -1986,7 +2109,7 @@ PHP_METHOD(Stub_NativeArray, Issue1140) { zephir_read_property(&_2, this_ptr, ZEND_STRL("prefixes"), PH_NOISY_CC | PH_READONLY); zephir_array_fetch(&_3, &_2, &prefix, PH_NOISY | PH_READONLY, "stub/nativearray.zep", 639); ZEPHIR_MAKE_REF(&_3); - ZEPHIR_CALL_FUNCTION(NULL, "array_push", NULL, 52, &_3, &baseDir); + ZEPHIR_CALL_FUNCTION(NULL, "array_push", NULL, 55, &_3, &baseDir); ZEPHIR_UNREF(&_3); zephir_check_call_status(); RETURN_MM_MEMBER(getThis(), "prefixes"); @@ -2002,6 +2125,7 @@ PHP_METHOD(Stub_NativeArray, Issue1159) { ZVAL_UNDEF(&myvar); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&myvar); @@ -2020,6 +2144,7 @@ zend_object *zephir_init_properties_Stub_NativeArray(zend_class_entry *class_typ zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1$$3); + ZEPHIR_MM_GROW(); diff --git a/ext/stub/nativearray.zep.h b/ext/stub/nativearray.zep.h index 5805a90e61..adea753285 100644 --- a/ext/stub/nativearray.zep.h +++ b/ext/stub/nativearray.zep.h @@ -79,527 +79,231 @@ PHP_METHOD(Stub_NativeArray, Issue1140); PHP_METHOD(Stub_NativeArray, Issue1159); zend_object *zephir_init_properties_Stub_NativeArray(zend_class_entry *class_type); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray1, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray1, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray2, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray2, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray3, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray3, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray4, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray4, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray5, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray5, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray6, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray6, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray7, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray7, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray8, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray8, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray9, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray9, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray10, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray10, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray11, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray11, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray12, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray12, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray13, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray13, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray14, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray14, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray15, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray15, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray16, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray16, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray17, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray17, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray18, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray18, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray19, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray19, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray20, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray20, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray21, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray21, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray22, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray22, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray23, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray23, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray24, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray24, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray25, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray25, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray26, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray26, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray27, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray27, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray28, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray28, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray29, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray29, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray30, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarray30, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess1, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess1, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess2, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess2, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess3, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess3, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess4, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess4, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess5, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess5, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess6, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayaccess6, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraymultipleaccess1, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraymultipleaccess1, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraymultipleaccess2, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraymultipleaccess2, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraymultipleaccess3, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraymultipleaccess3, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraymultipleaccess4, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraymultipleaccess4, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraymultipleaccess5, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraymultipleaccess5, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayupdate1, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayupdate1, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayupdate2, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayupdate2, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayupdate3, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayupdate3, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayupdate4, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayupdate4, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayupdate5, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayupdate5, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayappend1, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayappend1, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayappend2, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarrayappend2, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate1, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate1, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate2, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate2, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate3, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate3, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate4, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate4, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate5, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate5, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate6, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate6, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate7, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate7, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate8, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate8, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate9, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate9, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate10, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate10, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate11, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate11, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate12, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate12, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate13, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayupdate13, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayappend1, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayappend1, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayappend2, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayappend2, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayappend3, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testmultiplearrayappend3, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraykeys, 0, 1, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testarraykeys, 0, 1, IS_ARRAY, NULL, 0) -#endif ZEND_ARG_INFO(0, param) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testimplodearray, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_testimplodearray, 0, 1, IS_STRING, NULL, 0) -#endif ZEND_ARG_INFO(0, param) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue110, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue110, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue264, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue264, 0, 1, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_ARRAY_INFO(0, tokens, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue743a, 0, 1, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue743a, 0, 1, IS_ARRAY, NULL, 0) -#endif ZEND_ARG_ARRAY_INFO(0, current743a, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue743b, 0, 1, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue743b, 0, 1, IS_ARRAY, NULL, 0) -#endif ZEND_ARG_ARRAY_INFO(0, current, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue743c, 0, 1, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue743c, 0, 1, IS_ARRAY, NULL, 0) -#endif ZEND_ARG_ARRAY_INFO(0, current, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue709, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_nativearray_issue709, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_nativearray_issue1140, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, prefix, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, prefix) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, baseDir, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, baseDir) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_nativearray_issue1159, 0, 0, 0) @@ -682,6 +386,10 @@ ZEPHIR_INIT_FUNCS(stub_nativearray_method_entry) { PHP_ME(Stub_NativeArray, issue743c, arginfo_stub_nativearray_issue743c, ZEND_ACC_PUBLIC) PHP_ME(Stub_NativeArray, issue709, arginfo_stub_nativearray_issue709, ZEND_ACC_PUBLIC) PHP_ME(Stub_NativeArray, Issue1140, arginfo_stub_nativearray_issue1140, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_NativeArray, Issue1159, arginfo_stub_nativearray_issue1159, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_NativeArray, Issue1159, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/oo.zep.c b/ext/stub/oo.zep.c index 5026ed2f61..4e04e2cfdd 100644 --- a/ext/stub/oo.zep.c +++ b/ext/stub/oo.zep.c @@ -38,6 +38,7 @@ PHP_METHOD(Stub_Oo, testInstance1) { ZVAL_UNDEF(&o); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&o); @@ -55,11 +56,12 @@ PHP_METHOD(Stub_Oo, testInstance2) { ZVAL_UNDEF(&o); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&o); object_init_ex(&o, stub_oo_ooconstruct_ce); - ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 53); + ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 56); zephir_check_call_status(); RETURN_CCTOR(&o); @@ -74,6 +76,7 @@ PHP_METHOD(Stub_Oo, testInstance3) { ZVAL_UNDEF(&o); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&o); @@ -97,6 +100,7 @@ PHP_METHOD(Stub_Oo, testInstance4) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&b); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -105,7 +109,7 @@ PHP_METHOD(Stub_Oo, testInstance4) { ZVAL_STRING(&b, "b"); ZEPHIR_INIT_VAR(&o); object_init_ex(&o, stub_oo_ooconstructparams_ce); - ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 54, &a, &b); + ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 57, &a, &b); zephir_check_call_status(); RETURN_CCTOR(&o); @@ -122,6 +126,7 @@ PHP_METHOD(Stub_Oo, testInstance5) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&o); @@ -130,7 +135,7 @@ PHP_METHOD(Stub_Oo, testInstance5) { ZVAL_STRING(&_0, "a"); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "b"); - ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 54, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 57, &_0, &_1); zephir_check_call_status(); RETURN_CCTOR(&o); @@ -147,13 +152,14 @@ PHP_METHOD(Stub_Oo, testInstance6) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&o); object_init_ex(&o, stub_oo_ooconstructparams_ce); ZVAL_LONG(&_0, 1); ZVAL_LONG(&_1, 2); - ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 54, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 57, &_0, &_1); zephir_check_call_status(); RETURN_CCTOR(&o); @@ -170,13 +176,14 @@ PHP_METHOD(Stub_Oo, testInstance7) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&o); object_init_ex(&o, stub_oo_ooconstructparams_ce); ZVAL_BOOL(&_0, 0); ZVAL_BOOL(&_1, 1); - ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 54, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 57, &_0, &_1); zephir_check_call_status(); RETURN_CCTOR(&o); @@ -193,13 +200,14 @@ PHP_METHOD(Stub_Oo, testInstance8) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&o); object_init_ex(&o, stub_oo_ooconstructparams_ce); ZVAL_DOUBLE(&_0, 1.2); ZVAL_DOUBLE(&_1, 7.30); - ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 54, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 57, &_0, &_1); zephir_check_call_status(); RETURN_CCTOR(&o); @@ -215,6 +223,7 @@ PHP_METHOD(Stub_Oo, testInstance9) { ZVAL_UNDEF(&o); + ZEPHIR_MM_GROW(); ZEPHIR_CALL_CE_STATIC(&o, stub_oo_oodynamica_ce, "getnew", &_0, 0); @@ -233,6 +242,7 @@ PHP_METHOD(Stub_Oo, testInstance10) { ZVAL_UNDEF(&o); + ZEPHIR_MM_GROW(); ZEPHIR_CALL_CE_STATIC(&o, stub_oo_oodynamicb_ce, "getnew", &_0, 0); @@ -252,13 +262,14 @@ PHP_METHOD(Stub_Oo, testInstance11) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&o); object_init_ex(&o, stub_oo_ooconstructparams_ce); ZVAL_LONG(&_0, 1); ZVAL_LONG(&_1, 2); - ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 54, &_0, &_1); + ZEPHIR_CALL_METHOD(NULL, &o, "__construct", NULL, 57, &_0, &_1); zephir_check_call_status(); RETURN_CCTOR(&o); @@ -274,6 +285,7 @@ PHP_METHOD(Stub_Oo, testInstance12) { ZVAL_UNDEF(&o); + ZEPHIR_MM_GROW(); ZEPHIR_CALL_CE_STATIC(&o, stub_oo_oodynamica_ce, "call1", &_0, 0); @@ -305,6 +317,7 @@ PHP_METHOD(Stub_Oo, createInstancesInLoop) { ZVAL_UNDEF(&result); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&result); diff --git a/ext/stub/oo.zep.h b/ext/stub/oo.zep.h index 2ed5c67387..33a50a44b2 100644 --- a/ext/stub/oo.zep.h +++ b/ext/stub/oo.zep.h @@ -53,26 +53,70 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_testinstance12, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_createinstancesinloop, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_createinstancesinloop, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance1, arginfo_stub_oo_testinstance1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance2, arginfo_stub_oo_testinstance2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance3, arginfo_stub_oo_testinstance3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance4, arginfo_stub_oo_testinstance4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance5, arginfo_stub_oo_testinstance5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance6, arginfo_stub_oo_testinstance6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance6, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance7, arginfo_stub_oo_testinstance7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance7, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance8, arginfo_stub_oo_testinstance8, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance8, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance9, arginfo_stub_oo_testinstance9, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance9, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance10, arginfo_stub_oo_testinstance10, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance10, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance11, arginfo_stub_oo_testinstance11, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance11, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo, testInstance12, arginfo_stub_oo_testinstance12, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo, testInstance12, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Oo, createInstancesInLoop, arginfo_stub_oo_createinstancesinloop, ZEND_ACC_PUBLIC) PHP_FE_END }; diff --git a/ext/stub/oo/abstractclass.zep.h b/ext/stub/oo/abstractclass.zep.h index 3087adfb9b..137e96b858 100644 --- a/ext/stub/oo/abstractclass.zep.h +++ b/ext/stub/oo/abstractclass.zep.h @@ -15,53 +15,45 @@ PHP_METHOD(Stub_Oo_AbstractClass, testAbstractMethodDeclarationWithParameterAndR ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_abstractclass_testmethoddeclaration, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_abstractclass_testmethoddeclarationwithreturntype, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_abstractclass_testmethoddeclarationwithreturntype, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_abstractclass_testmethoddeclarationwithparameter, 0, 0, 1) ZEND_ARG_INFO(0, a) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_abstractclass_testmethoddeclarationwithparameterandreturntype, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_abstractclass_testmethoddeclarationwithparameterandreturntype, 0, 1, IS_STRING, NULL, 0) -#endif ZEND_ARG_INFO(0, a) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_abstractclass_testabstractmethoddeclaration, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_abstractclass_testabstractmethoddeclarationwithreturntype, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_abstractclass_testabstractmethoddeclarationwithreturntype, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_abstractclass_testabstractmethoddeclarationwithparameter, 0, 0, 1) ZEND_ARG_INFO(0, a) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_abstractclass_testabstractmethoddeclarationwithparameterandreturntype, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_abstractclass_testabstractmethoddeclarationwithparameterandreturntype, 0, 1, IS_STRING, NULL, 0) -#endif ZEND_ARG_INFO(0, a) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_abstractclass_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_AbstractClass, testMethodDeclaration, arginfo_stub_oo_abstractclass_testmethoddeclaration, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_AbstractClass, testMethodDeclaration, NULL, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Oo_AbstractClass, testMethodDeclarationWithReturnType, arginfo_stub_oo_abstractclass_testmethoddeclarationwithreturntype, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_AbstractClass, testMethodDeclarationWithParameter, arginfo_stub_oo_abstractclass_testmethoddeclarationwithparameter, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_AbstractClass, testMethodDeclarationWithParameterAndReturnType, arginfo_stub_oo_abstractclass_testmethoddeclarationwithparameterandreturntype, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_AbstractClass, testAbstractMethodDeclaration, arginfo_stub_oo_abstractclass_testabstractmethoddeclaration, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_AbstractClass, testAbstractMethodDeclaration, NULL, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Oo_AbstractClass, testAbstractMethodDeclarationWithReturnType, arginfo_stub_oo_abstractclass_testabstractmethoddeclarationwithreturntype, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_AbstractClass, testAbstractMethodDeclarationWithParameter, arginfo_stub_oo_abstractclass_testabstractmethoddeclarationwithparameter, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_AbstractClass, testAbstractMethodDeclarationWithParameterAndReturnType, arginfo_stub_oo_abstractclass_testabstractmethoddeclarationwithparameterandreturntype, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) diff --git a/ext/stub/oo/abstractstatic.zep.c b/ext/stub/oo/abstractstatic.zep.c index ab6516a34c..de0b1dcd49 100644 --- a/ext/stub/oo/abstractstatic.zep.c +++ b/ext/stub/oo/abstractstatic.zep.c @@ -28,6 +28,7 @@ PHP_METHOD(Stub_Oo_AbstractStatic, getCalledClass) { zval *this_ptr = getThis(); + zephir_get_called_class(return_value); return; diff --git a/ext/stub/oo/abstractstatic.zep.h b/ext/stub/oo/abstractstatic.zep.h index 30694fb78d..e7fa3e0c9b 100644 --- a/ext/stub/oo/abstractstatic.zep.h +++ b/ext/stub/oo/abstractstatic.zep.h @@ -5,11 +5,7 @@ ZEPHIR_INIT_CLASS(Stub_Oo_AbstractStatic); PHP_METHOD(Stub_Oo_AbstractStatic, getCalledClass); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_abstractstatic_getcalledclass, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_abstractstatic_getcalledclass, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_abstractstatic_method_entry) { diff --git a/ext/stub/oo/concretestatic.zep.c b/ext/stub/oo/concretestatic.zep.c index 45ad0247ec..d533904813 100644 --- a/ext/stub/oo/concretestatic.zep.c +++ b/ext/stub/oo/concretestatic.zep.c @@ -30,6 +30,7 @@ PHP_METHOD(Stub_Oo_ConcreteStatic, parentFunction) { zval *this_ptr = getThis(); + RETURN_STRING("ConcreteStatic:parentFunction"); } @@ -41,6 +42,7 @@ PHP_METHOD(Stub_Oo_ConcreteStatic, childFunction) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_SELF("parentfunction", NULL, 0); @@ -49,11 +51,29 @@ PHP_METHOD(Stub_Oo_ConcreteStatic, childFunction) { } +PHP_METHOD(Stub_Oo_ConcreteStatic, callParentFunction) { + + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zephir_fcall_cache_entry *_0 = NULL; + zval *this_ptr = getThis(); + + + + ZEPHIR_MM_GROW(); + + ZEPHIR_RETURN_CALL_PARENT(stub_oo_concretestatic_ce, getThis(), "getcalledclass", &_0, 0); + zephir_check_call_status(); + RETURN_MM(); + +} + PHP_METHOD(Stub_Oo_ConcreteStatic, simpleStaticIntReturn) { zval *this_ptr = getThis(); + RETURN_LONG(1337); } diff --git a/ext/stub/oo/concretestatic.zep.h b/ext/stub/oo/concretestatic.zep.h index f662ee234b..e2e2f17be8 100644 --- a/ext/stub/oo/concretestatic.zep.h +++ b/ext/stub/oo/concretestatic.zep.h @@ -5,6 +5,7 @@ ZEPHIR_INIT_CLASS(Stub_Oo_ConcreteStatic); PHP_METHOD(Stub_Oo_ConcreteStatic, parentFunction); PHP_METHOD(Stub_Oo_ConcreteStatic, childFunction); +PHP_METHOD(Stub_Oo_ConcreteStatic, callParentFunction); PHP_METHOD(Stub_Oo_ConcreteStatic, simpleStaticIntReturn); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_concretestatic_parentfunction, 0, 0, 0) @@ -13,16 +14,24 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_concretestatic_childfunction, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_concretestatic_callparentfunction, 0, 0, IS_STRING, 0) +ZEND_END_ARG_INFO() + ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_concretestatic_simplestaticintreturn, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_concretestatic_simplestaticintreturn, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_concretestatic_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_ConcreteStatic, parentFunction, arginfo_stub_oo_concretestatic_parentfunction, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Oo_ConcreteStatic, parentFunction, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_ConcreteStatic, childFunction, arginfo_stub_oo_concretestatic_childfunction, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Oo_ConcreteStatic, childFunction, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif + PHP_ME(Stub_Oo_ConcreteStatic, callParentFunction, arginfo_stub_oo_concretestatic_callparentfunction, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) PHP_ME(Stub_Oo_ConcreteStatic, simpleStaticIntReturn, arginfo_stub_oo_concretestatic_simplestaticintreturn, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) PHP_FE_END }; diff --git a/ext/stub/oo/constantsinterface.zep.c b/ext/stub/oo/constantsinterface.zep.c index 2251c0944a..70e2cc113a 100644 --- a/ext/stub/oo/constantsinterface.zep.c +++ b/ext/stub/oo/constantsinterface.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(Stub_Oo_ConstantsInterface, testReadInterfaceConstant1) { zval *this_ptr = getThis(); + RETURN_NULL(); } @@ -42,6 +43,7 @@ PHP_METHOD(Stub_Oo_ConstantsInterface, testReadInterfaceConstant2) { zval *this_ptr = getThis(); + RETURN_BOOL(0); } @@ -51,6 +53,7 @@ PHP_METHOD(Stub_Oo_ConstantsInterface, testReadInterfaceConstant3) { zval *this_ptr = getThis(); + RETURN_BOOL(1); } @@ -60,6 +63,7 @@ PHP_METHOD(Stub_Oo_ConstantsInterface, testReadInterfaceConstant4) { zval *this_ptr = getThis(); + RETURN_LONG(10); } @@ -69,6 +73,7 @@ PHP_METHOD(Stub_Oo_ConstantsInterface, testReadInterfaceConstant5) { zval *this_ptr = getThis(); + RETURN_DOUBLE(10.25); } @@ -78,6 +83,7 @@ PHP_METHOD(Stub_Oo_ConstantsInterface, testReadInterfaceConstant6) { zval *this_ptr = getThis(); + RETURN_STRING("test"); } diff --git a/ext/stub/oo/constantsinterface.zep.h b/ext/stub/oo/constantsinterface.zep.h index 408bc90e64..f6c552dca8 100644 --- a/ext/stub/oo/constantsinterface.zep.h +++ b/ext/stub/oo/constantsinterface.zep.h @@ -29,11 +29,35 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_constantsinterface_testreadinterfaceconst ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_constantsinterface_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant1, arginfo_stub_oo_constantsinterface_testreadinterfaceconstant1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant2, arginfo_stub_oo_constantsinterface_testreadinterfaceconstant2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant3, arginfo_stub_oo_constantsinterface_testreadinterfaceconstant3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant3, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant4, arginfo_stub_oo_constantsinterface_testreadinterfaceconstant4, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant4, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant5, arginfo_stub_oo_constantsinterface_testreadinterfaceconstant5, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant5, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant6, arginfo_stub_oo_constantsinterface_testreadinterfaceconstant6, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_ConstantsInterface, testReadInterfaceConstant6, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/oo/deprecatedmethods.zep.c b/ext/stub/oo/deprecatedmethods.zep.c index 61b020ea7c..ae5e035d08 100644 --- a/ext/stub/oo/deprecatedmethods.zep.c +++ b/ext/stub/oo/deprecatedmethods.zep.c @@ -30,6 +30,7 @@ PHP_METHOD(Stub_Oo_DeprecatedMethods, publicDeprecated) { zval *this_ptr = getThis(); + RETURN_BOOL(1); } @@ -41,9 +42,10 @@ PHP_METHOD(Stub_Oo_DeprecatedMethods, normalMethod) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); - ZEPHIR_RETURN_CALL_METHOD(this_ptr, "privatedeprecated", NULL, 55); + ZEPHIR_RETURN_CALL_METHOD(this_ptr, "privatedeprecated", NULL, 58); zephir_check_call_status(); RETURN_MM(); @@ -54,6 +56,7 @@ PHP_METHOD(Stub_Oo_DeprecatedMethods, privateDeprecated) { zval *this_ptr = getThis(); + RETURN_BOOL(1); } diff --git a/ext/stub/oo/deprecatedmethods.zep.h b/ext/stub/oo/deprecatedmethods.zep.h index 25e0c5263a..0ffa7652bc 100644 --- a/ext/stub/oo/deprecatedmethods.zep.h +++ b/ext/stub/oo/deprecatedmethods.zep.h @@ -17,8 +17,20 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_deprecatedmethods_privatedeprecated, 0, 0 ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_deprecatedmethods_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_DeprecatedMethods, publicDeprecated, arginfo_stub_oo_deprecatedmethods_publicdeprecated, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED) +#else + PHP_ME(Stub_Oo_DeprecatedMethods, publicDeprecated, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_DeprecatedMethods, normalMethod, arginfo_stub_oo_deprecatedmethods_normalmethod, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_DeprecatedMethods, normalMethod, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_DeprecatedMethods, privateDeprecated, arginfo_stub_oo_deprecatedmethods_privatedeprecated, ZEND_ACC_PRIVATE|ZEND_ACC_DEPRECATED) +#else + PHP_ME(Stub_Oo_DeprecatedMethods, privateDeprecated, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_DEPRECATED) +#endif PHP_FE_END }; diff --git a/ext/stub/oo/dynamicprop.zep.c b/ext/stub/oo/dynamicprop.zep.c index 86ae56c94f..a6a5c8897a 100644 --- a/ext/stub/oo/dynamicprop.zep.c +++ b/ext/stub/oo/dynamicprop.zep.c @@ -41,6 +41,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setPropertyInt) { ZVAL_UNDEF(&property); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(property) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &property_param); @@ -73,6 +81,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setPropertyBoolTrue) { ZVAL_UNDEF(&property); ZVAL_BOOL(&__$true, 1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(property) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &property_param); @@ -103,6 +119,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setPropertyBoolFalse) { ZVAL_UNDEF(&property); ZVAL_BOOL(&__$false, 0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(property) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &property_param); @@ -133,6 +157,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setPropertyString) { ZVAL_UNDEF(&property); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(property) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &property_param); @@ -166,6 +198,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setPropertyChar) { ZVAL_UNDEF(&property); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(property) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &property_param); @@ -200,6 +240,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setPropertyUChar) { ZVAL_UNDEF(&property); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(property) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &property_param); @@ -233,6 +281,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setPropertyNull) { ZVAL_UNDEF(&property); ZVAL_NULL(&__$null); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(property) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &property_param); @@ -264,6 +320,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setPropertyVariableInt) { ZVAL_UNDEF(&property); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(property) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &property_param); @@ -297,6 +361,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setPropertyVariableString) { ZVAL_UNDEF(&property); ZVAL_UNDEF(&a); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(property) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &property_param); @@ -330,6 +402,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setPropertyVariableBoolTrue) { ZVAL_UNDEF(&property); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(property) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &property_param); @@ -364,6 +444,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setPropertyVariableBoolFalse) { ZVAL_UNDEF(&property); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(property) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &property_param); @@ -396,6 +484,7 @@ PHP_METHOD(Stub_Oo_DynamicProp, setExistingStringProperty) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -413,6 +502,14 @@ PHP_METHOD(Stub_Oo_DynamicProp, setExistingStringPropertyString) { zval *this_ptr = getThis(); ZVAL_UNDEF(&value); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &value_param); @@ -442,6 +539,7 @@ PHP_METHOD(Stub_Oo_DynamicProp, setNonExistingStringProperty) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); diff --git a/ext/stub/oo/dynamicprop.zep.h b/ext/stub/oo/dynamicprop.zep.h index f22ba00e7e..4daece4bc4 100644 --- a/ext/stub/oo/dynamicprop.zep.h +++ b/ext/stub/oo/dynamicprop.zep.h @@ -19,102 +19,54 @@ PHP_METHOD(Stub_Oo_DynamicProp, setExistingStringPropertyString); PHP_METHOD(Stub_Oo_DynamicProp, setNonExistingStringProperty); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setpropertyint, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setpropertybooltrue, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setpropertyboolfalse, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setpropertystring, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setpropertychar, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setpropertyuchar, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setpropertynull, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setpropertyvariableint, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setpropertyvariablestring, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setpropertyvariablebooltrue, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setpropertyvariableboolfalse, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setexistingstringproperty, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setexistingstringpropertystring, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, value, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, value) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_dynamicprop_setnonexistingstringproperty, 0, 0, 0) @@ -132,8 +84,16 @@ ZEPHIR_INIT_FUNCS(stub_oo_dynamicprop_method_entry) { PHP_ME(Stub_Oo_DynamicProp, setPropertyVariableString, arginfo_stub_oo_dynamicprop_setpropertyvariablestring, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_DynamicProp, setPropertyVariableBoolTrue, arginfo_stub_oo_dynamicprop_setpropertyvariablebooltrue, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_DynamicProp, setPropertyVariableBoolFalse, arginfo_stub_oo_dynamicprop_setpropertyvariableboolfalse, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_DynamicProp, setExistingStringProperty, arginfo_stub_oo_dynamicprop_setexistingstringproperty, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_DynamicProp, setExistingStringProperty, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Oo_DynamicProp, setExistingStringPropertyString, arginfo_stub_oo_dynamicprop_setexistingstringpropertystring, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_DynamicProp, setNonExistingStringProperty, arginfo_stub_oo_dynamicprop_setnonexistingstringproperty, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_DynamicProp, setNonExistingStringProperty, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/oo/extend/exception.zep.c b/ext/stub/oo/extend/exception.zep.c index b5f6572901..ca3b3e7292 100644 --- a/ext/stub/oo/extend/exception.zep.c +++ b/ext/stub/oo/extend/exception.zep.c @@ -16,7 +16,7 @@ ZEPHIR_INIT_CLASS(Stub_Oo_Extend_Exception) { - ZEPHIR_REGISTER_CLASS_EX(Stub\\Oo\\Extend, Exception, stub, oo_extend_exception, zend_exception_get_default(), NULL, 0); + ZEPHIR_REGISTER_CLASS_EX(Stub\\Oo\\Extend, Exception, stub, oo_extend_exception, zend_ce_exception, NULL, 0); return SUCCESS; diff --git a/ext/stub/oo/extendpdoclass.zep.c b/ext/stub/oo/extendpdoclass.zep.c index 96358e8717..fce8387fb4 100644 --- a/ext/stub/oo/extendpdoclass.zep.c +++ b/ext/stub/oo/extendpdoclass.zep.c @@ -43,6 +43,18 @@ PHP_METHOD(Stub_Oo_ExtendPdoClass, __construct) { ZVAL_UNDEF(&attrs_sub); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 4) + Z_PARAM_STR(dsn) + Z_PARAM_OPTIONAL + Z_PARAM_STR_OR_NULL(username) + Z_PARAM_STR_OR_NULL(password) + Z_PARAM_ZVAL(attrs) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 3, &dsn_param, &username_param, &password_param, &attrs); diff --git a/ext/stub/oo/extendpdoclass.zep.h b/ext/stub/oo/extendpdoclass.zep.h index f83d066a46..6804cad14d 100644 --- a/ext/stub/oo/extendpdoclass.zep.h +++ b/ext/stub/oo/extendpdoclass.zep.h @@ -6,21 +6,9 @@ ZEPHIR_INIT_CLASS(Stub_Oo_ExtendPdoClass); PHP_METHOD(Stub_Oo_ExtendPdoClass, __construct); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_extendpdoclass___construct, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, dsn, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, dsn) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, username, IS_STRING, 1) -#else - ZEND_ARG_INFO(0, username) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, password, IS_STRING, 1) -#else - ZEND_ARG_INFO(0, password) -#endif ZEND_ARG_INFO(0, attrs) ZEND_END_ARG_INFO() diff --git a/ext/stub/oo/ooconstruct.zep.c b/ext/stub/oo/ooconstruct.zep.c index ab1eddb722..2421220aa6 100644 --- a/ext/stub/oo/ooconstruct.zep.c +++ b/ext/stub/oo/ooconstruct.zep.c @@ -32,5 +32,6 @@ PHP_METHOD(Stub_Oo_OoConstruct, __construct) { + } diff --git a/ext/stub/oo/ooconstruct.zep.h b/ext/stub/oo/ooconstruct.zep.h index c1eb7a2fd4..8cebd6a463 100644 --- a/ext/stub/oo/ooconstruct.zep.h +++ b/ext/stub/oo/ooconstruct.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooconstruct___construct, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_ooconstruct_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoConstruct, __construct, arginfo_stub_oo_ooconstruct___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#else + PHP_ME(Stub_Oo_OoConstruct, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#endif PHP_FE_END }; diff --git a/ext/stub/oo/ooconstructparams.zep.c b/ext/stub/oo/ooconstructparams.zep.c index cda6e6e194..91ae02c517 100644 --- a/ext/stub/oo/ooconstructparams.zep.c +++ b/ext/stub/oo/ooconstructparams.zep.c @@ -38,6 +38,15 @@ PHP_METHOD(Stub_Oo_OoConstructParams, __construct) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); @@ -53,6 +62,7 @@ PHP_METHOD(Stub_Oo_OoConstructParams, getA) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "a"); } @@ -62,6 +72,7 @@ PHP_METHOD(Stub_Oo_OoConstructParams, getB) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "b"); } diff --git a/ext/stub/oo/ooconstructparams.zep.h b/ext/stub/oo/ooconstructparams.zep.h index f9ca6d23cb..2d97ecad9a 100644 --- a/ext/stub/oo/ooconstructparams.zep.h +++ b/ext/stub/oo/ooconstructparams.zep.h @@ -20,7 +20,15 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_ooconstructparams_method_entry) { PHP_ME(Stub_Oo_OoConstructParams, __construct, arginfo_stub_oo_ooconstructparams___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoConstructParams, getA, arginfo_stub_oo_ooconstructparams_geta, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoConstructParams, getA, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoConstructParams, getB, arginfo_stub_oo_ooconstructparams_getb, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoConstructParams, getB, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/oo/oodestruct.zep.c b/ext/stub/oo/oodestruct.zep.c index 1e5c625ace..efb2a0c52b 100644 --- a/ext/stub/oo/oodestruct.zep.c +++ b/ext/stub/oo/oodestruct.zep.c @@ -81,6 +81,7 @@ PHP_METHOD(Stub_Oo_OoDestruct, getHeight) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "height"); } @@ -90,6 +91,7 @@ PHP_METHOD(Stub_Oo_OoDestruct, getImage) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "image"); } @@ -102,6 +104,7 @@ PHP_METHOD(Stub_Oo_OoDestruct, getMime) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "mime"); } @@ -111,6 +114,7 @@ PHP_METHOD(Stub_Oo_OoDestruct, getRealpath) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "realpath"); } @@ -127,6 +131,7 @@ PHP_METHOD(Stub_Oo_OoDestruct, getType) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "type"); } @@ -139,6 +144,7 @@ PHP_METHOD(Stub_Oo_OoDestruct, getWidth) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "width"); } @@ -148,8 +154,9 @@ PHP_METHOD(Stub_Oo_OoDestruct, __construct) { zend_bool _30$$13; zend_class_entry *_26$$11 = NULL, *_22$$12 = NULL, *_32$$14 = NULL; zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zephir_fcall_cache_entry *_29 = NULL; zend_long width, height, ZEPHIR_LAST_CALL_STATUS; - zval *file_param = NULL, *width_param = NULL, *height_param = NULL, __$true, imageinfo, _0, _1, _2$$4, _3$$4, _4$$4, _9$$4, _28$$4, _29$$4, _5$$5, _6$$5, _7$$5, _8$$5, _10$$6, _11$$6, _12$$7, _13$$7, _14$$8, _15$$8, _16$$9, _17$$9, _18$$10, _19$$10, _20$$11, _25$$11, _27$$11, _21$$12, _23$$12, _24$$12, _35$$13, _36$$13, _37$$13, _38$$13, _39$$13, _40$$13, _31$$14, _33$$14, _34$$14; + zval *file_param = NULL, *width_param = NULL, *height_param = NULL, __$true, imageinfo, _0, _1, _2$$4, _3$$4, _4$$4, _9$$4, _28$$4, _5$$5, _6$$5, _7$$5, _8$$5, _10$$6, _11$$6, _12$$7, _13$$7, _14$$8, _15$$8, _16$$9, _17$$9, _18$$10, _19$$10, _20$$11, _25$$11, _27$$11, _21$$12, _23$$12, _24$$12, _35$$13, _36$$13, _37$$13, _38$$13, _39$$13, _40$$13, _31$$14, _33$$14, _34$$14; zval file; zval *this_ptr = getThis(); @@ -163,7 +170,6 @@ PHP_METHOD(Stub_Oo_OoDestruct, __construct) { ZVAL_UNDEF(&_4$$4); ZVAL_UNDEF(&_9$$4); ZVAL_UNDEF(&_28$$4); - ZVAL_UNDEF(&_29$$4); ZVAL_UNDEF(&_5$$5); ZVAL_UNDEF(&_6$$5); ZVAL_UNDEF(&_7$$5); @@ -193,6 +199,17 @@ PHP_METHOD(Stub_Oo_OoDestruct, __construct) { ZVAL_UNDEF(&_31$$14); ZVAL_UNDEF(&_33$$14); ZVAL_UNDEF(&_34$$14); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 3) + Z_PARAM_STR(file) + Z_PARAM_OPTIONAL + Z_PARAM_LONG_OR_NULL(width, is_null_true) + Z_PARAM_LONG_OR_NULL(height, is_null_true) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &file_param, &width_param, &height_param); @@ -228,11 +245,11 @@ PHP_METHOD(Stub_Oo_OoDestruct, __construct) { zephir_read_property(&_1, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); if ((zephir_file_exists(&_1) == SUCCESS)) { zephir_read_property(&_2$$4, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_3$$4, "realpath", NULL, 56, &_2$$4); + ZEPHIR_CALL_FUNCTION(&_3$$4, "realpath", NULL, 59, &_2$$4); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("realpath"), &_3$$4); zephir_read_property(&_4$$4, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&imageinfo, "getimagesize", NULL, 57, &_4$$4); + ZEPHIR_CALL_FUNCTION(&imageinfo, "getimagesize", NULL, 60, &_4$$4); zephir_check_call_status(); if (zephir_is_true(&imageinfo)) { zephir_array_fetch_long(&_5$$5, &imageinfo, 0, PH_NOISY | PH_READONLY, "stub/oo/oodestruct.zep", 62); @@ -248,7 +265,7 @@ PHP_METHOD(Stub_Oo_OoDestruct, __construct) { do { if (ZEPHIR_IS_LONG(&_9$$4, 1)) { zephir_read_property(&_10$$6, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_11$$6, "imagecreatefromgif", NULL, 0, &_10$$6); + ZEPHIR_CALL_FUNCTION(&_11$$6, "imagecreatefromgif", NULL, 61, &_10$$6); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &_11$$6); break; @@ -262,21 +279,21 @@ PHP_METHOD(Stub_Oo_OoDestruct, __construct) { } if (ZEPHIR_IS_LONG(&_9$$4, 3)) { zephir_read_property(&_14$$8, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_15$$8, "imagecreatefrompng", NULL, 0, &_14$$8); + ZEPHIR_CALL_FUNCTION(&_15$$8, "imagecreatefrompng", NULL, 62, &_14$$8); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &_15$$8); break; } if (ZEPHIR_IS_LONG(&_9$$4, 15)) { zephir_read_property(&_16$$9, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_17$$9, "imagecreatefromwbmp", NULL, 0, &_16$$9); + ZEPHIR_CALL_FUNCTION(&_17$$9, "imagecreatefromwbmp", NULL, 63, &_16$$9); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &_17$$9); break; } if (ZEPHIR_IS_LONG(&_9$$4, 16)) { zephir_read_property(&_18$$10, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(&_19$$10, "imagecreatefromxbm", NULL, 0, &_18$$10); + ZEPHIR_CALL_FUNCTION(&_19$$10, "imagecreatefromxbm", NULL, 64, &_18$$10); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &_19$$10); break; @@ -316,8 +333,7 @@ PHP_METHOD(Stub_Oo_OoDestruct, __construct) { } while(0); zephir_read_property(&_28$$4, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZVAL_BOOL(&_29$$4, 1); - ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 0, &_28$$4, &_29$$4); + ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", &_29, 65, &_28$$4, &__$true); zephir_check_call_status(); } else { _30$$13 = !width; @@ -343,15 +359,14 @@ PHP_METHOD(Stub_Oo_OoDestruct, __construct) { } ZVAL_LONG(&_35$$13, width); ZVAL_LONG(&_36$$13, height); - ZEPHIR_CALL_FUNCTION(&_37$$13, "imagecreatetruecolor", NULL, 0, &_35$$13, &_36$$13); + ZEPHIR_CALL_FUNCTION(&_37$$13, "imagecreatetruecolor", NULL, 66, &_35$$13, &_36$$13); zephir_check_call_status(); zephir_update_property_zval(this_ptr, ZEND_STRL("image"), &_37$$13); zephir_read_property(&_35$$13, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 58, &_35$$13, &__$true); + ZEPHIR_CALL_FUNCTION(NULL, "imagealphablending", NULL, 67, &_35$$13, &__$true); zephir_check_call_status(); zephir_read_property(&_36$$13, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); - ZVAL_BOOL(&_38$$13, 1); - ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", NULL, 0, &_36$$13, &_38$$13); + ZEPHIR_CALL_FUNCTION(NULL, "imagesavealpha", &_29, 65, &_36$$13, &__$true); zephir_check_call_status(); zephir_read_property(&_38$$13, this_ptr, ZEND_STRL("file"), PH_NOISY_CC | PH_READONLY); zephir_update_property_zval(this_ptr, ZEND_STRL("realpath"), &_38$$13); @@ -383,12 +398,13 @@ PHP_METHOD(Stub_Oo_OoDestruct, __destruct) { ZVAL_UNDEF(&image); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); zephir_read_property(&_0, this_ptr, ZEND_STRL("image"), PH_NOISY_CC | PH_READONLY); ZEPHIR_CPY_WRT(&image, &_0); if (Z_TYPE_P(&image) == IS_RESOURCE) { - ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 0, &image); + ZEPHIR_CALL_FUNCTION(NULL, "imagedestroy", NULL, 68, &image); zephir_check_call_status(); } ZEPHIR_MM_RESTORE(); @@ -415,6 +431,7 @@ PHP_METHOD(Stub_Oo_OoDestruct, check) { ZVAL_UNDEF(&_7$$5); ZVAL_UNDEF(&_9$$5); + ZEPHIR_MM_GROW(); zephir_read_static_property_ce(&_0, stub_oo_oodestruct_ce, SL("checked"), PH_NOISY_CC | PH_READONLY); @@ -443,7 +460,7 @@ PHP_METHOD(Stub_Oo_OoDestruct, check) { ZVAL_STRING(&_4, "2.0.1"); ZEPHIR_INIT_VAR(&_5); ZVAL_STRING(&_5, ">="); - ZEPHIR_CALL_FUNCTION(&_6, "version_compare", NULL, 59, &version, &_4, &_5); + ZEPHIR_CALL_FUNCTION(&_6, "version_compare", NULL, 69, &version, &_4, &_5); zephir_check_call_status(); if (UNEXPECTED(!zephir_is_true(&_6))) { ZEPHIR_INIT_VAR(&_7$$5); @@ -487,6 +504,7 @@ PHP_METHOD(Stub_Oo_OoDestruct, getVersion) { ZVAL_UNDEF(&_7$$5); ZVAL_UNDEF(&_8$$5); + ZEPHIR_MM_GROW(); if (UNEXPECTED(!((zephir_function_exists_ex(ZEND_STRL("gd_info")) == SUCCESS)))) { @@ -509,13 +527,13 @@ PHP_METHOD(Stub_Oo_OoDestruct, getVersion) { ZVAL_NULL(&version); ZEPHIR_INIT_VAR(&_3); ZVAL_STRING(&_3, "GD_VERSION"); - ZEPHIR_CALL_FUNCTION(&_4, "defined", NULL, 60, &_3); + ZEPHIR_CALL_FUNCTION(&_4, "defined", NULL, 70, &_3); zephir_check_call_status(); if (zephir_is_true(&_4)) { ZEPHIR_INIT_NVAR(&version); ZEPHIR_GET_CONSTANT(&version, "GD_VERSION"); } else { - ZEPHIR_CALL_FUNCTION(&info, "gd_info", NULL, 61); + ZEPHIR_CALL_FUNCTION(&info, "gd_info", NULL, 71); zephir_check_call_status(); ZEPHIR_INIT_VAR(&matches); ZVAL_NULL(&matches); diff --git a/ext/stub/oo/oodestruct.zep.h b/ext/stub/oo/oodestruct.zep.h index 31da80dcc9..478daeadd3 100644 --- a/ext/stub/oo/oodestruct.zep.h +++ b/ext/stub/oo/oodestruct.zep.h @@ -14,84 +14,60 @@ PHP_METHOD(Stub_Oo_OoDestruct, __destruct); PHP_METHOD(Stub_Oo_OoDestruct, check); PHP_METHOD(Stub_Oo_OoDestruct, getVersion); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_getheight, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_getheight, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oodestruct_getimage, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_getmime, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_getmime, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oodestruct_getrealpath, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_gettype, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_gettype, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_getwidth, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_getwidth, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oodestruct___construct, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, file, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, file) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, width, IS_LONG, 1) -#else - ZEND_ARG_INFO(0, width) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, height, IS_LONG, 1) -#else - ZEND_ARG_INFO(0, height) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oodestruct___destruct, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_check, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_check, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_getversion, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oodestruct_getversion, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_oodestruct_method_entry) { PHP_ME(Stub_Oo_OoDestruct, getHeight, arginfo_stub_oo_oodestruct_getheight, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoDestruct, getImage, arginfo_stub_oo_oodestruct_getimage, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoDestruct, getImage, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Oo_OoDestruct, getMime, arginfo_stub_oo_oodestruct_getmime, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoDestruct, getRealpath, arginfo_stub_oo_oodestruct_getrealpath, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoDestruct, getRealpath, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Oo_OoDestruct, getType, arginfo_stub_oo_oodestruct_gettype, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_OoDestruct, getWidth, arginfo_stub_oo_oodestruct_getwidth, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_OoDestruct, __construct, arginfo_stub_oo_oodestruct___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoDestruct, __destruct, arginfo_stub_oo_oodestruct___destruct, ZEND_ACC_PUBLIC|ZEND_ACC_DTOR) +#else + PHP_ME(Stub_Oo_OoDestruct, __destruct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_DTOR) +#endif PHP_ME(Stub_Oo_OoDestruct, check, arginfo_stub_oo_oodestruct_check, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) PHP_ME(Stub_Oo_OoDestruct, getVersion, arginfo_stub_oo_oodestruct_getversion, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) PHP_FE_END diff --git a/ext/stub/oo/oodynamica.zep.c b/ext/stub/oo/oodynamica.zep.c index c6c6c2f49f..b4f42ad409 100644 --- a/ext/stub/oo/oodynamica.zep.c +++ b/ext/stub/oo/oodynamica.zep.c @@ -41,6 +41,7 @@ PHP_METHOD(Stub_Oo_OoDynamicA, getNew) { ZVAL_UNDEF(&fullClassName); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&className); @@ -68,6 +69,7 @@ PHP_METHOD(Stub_Oo_OoDynamicA, call2) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_SELF("getnew", NULL, 0); @@ -83,6 +85,7 @@ PHP_METHOD(Stub_Oo_OoDynamicA, call1) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_SELF("call2", NULL, 0); @@ -96,6 +99,7 @@ PHP_METHOD(Stub_Oo_OoDynamicA, execute) { zval *this_ptr = getThis(); + RETURN_STRING("A"); } @@ -105,6 +109,7 @@ PHP_METHOD(Stub_Oo_OoDynamicA, execute2) { zval *this_ptr = getThis(); + RETURN_STRING("AA"); } diff --git a/ext/stub/oo/oodynamica.zep.h b/ext/stub/oo/oodynamica.zep.h index df2258cf47..c96fa916fb 100644 --- a/ext/stub/oo/oodynamica.zep.h +++ b/ext/stub/oo/oodynamica.zep.h @@ -25,10 +25,30 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oodynamica_execute2, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_oodynamica_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoDynamicA, getNew, arginfo_stub_oo_oodynamica_getnew, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Oo_OoDynamicA, getNew, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoDynamicA, call2, arginfo_stub_oo_oodynamica_call2, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Oo_OoDynamicA, call2, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoDynamicA, call1, arginfo_stub_oo_oodynamica_call1, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Oo_OoDynamicA, call1, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoDynamicA, execute, arginfo_stub_oo_oodynamica_execute, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoDynamicA, execute, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoDynamicA, execute2, arginfo_stub_oo_oodynamica_execute2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoDynamicA, execute2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/oo/oodynamicb.zep.c b/ext/stub/oo/oodynamicb.zep.c index 08b3f8fa86..430c0a17f5 100644 --- a/ext/stub/oo/oodynamicb.zep.c +++ b/ext/stub/oo/oodynamicb.zep.c @@ -31,6 +31,7 @@ PHP_METHOD(Stub_Oo_OoDynamicB, execute) { zval *this_ptr = getThis(); + RETURN_STRING("B"); } @@ -40,6 +41,7 @@ PHP_METHOD(Stub_Oo_OoDynamicB, execute2) { zval *this_ptr = getThis(); + RETURN_STRING("BB"); } diff --git a/ext/stub/oo/oodynamicb.zep.h b/ext/stub/oo/oodynamicb.zep.h index 8cab8f24ab..a003c816de 100644 --- a/ext/stub/oo/oodynamicb.zep.h +++ b/ext/stub/oo/oodynamicb.zep.h @@ -13,7 +13,15 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oodynamicb_execute2, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_oodynamicb_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoDynamicB, execute, arginfo_stub_oo_oodynamicb_execute, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoDynamicB, execute, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoDynamicB, execute2, arginfo_stub_oo_oodynamicb_execute2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoDynamicB, execute2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/oo/oonativeimplements.zep.c b/ext/stub/oo/oonativeimplements.zep.c index 0d6f0333f9..0f4fbd4f69 100644 --- a/ext/stub/oo/oonativeimplements.zep.c +++ b/ext/stub/oo/oonativeimplements.zep.c @@ -25,7 +25,7 @@ ZEPHIR_INIT_CLASS(Stub_Oo_OoNativeImplements) { ZEPHIR_REGISTER_CLASS(Stub\\Oo, OoNativeImplements, stub, oo_oonativeimplements, stub_oo_oonativeimplements_method_entry, 0); - zend_class_implements(stub_oo_oonativeimplements_ce, 1, spl_ce_Countable); + zend_class_implements(stub_oo_oonativeimplements_ce, 1, zend_ce_countable); zend_class_implements(stub_oo_oonativeimplements_ce, 1, zend_ce_iterator); zend_class_implements(stub_oo_oonativeimplements_ce, 1, spl_ce_OuterIterator); zend_class_implements(stub_oo_oonativeimplements_ce, 1, spl_ce_RecursiveIterator); @@ -40,6 +40,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, count) { + } PHP_METHOD(Stub_Oo_OoNativeImplements, current) { @@ -48,6 +49,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, current) { + } PHP_METHOD(Stub_Oo_OoNativeImplements, key) { @@ -56,6 +58,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, key) { + } PHP_METHOD(Stub_Oo_OoNativeImplements, next) { @@ -64,6 +67,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, next) { + } PHP_METHOD(Stub_Oo_OoNativeImplements, rewind) { @@ -72,6 +76,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, rewind) { + } PHP_METHOD(Stub_Oo_OoNativeImplements, valid) { @@ -80,6 +85,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, valid) { + } PHP_METHOD(Stub_Oo_OoNativeImplements, getInnerIterator) { @@ -88,6 +94,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, getInnerIterator) { + } PHP_METHOD(Stub_Oo_OoNativeImplements, getChildren) { @@ -96,6 +103,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, getChildren) { + } PHP_METHOD(Stub_Oo_OoNativeImplements, hasChildren) { @@ -104,6 +112,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, hasChildren) { + } PHP_METHOD(Stub_Oo_OoNativeImplements, seek) { @@ -112,6 +121,14 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, seek) { zval *this_ptr = getThis(); ZVAL_UNDEF(&position_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(position) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &position); @@ -126,6 +143,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, getIterator) { + } PHP_METHOD(Stub_Oo_OoNativeImplements, offsetExists) { @@ -134,6 +152,14 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, offsetExists) { zval *this_ptr = getThis(); ZVAL_UNDEF(&offset_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(offset) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &offset); @@ -148,6 +174,14 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, offsetGet) { zval *this_ptr = getThis(); ZVAL_UNDEF(&offset_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(offset) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &offset); @@ -163,6 +197,15 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, offsetSet) { ZVAL_UNDEF(&offset_sub); ZVAL_UNDEF(&value_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(offset) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &offset, &value); @@ -177,6 +220,14 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, offsetUnset) { zval *this_ptr = getThis(); ZVAL_UNDEF(&offset_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(offset) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &offset); @@ -191,6 +242,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, serialize) { + } PHP_METHOD(Stub_Oo_OoNativeImplements, unserialize) { @@ -201,6 +253,14 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, unserialize) { zval *this_ptr = getThis(); ZVAL_UNDEF(&serialized); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(serialized) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &serialized_param); diff --git a/ext/stub/oo/oonativeimplements.zep.h b/ext/stub/oo/oonativeimplements.zep.h index d8dfcd763f..0c454ba069 100644 --- a/ext/stub/oo/oonativeimplements.zep.h +++ b/ext/stub/oo/oonativeimplements.zep.h @@ -21,11 +21,7 @@ PHP_METHOD(Stub_Oo_OoNativeImplements, offsetUnset); PHP_METHOD(Stub_Oo_OoNativeImplements, serialize); PHP_METHOD(Stub_Oo_OoNativeImplements, unserialize); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_count, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_count, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oonativeimplements_current, 0, 0, 0) @@ -40,46 +36,26 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oonativeimplements_rewind, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_valid, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_valid, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oonativeimplements_getinneriterator, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_oo_oonativeimplements_getchildren, 0, 0, RecursiveIterator, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_getchildren, 0, 0, IS_OBJECT, "RecursiveIterator", 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_haschildren, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_haschildren, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oonativeimplements_seek, 0, 0, 1) ZEND_ARG_INFO(0, position) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_oo_oonativeimplements_getiterator, 0, 0, Traversable, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_getiterator, 0, 0, IS_OBJECT, "Traversable", 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_offsetexists, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_offsetexists, 0, 1, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_INFO(0, offset) ZEND_END_ARG_INFO() @@ -96,29 +72,41 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oonativeimplements_offsetunset, 0, 0, 1) ZEND_ARG_INFO(0, offset) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_serialize, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_oonativeimplements_serialize, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_oonativeimplements_unserialize, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, serialized, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, serialized) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_oonativeimplements_method_entry) { PHP_ME(Stub_Oo_OoNativeImplements, count, arginfo_stub_oo_oonativeimplements_count, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoNativeImplements, current, arginfo_stub_oo_oonativeimplements_current, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoNativeImplements, current, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoNativeImplements, key, arginfo_stub_oo_oonativeimplements_key, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoNativeImplements, key, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoNativeImplements, next, arginfo_stub_oo_oonativeimplements_next, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoNativeImplements, next, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoNativeImplements, rewind, arginfo_stub_oo_oonativeimplements_rewind, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoNativeImplements, rewind, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Oo_OoNativeImplements, valid, arginfo_stub_oo_oonativeimplements_valid, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoNativeImplements, getInnerIterator, arginfo_stub_oo_oonativeimplements_getinneriterator, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoNativeImplements, getInnerIterator, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Oo_OoNativeImplements, getChildren, arginfo_stub_oo_oonativeimplements_getchildren, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_OoNativeImplements, hasChildren, arginfo_stub_oo_oonativeimplements_haschildren, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_OoNativeImplements, seek, arginfo_stub_oo_oonativeimplements_seek, ZEND_ACC_PUBLIC) diff --git a/ext/stub/oo/ooparams.zep.c b/ext/stub/oo/ooparams.zep.c index 7feea0390b..0b0278f11a 100644 --- a/ext/stub/oo/ooparams.zep.c +++ b/ext/stub/oo/ooparams.zep.c @@ -38,6 +38,7 @@ PHP_METHOD(Stub_Oo_OoParams, createThisClassWithoutWriteCurrentNamespace) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); object_init_ex(return_value, stub_oo_ooparams_ce); @@ -56,6 +57,7 @@ PHP_METHOD(Stub_Oo_OoParams, createOtherClassWithoutWriteCurrentNamespace) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); object_init_ex(return_value, stub_oo_oodynamica_ce); @@ -73,6 +75,14 @@ PHP_METHOD(Stub_Oo_OoParams, setAge) { zend_long age; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(age) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &age_param); @@ -89,6 +99,14 @@ PHP_METHOD(Stub_Oo_OoParams, setAverage) { double average; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(average) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &average_param); @@ -107,6 +125,14 @@ PHP_METHOD(Stub_Oo_OoParams, setName) { zval *this_ptr = getThis(); ZVAL_UNDEF(&name); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(name) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &name_param); @@ -124,6 +150,14 @@ PHP_METHOD(Stub_Oo_OoParams, setEnabled) { zend_bool enabled; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_BOOL(enabled) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &enabled_param); @@ -142,6 +176,14 @@ PHP_METHOD(Stub_Oo_OoParams, setList) { zval *this_ptr = getThis(); ZVAL_UNDEF(&someList); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(someList) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &someList_param); @@ -159,6 +201,14 @@ PHP_METHOD(Stub_Oo_OoParams, setStrictAge) { zend_long age; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(age) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &age_param); @@ -179,6 +229,14 @@ PHP_METHOD(Stub_Oo_OoParams, setStrictAverage) { double average; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(average) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &average_param); @@ -202,6 +260,7 @@ PHP_METHOD(Stub_Oo_OoParams, setStrictNameFromZephirLand) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, 12345); @@ -219,6 +278,14 @@ PHP_METHOD(Stub_Oo_OoParams, setStrictName) { zval *this_ptr = getThis(); ZVAL_UNDEF(&name); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(name) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &name_param); @@ -245,6 +312,14 @@ PHP_METHOD(Stub_Oo_OoParams, setStrictEnabled) { zend_bool enabled; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_BOOL(enabled) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &enabled_param); @@ -263,6 +338,14 @@ PHP_METHOD(Stub_Oo_OoParams, setStrictList) { zval *this_ptr = getThis(); ZVAL_UNDEF(&someList); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(someList) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &someList_param); @@ -280,6 +363,15 @@ PHP_METHOD(Stub_Oo_OoParams, setAgeDefault) { zend_long age; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_LONG(age) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, &age_param); @@ -300,6 +392,15 @@ PHP_METHOD(Stub_Oo_OoParams, setAverageDefault) { double average; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(average) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, &average_param); @@ -322,6 +423,15 @@ PHP_METHOD(Stub_Oo_OoParams, setNameDefault) { zval *this_ptr = getThis(); ZVAL_UNDEF(&name); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_STR(name) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &name_param); @@ -344,6 +454,15 @@ PHP_METHOD(Stub_Oo_OoParams, setEnabledDefault) { zend_bool enabled; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(enabled) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(0, 1, &enabled_param); @@ -366,6 +485,15 @@ PHP_METHOD(Stub_Oo_OoParams, setListDefault) { zval *this_ptr = getThis(); ZVAL_UNDEF(&someList); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ARRAY(someList) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &someList_param); @@ -388,6 +516,14 @@ PHP_METHOD(Stub_Oo_OoParams, setConstAge) { zend_long age; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(age) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &age_param); @@ -404,6 +540,14 @@ PHP_METHOD(Stub_Oo_OoParams, setConstAverage) { double average; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(average) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &average_param); @@ -420,6 +564,14 @@ PHP_METHOD(Stub_Oo_OoParams, setObject) { zval *this_ptr = getThis(); ZVAL_UNDEF(&obj_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT(obj) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &obj); @@ -436,6 +588,14 @@ PHP_METHOD(Stub_Oo_OoParams, setCallable) { zval *this_ptr = getThis(); ZVAL_UNDEF(&obj_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(obj) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &obj); @@ -452,6 +612,14 @@ PHP_METHOD(Stub_Oo_OoParams, setResource) { zval *this_ptr = getThis(); ZVAL_UNDEF(&obj_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_RESOURCE(obj) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &obj); @@ -468,6 +636,14 @@ PHP_METHOD(Stub_Oo_OoParams, setObjectClassCast) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶meter_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(parameter, stub_oo_param_ce) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, ¶meter); diff --git a/ext/stub/oo/ooparams.zep.h b/ext/stub/oo/ooparams.zep.h index 3c774faa7f..42b764a2c7 100644 --- a/ext/stub/oo/ooparams.zep.h +++ b/ext/stub/oo/ooparams.zep.h @@ -35,35 +35,19 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_createotherclasswithoutwritecurr ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setage, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, age, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, age) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setaverage, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, average, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, average) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setname, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, name) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setenabled, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, enabled, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, enabled) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setlist, 0, 0, 1) @@ -71,42 +55,22 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setlist, 0, 0, 1) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setstrictage, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, age, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, age) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setstrictaverage, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, average, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, average) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setstrictnamefromzephirland, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_ooparams_setstrictname, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_ooparams_setstrictname, 0, 1, IS_STRING, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, name) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setstrictenabled, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, enabled, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, enabled) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setstrictlist, 0, 0, 1) @@ -114,35 +78,19 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setstrictlist, 0, 0, 1) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setagedefault, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, age, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, age) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setaveragedefault, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, average, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, average) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setnamedefault, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, name) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setenableddefault, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, enabled, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, enabled) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setlistdefault, 0, 0, 0) @@ -150,19 +98,11 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setlistdefault, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setconstage, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, age, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, age) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setconstaverage, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, average, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, average) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setobject, 0, 0, 1) @@ -182,8 +122,16 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_ooparams_setobjectclasscast, 0, 0, 1) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_ooparams_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoParams, createThisClassWithoutWriteCurrentNamespace, arginfo_stub_oo_ooparams_createthisclasswithoutwritecurrentnamespace, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoParams, createThisClassWithoutWriteCurrentNamespace, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoParams, createOtherClassWithoutWriteCurrentNamespace, arginfo_stub_oo_ooparams_createotherclasswithoutwritecurrentnamespace, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoParams, createOtherClassWithoutWriteCurrentNamespace, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Oo_OoParams, setAge, arginfo_stub_oo_ooparams_setage, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_OoParams, setAverage, arginfo_stub_oo_ooparams_setaverage, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_OoParams, setName, arginfo_stub_oo_ooparams_setname, ZEND_ACC_PUBLIC) @@ -191,7 +139,11 @@ ZEPHIR_INIT_FUNCS(stub_oo_ooparams_method_entry) { PHP_ME(Stub_Oo_OoParams, setList, arginfo_stub_oo_ooparams_setlist, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_OoParams, setStrictAge, arginfo_stub_oo_ooparams_setstrictage, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_OoParams, setStrictAverage, arginfo_stub_oo_ooparams_setstrictaverage, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_OoParams, setStrictNameFromZephirLand, arginfo_stub_oo_ooparams_setstrictnamefromzephirland, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_OoParams, setStrictNameFromZephirLand, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Oo_OoParams, setStrictName, arginfo_stub_oo_ooparams_setstrictname, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_OoParams, setStrictEnabled, arginfo_stub_oo_ooparams_setstrictenabled, ZEND_ACC_PUBLIC) PHP_ME(Stub_Oo_OoParams, setStrictList, arginfo_stub_oo_ooparams_setstrictlist, ZEND_ACC_PUBLIC) diff --git a/ext/stub/oo/propertyaccess.zep.c b/ext/stub/oo/propertyaccess.zep.c index 7dc1610bd7..664f79ba3b 100644 --- a/ext/stub/oo/propertyaccess.zep.c +++ b/ext/stub/oo/propertyaccess.zep.c @@ -52,6 +52,7 @@ PHP_METHOD(Stub_Oo_PropertyAccess, __construct) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_6); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&test); @@ -114,6 +115,14 @@ PHP_METHOD(Stub_Oo_PropertyAccess, setPrivatevariable) { zval *this_ptr = getThis(); ZVAL_UNDEF(&value_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &value); @@ -132,6 +141,7 @@ PHP_METHOD(Stub_Oo_PropertyAccess, getPrivatevariable) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "privateVariable"); } diff --git a/ext/stub/oo/propertyaccess.zep.h b/ext/stub/oo/propertyaccess.zep.h index e73805688a..396ffb1c75 100644 --- a/ext/stub/oo/propertyaccess.zep.h +++ b/ext/stub/oo/propertyaccess.zep.h @@ -10,11 +10,7 @@ PHP_METHOD(Stub_Oo_PropertyAccess, getPrivatevariable); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_propertyaccess___construct, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_oo_propertyaccess_setprivatevariable, 0, 1, Stub\\Oo\\PropertyAccess, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_propertyaccess_setprivatevariable, 0, 1, IS_OBJECT, "Stub\\Oo\\PropertyAccess", 0) -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() @@ -22,8 +18,16 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_propertyaccess_getprivatevariable, 0, 0, ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_propertyaccess_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_PropertyAccess, __construct, arginfo_stub_oo_propertyaccess___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#else + PHP_ME(Stub_Oo_PropertyAccess, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#endif PHP_ME(Stub_Oo_PropertyAccess, setPrivatevariable, arginfo_stub_oo_propertyaccess_setprivatevariable, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_PropertyAccess, getPrivatevariable, arginfo_stub_oo_propertyaccess_getprivatevariable, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_PropertyAccess, getPrivatevariable, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/oo/scopes/abstractclass.zep.c b/ext/stub/oo/scopes/abstractclass.zep.c index a170114a0f..9fdef87a41 100644 --- a/ext/stub/oo/scopes/abstractclass.zep.c +++ b/ext/stub/oo/scopes/abstractclass.zep.c @@ -38,6 +38,15 @@ PHP_METHOD(Stub_Oo_Scopes_AbstractClass, setProperty) { ZVAL_UNDEF(&name); ZVAL_UNDEF(&value_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(name) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &name_param, &value); @@ -55,6 +64,7 @@ PHP_METHOD(Stub_Oo_Scopes_AbstractClass, getPrivateProperty2) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "privateProperty2"); } @@ -64,6 +74,7 @@ PHP_METHOD(Stub_Oo_Scopes_AbstractClass, getProtectedProperty2) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "protectedProperty2"); } diff --git a/ext/stub/oo/scopes/abstractclass.zep.h b/ext/stub/oo/scopes/abstractclass.zep.h index 42b346daa6..37f2604910 100644 --- a/ext/stub/oo/scopes/abstractclass.zep.h +++ b/ext/stub/oo/scopes/abstractclass.zep.h @@ -8,11 +8,7 @@ PHP_METHOD(Stub_Oo_Scopes_AbstractClass, getPrivateProperty2); PHP_METHOD(Stub_Oo_Scopes_AbstractClass, getProtectedProperty2); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_scopes_abstractclass_setproperty, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, name) -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() @@ -24,7 +20,15 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_scopes_abstractclass_method_entry) { PHP_ME(Stub_Oo_Scopes_AbstractClass, setProperty, arginfo_stub_oo_scopes_abstractclass_setproperty, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_Scopes_AbstractClass, getPrivateProperty2, arginfo_stub_oo_scopes_abstractclass_getprivateproperty2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_Scopes_AbstractClass, getPrivateProperty2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Oo_Scopes_AbstractClass, getProtectedProperty2, arginfo_stub_oo_scopes_abstractclass_getprotectedproperty2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Oo_Scopes_AbstractClass, getProtectedProperty2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/oo/scopes/abstractclassmagic.zep.c b/ext/stub/oo/scopes/abstractclassmagic.zep.c index 68e80620ad..1599268659 100644 --- a/ext/stub/oo/scopes/abstractclassmagic.zep.c +++ b/ext/stub/oo/scopes/abstractclassmagic.zep.c @@ -44,6 +44,15 @@ PHP_METHOD(Stub_Oo_Scopes_AbstractClassMagic, __set) { ZVAL_UNDEF(&value_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(name) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &name_param, &value); @@ -69,6 +78,14 @@ PHP_METHOD(Stub_Oo_Scopes_AbstractClassMagic, __get) { ZVAL_UNDEF(&name); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(name) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &name_param); diff --git a/ext/stub/oo/scopes/abstractclassmagic.zep.h b/ext/stub/oo/scopes/abstractclassmagic.zep.h index 2d6a5f83a8..9e4cf531cc 100644 --- a/ext/stub/oo/scopes/abstractclassmagic.zep.h +++ b/ext/stub/oo/scopes/abstractclassmagic.zep.h @@ -6,31 +6,14 @@ ZEPHIR_INIT_CLASS(Stub_Oo_Scopes_AbstractClassMagic); PHP_METHOD(Stub_Oo_Scopes_AbstractClassMagic, __set); PHP_METHOD(Stub_Oo_Scopes_AbstractClassMagic, __get); -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_scopes_abstractclassmagic___set, 0, 2, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_scopes_abstractclassmagic___set, 0, 2, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_scopes_abstractclassmagic___set, 0, 0, 2) -#define arginfo_stub_oo_scopes_abstractclassmagic___set NULL -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, name) -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_scopes_abstractclassmagic___get, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, name) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_scopes_abstractclassmagic_method_entry) { diff --git a/ext/stub/oo/scopes/hasprivatemethod.zep.c b/ext/stub/oo/scopes/hasprivatemethod.zep.c index 59d70eda80..55e7fe9676 100644 --- a/ext/stub/oo/scopes/hasprivatemethod.zep.c +++ b/ext/stub/oo/scopes/hasprivatemethod.zep.c @@ -32,6 +32,7 @@ PHP_METHOD(Stub_Oo_Scopes_HasPrivateMethod, callPrivateMethod) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "isprivate", NULL, 1); @@ -45,6 +46,7 @@ PHP_METHOD(Stub_Oo_Scopes_HasPrivateMethod, isPrivate) { zval *this_ptr = getThis(); + RETURN_STRING("isPrivate"); } diff --git a/ext/stub/oo/scopes/hasprivatemethod.zep.h b/ext/stub/oo/scopes/hasprivatemethod.zep.h index 6164f3d359..aac11c6852 100644 --- a/ext/stub/oo/scopes/hasprivatemethod.zep.h +++ b/ext/stub/oo/scopes/hasprivatemethod.zep.h @@ -6,18 +6,10 @@ ZEPHIR_INIT_CLASS(Stub_Oo_Scopes_HasPrivateMethod); PHP_METHOD(Stub_Oo_Scopes_HasPrivateMethod, callPrivateMethod); PHP_METHOD(Stub_Oo_Scopes_HasPrivateMethod, isPrivate); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_scopes_hasprivatemethod_callprivatemethod, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_scopes_hasprivatemethod_callprivatemethod, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_scopes_hasprivatemethod_isprivate, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_scopes_hasprivatemethod_isprivate, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_scopes_hasprivatemethod_method_entry) { diff --git a/ext/stub/oo/scopes/privatescopetester.zep.c b/ext/stub/oo/scopes/privatescopetester.zep.c index ae856c49a1..da89d9587f 100644 --- a/ext/stub/oo/scopes/privatescopetester.zep.c +++ b/ext/stub/oo/scopes/privatescopetester.zep.c @@ -34,6 +34,7 @@ PHP_METHOD(Stub_Oo_Scopes_PrivateScopeTester, run) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_METHOD(this_ptr, "callprivatemethod", NULL, 0); @@ -56,6 +57,16 @@ PHP_METHOD(Stub_Oo_Scopes_PrivateScopeTester, setPropertyObj) { ZVAL_UNDEF(&value_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&property); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_ZVAL(obj) + Z_PARAM_STR(property) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 3, 0, &obj, &property_param, &value); @@ -86,6 +97,16 @@ PHP_METHOD(Stub_Oo_Scopes_PrivateScopeTester, setPropertyNew) { ZVAL_UNDEF(&property); ZVAL_UNDEF(&value_sub); ZVAL_UNDEF(&obj); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_STR(className) + Z_PARAM_STR(property) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 3, 0, &className_param, &property_param, &value); @@ -113,13 +134,21 @@ PHP_METHOD(Stub_Oo_Scopes_PrivateScopeTester, getObjVars) { zval *this_ptr = getThis(); ZVAL_UNDEF(&obj_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(obj) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &obj); - ZEPHIR_RETURN_CALL_FUNCTION("get_object_vars", NULL, 62, obj); + ZEPHIR_RETURN_CALL_FUNCTION("get_object_vars", NULL, 72, obj); zephir_check_call_status(); RETURN_MM(); @@ -138,6 +167,14 @@ PHP_METHOD(Stub_Oo_Scopes_PrivateScopeTester, getNewVars) { ZVAL_UNDEF(&className); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(className) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &className_param); diff --git a/ext/stub/oo/scopes/privatescopetester.zep.h b/ext/stub/oo/scopes/privatescopetester.zep.h index 9b592d5383..24b09b260b 100644 --- a/ext/stub/oo/scopes/privatescopetester.zep.h +++ b/ext/stub/oo/scopes/privatescopetester.zep.h @@ -9,34 +9,18 @@ PHP_METHOD(Stub_Oo_Scopes_PrivateScopeTester, setPropertyNew); PHP_METHOD(Stub_Oo_Scopes_PrivateScopeTester, getObjVars); PHP_METHOD(Stub_Oo_Scopes_PrivateScopeTester, getNewVars); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_scopes_privatescopetester_run, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_scopes_privatescopetester_run, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_scopes_privatescopetester_setpropertyobj, 0, 0, 3) ZEND_ARG_INFO(0, obj) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_scopes_privatescopetester_setpropertynew, 0, 0, 3) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, className, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, className) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, property, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, property) -#endif ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO() @@ -45,11 +29,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_scopes_privatescopetester_getobjvars, 0, ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_oo_scopes_privatescopetester_getnewvars, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, className, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, className) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_scopes_privatescopetester_method_entry) { diff --git a/ext/stub/oo/scopes/scopetesterinterface.zep.c b/ext/stub/oo/scopes/scopetesterinterface.zep.c index d6426f7a1d..b23bece696 100644 --- a/ext/stub/oo/scopes/scopetesterinterface.zep.c +++ b/ext/stub/oo/scopes/scopetesterinterface.zep.c @@ -21,4 +21,3 @@ ZEPHIR_INIT_CLASS(Stub_Oo_Scopes_ScopeTesterInterface) { } ZEPHIR_DOC_METHOD(Stub_Oo_Scopes_ScopeTesterInterface, run); - diff --git a/ext/stub/oo/scopes/scopetesterinterface.zep.h b/ext/stub/oo/scopes/scopetesterinterface.zep.h index 46eea9512a..e7f8691906 100644 --- a/ext/stub/oo/scopes/scopetesterinterface.zep.h +++ b/ext/stub/oo/scopes/scopetesterinterface.zep.h @@ -3,11 +3,7 @@ extern zend_class_entry *stub_oo_scopes_scopetesterinterface_ce; ZEPHIR_INIT_CLASS(Stub_Oo_Scopes_ScopeTesterInterface); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_scopes_scopetesterinterface_run, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_oo_scopes_scopetesterinterface_run, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_oo_scopes_scopetesterinterface_method_entry) { diff --git a/ext/stub/operator.zep.c b/ext/stub/operator.zep.c index 434f07175b..e2d28fe219 100644 --- a/ext/stub/operator.zep.c +++ b/ext/stub/operator.zep.c @@ -34,6 +34,15 @@ PHP_METHOD(Stub_Operator, testIdentical) { ZVAL_UNDEF(¶m1_sub); ZVAL_UNDEF(¶m2_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(param1) + Z_PARAM_ZVAL(param2) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, ¶m1, ¶m2); @@ -53,6 +62,14 @@ PHP_METHOD(Stub_Operator, testIdenticalIfComplex) { ZVAL_UNDEF(&input_sub); ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(input) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &input); @@ -77,6 +94,14 @@ PHP_METHOD(Stub_Operator, testIdenticalVarFalse) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, ¶m); @@ -92,6 +117,14 @@ PHP_METHOD(Stub_Operator, testIdenticalFalseVar) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, ¶m); @@ -111,6 +144,15 @@ PHP_METHOD(Stub_Operator, testBoolComparison) { ZVAL_UNDEF(&varTrue_sub); ZVAL_UNDEF(&varFalse_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(varTrue) + Z_PARAM_ZVAL(varFalse) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &varTrue, &varFalse); @@ -158,6 +200,14 @@ PHP_METHOD(Stub_Operator, testNewInstanceOperator) { ZVAL_UNDEF(&className_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(className) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &className); diff --git a/ext/stub/optimizers/acos.zep.c b/ext/stub/optimizers/acos.zep.c index 800b71be85..b603b03604 100644 --- a/ext/stub/optimizers/acos.zep.c +++ b/ext/stub/optimizers/acos.zep.c @@ -12,11 +12,10 @@ #include #include "kernel/main.h" -#include "math.h" +#include "kernel/fcall.h" #include "kernel/object.h" -#include "kernel/operators.h" #include "kernel/memory.h" -#include "kernel/math.h" +#include "kernel/operators.h" ZEPHIR_INIT_CLASS(Stub_Optimizers_ACos) { @@ -30,76 +29,117 @@ ZEPHIR_INIT_CLASS(Stub_Optimizers_ACos) { PHP_METHOD(Stub_Optimizers_ACos, testInt) { zval _0; - zend_long a; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS, a; zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); + a = 1; ZVAL_LONG(&_0, a); - RETURN_DOUBLE(acos(a)); + ZEPHIR_RETURN_CALL_FUNCTION("acos", NULL, 13, &_0); + zephir_check_call_status(); + RETURN_MM(); } PHP_METHOD(Stub_Optimizers_ACos, testVar) { zval _0; - zend_long a; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS, a; zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); + a = 1; ZVAL_LONG(&_0, a); - RETURN_DOUBLE(acos(a)); + ZEPHIR_RETURN_CALL_FUNCTION("acos", NULL, 13, &_0); + zephir_check_call_status(); + RETURN_MM(); } PHP_METHOD(Stub_Optimizers_ACos, testIntValue1) { zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); + ZVAL_LONG(&_0, 0); - RETURN_DOUBLE(acos(0)); + ZEPHIR_RETURN_CALL_FUNCTION("acos", NULL, 13, &_0); + zephir_check_call_status(); + RETURN_MM(); } PHP_METHOD(Stub_Optimizers_ACos, testIntParameter) { + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zval *a_param = NULL, _0; - zend_long a; + zend_long a, ZEPHIR_LAST_CALL_STATUS; zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(a) + ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(1, 0, &a_param); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &a_param); a = zephir_get_intval(a_param); ZVAL_LONG(&_0, a); - RETURN_DOUBLE(acos(a)); + ZEPHIR_RETURN_CALL_FUNCTION("acos", NULL, 13, &_0); + zephir_check_call_status(); + RETURN_MM(); } PHP_METHOD(Stub_Optimizers_ACos, testVarParameter) { + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; zval *a, a_sub; zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + - zephir_fetch_params_without_memory_grow(1, 0, &a); + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &a); - RETURN_DOUBLE(zephir_acos(a)); + ZEPHIR_RETURN_CALL_FUNCTION("acos", NULL, 13, a); + zephir_check_call_status(); + RETURN_MM(); } diff --git a/ext/stub/optimizers/acos.zep.h b/ext/stub/optimizers/acos.zep.h index 2494958bb8..b2c9fd88af 100644 --- a/ext/stub/optimizers/acos.zep.h +++ b/ext/stub/optimizers/acos.zep.h @@ -19,11 +19,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_acos_testintvalue1, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_acos_testintparameter, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_acos_testvarparameter, 0, 0, 1) @@ -31,9 +27,21 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_acos_testvarparameter, 0, 0, 1) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_optimizers_acos_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_ACos, testInt, arginfo_stub_optimizers_acos_testint, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_ACos, testInt, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_ACos, testVar, arginfo_stub_optimizers_acos_testvar, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_ACos, testVar, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_ACos, testIntValue1, arginfo_stub_optimizers_acos_testintvalue1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_ACos, testIntValue1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Optimizers_ACos, testIntParameter, arginfo_stub_optimizers_acos_testintparameter, ZEND_ACC_PUBLIC) PHP_ME(Stub_Optimizers_ACos, testVarParameter, arginfo_stub_optimizers_acos_testvarparameter, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/optimizers/arraymerge.zep.c b/ext/stub/optimizers/arraymerge.zep.c index d923428087..b4daac93ce 100644 --- a/ext/stub/optimizers/arraymerge.zep.c +++ b/ext/stub/optimizers/arraymerge.zep.c @@ -35,6 +35,15 @@ PHP_METHOD(Stub_Optimizers_ArrayMerge, mergeTwoRequiredArrays) { ZVAL_UNDEF(&arr1); ZVAL_UNDEF(&arr2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ARRAY(arr1) + Z_PARAM_ARRAY(arr2) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &arr1_param, &arr2_param); diff --git a/ext/stub/optimizers/asin.zep.c b/ext/stub/optimizers/asin.zep.c index cbf226047b..ed325d1296 100644 --- a/ext/stub/optimizers/asin.zep.c +++ b/ext/stub/optimizers/asin.zep.c @@ -12,11 +12,10 @@ #include #include "kernel/main.h" -#include "math.h" +#include "kernel/fcall.h" #include "kernel/object.h" -#include "kernel/operators.h" #include "kernel/memory.h" -#include "kernel/math.h" +#include "kernel/operators.h" ZEPHIR_INIT_CLASS(Stub_Optimizers_ASin) { @@ -30,76 +29,117 @@ ZEPHIR_INIT_CLASS(Stub_Optimizers_ASin) { PHP_METHOD(Stub_Optimizers_ASin, testInt) { zval _0; - zend_long a; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS, a; zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); + a = 1; ZVAL_LONG(&_0, a); - RETURN_DOUBLE(asin(a)); + ZEPHIR_RETURN_CALL_FUNCTION("asin", NULL, 12, &_0); + zephir_check_call_status(); + RETURN_MM(); } PHP_METHOD(Stub_Optimizers_ASin, testVar) { zval _0; - zend_long a; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS, a; zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); + a = 1; ZVAL_LONG(&_0, a); - RETURN_DOUBLE(asin(a)); + ZEPHIR_RETURN_CALL_FUNCTION("asin", NULL, 12, &_0); + zephir_check_call_status(); + RETURN_MM(); } PHP_METHOD(Stub_Optimizers_ASin, testIntValue1) { zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); + ZVAL_LONG(&_0, 0); - RETURN_DOUBLE(asin(0)); + ZEPHIR_RETURN_CALL_FUNCTION("asin", NULL, 12, &_0); + zephir_check_call_status(); + RETURN_MM(); } PHP_METHOD(Stub_Optimizers_ASin, testIntParameter) { + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; zval *a_param = NULL, _0; - zend_long a; + zend_long a, ZEPHIR_LAST_CALL_STATUS; zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(a) + ZEND_PARSE_PARAMETERS_END(); - zephir_fetch_params_without_memory_grow(1, 0, &a_param); +#endif + + + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &a_param); a = zephir_get_intval(a_param); ZVAL_LONG(&_0, a); - RETURN_DOUBLE(asin(a)); + ZEPHIR_RETURN_CALL_FUNCTION("asin", NULL, 12, &_0); + zephir_check_call_status(); + RETURN_MM(); } PHP_METHOD(Stub_Optimizers_ASin, testVarParameter) { + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; zval *a, a_sub; zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + - zephir_fetch_params_without_memory_grow(1, 0, &a); + ZEPHIR_MM_GROW(); + zephir_fetch_params(1, 1, 0, &a); - RETURN_DOUBLE(zephir_asin(a)); + ZEPHIR_RETURN_CALL_FUNCTION("asin", NULL, 12, a); + zephir_check_call_status(); + RETURN_MM(); } diff --git a/ext/stub/optimizers/asin.zep.h b/ext/stub/optimizers/asin.zep.h index cb0798960d..0d005332bb 100644 --- a/ext/stub/optimizers/asin.zep.h +++ b/ext/stub/optimizers/asin.zep.h @@ -19,11 +19,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_asin_testintvalue1, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_asin_testintparameter, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_asin_testvarparameter, 0, 0, 1) @@ -31,9 +27,21 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_asin_testvarparameter, 0, 0, 1) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_optimizers_asin_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_ASin, testInt, arginfo_stub_optimizers_asin_testint, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_ASin, testInt, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_ASin, testVar, arginfo_stub_optimizers_asin_testvar, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_ASin, testVar, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_ASin, testIntValue1, arginfo_stub_optimizers_asin_testintvalue1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_ASin, testIntValue1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Optimizers_ASin, testIntParameter, arginfo_stub_optimizers_asin_testintparameter, ZEND_ACC_PUBLIC) PHP_ME(Stub_Optimizers_ASin, testVarParameter, arginfo_stub_optimizers_asin_testvarparameter, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/optimizers/cos.zep.c b/ext/stub/optimizers/cos.zep.c index fe31791a2b..b3da5ea0f7 100644 --- a/ext/stub/optimizers/cos.zep.c +++ b/ext/stub/optimizers/cos.zep.c @@ -36,6 +36,7 @@ PHP_METHOD(Stub_Optimizers_Cos, testInt) { ZVAL_UNDEF(&_0); + a = 4; ZVAL_LONG(&_0, a); RETURN_DOUBLE(cos(a)); @@ -51,6 +52,7 @@ PHP_METHOD(Stub_Optimizers_Cos, testVar) { ZVAL_UNDEF(&_0); + a = 4; ZVAL_LONG(&_0, a); RETURN_DOUBLE(cos(a)); @@ -65,6 +67,7 @@ PHP_METHOD(Stub_Optimizers_Cos, testIntValue1) { ZVAL_UNDEF(&_0); + ZVAL_LONG(&_0, 4); RETURN_DOUBLE(cos(4)); @@ -78,6 +81,7 @@ PHP_METHOD(Stub_Optimizers_Cos, testIntValue2) { ZVAL_UNDEF(&_0); + ZVAL_LONG(&_0, 16); RETURN_DOUBLE(cos(16)); @@ -90,6 +94,14 @@ PHP_METHOD(Stub_Optimizers_Cos, testIntParameter) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a_param); @@ -107,6 +119,14 @@ PHP_METHOD(Stub_Optimizers_Cos, testVarParameter) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); diff --git a/ext/stub/optimizers/cos.zep.h b/ext/stub/optimizers/cos.zep.h index d16454ae57..f0d22dd5d0 100644 --- a/ext/stub/optimizers/cos.zep.h +++ b/ext/stub/optimizers/cos.zep.h @@ -23,11 +23,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_cos_testintvalue2, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_cos_testintparameter, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_cos_testvarparameter, 0, 0, 1) @@ -35,10 +31,26 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_cos_testvarparameter, 0, 0, 1) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_optimizers_cos_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Cos, testInt, arginfo_stub_optimizers_cos_testint, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Cos, testInt, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Cos, testVar, arginfo_stub_optimizers_cos_testvar, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Cos, testVar, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Cos, testIntValue1, arginfo_stub_optimizers_cos_testintvalue1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Cos, testIntValue1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Cos, testIntValue2, arginfo_stub_optimizers_cos_testintvalue2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Cos, testIntValue2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Optimizers_Cos, testIntParameter, arginfo_stub_optimizers_cos_testintparameter, ZEND_ACC_PUBLIC) PHP_ME(Stub_Optimizers_Cos, testVarParameter, arginfo_stub_optimizers_cos_testvarparameter, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/optimizers/createarray.zep.c b/ext/stub/optimizers/createarray.zep.c index 51e644970f..a0e78d09d9 100644 --- a/ext/stub/optimizers/createarray.zep.c +++ b/ext/stub/optimizers/createarray.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(Stub_Optimizers_CreateArray, createNoSize) { + zephir_create_array(return_value, 0, 1); return; @@ -45,6 +46,14 @@ PHP_METHOD(Stub_Optimizers_CreateArray, createSize) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &n_param); diff --git a/ext/stub/optimizers/createarray.zep.h b/ext/stub/optimizers/createarray.zep.h index 38e1410eac..af6e783edd 100644 --- a/ext/stub/optimizers/createarray.zep.h +++ b/ext/stub/optimizers/createarray.zep.h @@ -10,15 +10,15 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_createarray_createnosize, 0, 0, 0 ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_createarray_createsize, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, n) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_optimizers_createarray_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_CreateArray, createNoSize, arginfo_stub_optimizers_createarray_createnosize, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_CreateArray, createNoSize, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Optimizers_CreateArray, createSize, arginfo_stub_optimizers_createarray_createsize, ZEND_ACC_PUBLIC) PHP_FE_END }; diff --git a/ext/stub/optimizers/isscalar.zep.c b/ext/stub/optimizers/isscalar.zep.c index 55c939319c..f2cc25e22e 100644 --- a/ext/stub/optimizers/isscalar.zep.c +++ b/ext/stub/optimizers/isscalar.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(Stub_Optimizers_IsScalar, testIntVar) { ZVAL_UNDEF(&_0); + a = 1; ZVAL_LONG(&_0, a); RETURN_BOOL(zephir_is_scalar(&_0)); @@ -48,6 +49,7 @@ PHP_METHOD(Stub_Optimizers_IsScalar, testDoubleVar) { ZVAL_UNDEF(&_0); + a = (double) (1); ZVAL_DOUBLE(&_0, a); RETURN_BOOL(zephir_is_scalar(&_0)); @@ -63,6 +65,7 @@ PHP_METHOD(Stub_Optimizers_IsScalar, testBoolVar) { ZVAL_UNDEF(&_0); + a = 1; ZVAL_BOOL(&_0, (a ? 1 : 0)); RETURN_BOOL(zephir_is_scalar(&_0)); @@ -77,6 +80,7 @@ PHP_METHOD(Stub_Optimizers_IsScalar, testStringVar) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -93,6 +97,7 @@ PHP_METHOD(Stub_Optimizers_IsScalar, testEmptyArrayVar) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -110,6 +115,7 @@ PHP_METHOD(Stub_Optimizers_IsScalar, testVar) { ZVAL_UNDEF(&_0); + a = 1; ZVAL_LONG(&_0, a); RETURN_BOOL(zephir_is_scalar(&_0)); @@ -122,6 +128,14 @@ PHP_METHOD(Stub_Optimizers_IsScalar, testVarParameter) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); diff --git a/ext/stub/optimizers/isscalar.zep.h b/ext/stub/optimizers/isscalar.zep.h index e82120fc2e..05d2f6b83f 100644 --- a/ext/stub/optimizers/isscalar.zep.h +++ b/ext/stub/optimizers/isscalar.zep.h @@ -11,53 +11,25 @@ PHP_METHOD(Stub_Optimizers_IsScalar, testEmptyArrayVar); PHP_METHOD(Stub_Optimizers_IsScalar, testVar); PHP_METHOD(Stub_Optimizers_IsScalar, testVarParameter); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testintvar, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testintvar, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testdoublevar, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testdoublevar, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testboolvar, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testboolvar, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_teststringvar, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_teststringvar, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testemptyarrayvar, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testemptyarrayvar, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testvar, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testvar, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testvarparameter, 0, 1, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_optimizers_isscalar_testvarparameter, 0, 1, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_INFO(0, a) ZEND_END_ARG_INFO() diff --git a/ext/stub/optimizers/ldexp.zep.c b/ext/stub/optimizers/ldexp.zep.c index 0dd892cd24..0a255c3562 100644 --- a/ext/stub/optimizers/ldexp.zep.c +++ b/ext/stub/optimizers/ldexp.zep.c @@ -36,6 +36,7 @@ PHP_METHOD(Stub_Optimizers_Ldexp, testInt) { ZVAL_UNDEF(&_1); + x = 2; exponent = 3; ZVAL_LONG(&_0, x); @@ -55,6 +56,7 @@ PHP_METHOD(Stub_Optimizers_Ldexp, testDoubleInt) { ZVAL_UNDEF(&_1); + x = 2.0; exponent = 3; ZVAL_DOUBLE(&_0, x); @@ -73,6 +75,7 @@ PHP_METHOD(Stub_Optimizers_Ldexp, testDouble) { ZVAL_UNDEF(&_1); + x = 2.0; exponent = 3.0; ZVAL_DOUBLE(&_0, x); @@ -91,6 +94,7 @@ PHP_METHOD(Stub_Optimizers_Ldexp, testVar) { ZVAL_UNDEF(&_1); + x = 2; exponent = 3; ZVAL_LONG(&_0, x); @@ -108,6 +112,7 @@ PHP_METHOD(Stub_Optimizers_Ldexp, testIntValue1) { ZVAL_UNDEF(&_1); + ZVAL_LONG(&_0, 2); ZVAL_LONG(&_1, 3); RETURN_DOUBLE(zephir_ldexp(&_0, &_1)); @@ -122,6 +127,15 @@ PHP_METHOD(Stub_Optimizers_Ldexp, testIntParameter) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_LONG(x) + Z_PARAM_LONG(exponent) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &x_param, &exponent_param); @@ -142,6 +156,15 @@ PHP_METHOD(Stub_Optimizers_Ldexp, testVarParameter) { ZVAL_UNDEF(&x_sub); ZVAL_UNDEF(&exponent_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(x) + Z_PARAM_ZVAL(exponent) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &x, &exponent); diff --git a/ext/stub/optimizers/ldexp.zep.h b/ext/stub/optimizers/ldexp.zep.h index 778c5d0c11..a6f5e681a7 100644 --- a/ext/stub/optimizers/ldexp.zep.h +++ b/ext/stub/optimizers/ldexp.zep.h @@ -27,16 +27,8 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_ldexp_testintvalue1, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_ldexp_testintparameter, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, x, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, x) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, exponent, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, exponent) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_ldexp_testvarparameter, 0, 0, 2) @@ -45,11 +37,31 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_ldexp_testvarparameter, 0, 0, 2) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_optimizers_ldexp_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Ldexp, testInt, arginfo_stub_optimizers_ldexp_testint, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Ldexp, testInt, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Ldexp, testDoubleInt, arginfo_stub_optimizers_ldexp_testdoubleint, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Ldexp, testDoubleInt, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Ldexp, testDouble, arginfo_stub_optimizers_ldexp_testdouble, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Ldexp, testDouble, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Ldexp, testVar, arginfo_stub_optimizers_ldexp_testvar, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Ldexp, testVar, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Ldexp, testIntValue1, arginfo_stub_optimizers_ldexp_testintvalue1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Ldexp, testIntValue1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Optimizers_Ldexp, testIntParameter, arginfo_stub_optimizers_ldexp_testintparameter, ZEND_ACC_PUBLIC) PHP_ME(Stub_Optimizers_Ldexp, testVarParameter, arginfo_stub_optimizers_ldexp_testvarparameter, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/optimizers/sin.zep.c b/ext/stub/optimizers/sin.zep.c index 00615a4240..53e94b4f87 100644 --- a/ext/stub/optimizers/sin.zep.c +++ b/ext/stub/optimizers/sin.zep.c @@ -36,6 +36,7 @@ PHP_METHOD(Stub_Optimizers_Sin, testInt) { ZVAL_UNDEF(&_0); + a = 4; ZVAL_LONG(&_0, a); RETURN_DOUBLE(sin(a)); @@ -51,6 +52,7 @@ PHP_METHOD(Stub_Optimizers_Sin, testVar) { ZVAL_UNDEF(&_0); + a = 4; ZVAL_LONG(&_0, a); RETURN_DOUBLE(sin(a)); @@ -65,6 +67,7 @@ PHP_METHOD(Stub_Optimizers_Sin, testIntValue1) { ZVAL_UNDEF(&_0); + ZVAL_LONG(&_0, 4); RETURN_DOUBLE(sin(4)); @@ -78,6 +81,7 @@ PHP_METHOD(Stub_Optimizers_Sin, testIntValue2) { ZVAL_UNDEF(&_0); + ZVAL_LONG(&_0, 16); RETURN_DOUBLE(sin(16)); @@ -90,6 +94,14 @@ PHP_METHOD(Stub_Optimizers_Sin, testIntParameter) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a_param); @@ -107,6 +119,14 @@ PHP_METHOD(Stub_Optimizers_Sin, testVarParameter) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); diff --git a/ext/stub/optimizers/sin.zep.h b/ext/stub/optimizers/sin.zep.h index b0f13bbe37..48216e6c96 100644 --- a/ext/stub/optimizers/sin.zep.h +++ b/ext/stub/optimizers/sin.zep.h @@ -23,11 +23,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_sin_testintvalue2, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_sin_testintparameter, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_sin_testvarparameter, 0, 0, 1) @@ -35,10 +31,26 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_sin_testvarparameter, 0, 0, 1) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_optimizers_sin_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Sin, testInt, arginfo_stub_optimizers_sin_testint, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Sin, testInt, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Sin, testVar, arginfo_stub_optimizers_sin_testvar, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Sin, testVar, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Sin, testIntValue1, arginfo_stub_optimizers_sin_testintvalue1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Sin, testIntValue1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Sin, testIntValue2, arginfo_stub_optimizers_sin_testintvalue2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Sin, testIntValue2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Optimizers_Sin, testIntParameter, arginfo_stub_optimizers_sin_testintparameter, ZEND_ACC_PUBLIC) PHP_ME(Stub_Optimizers_Sin, testVarParameter, arginfo_stub_optimizers_sin_testvarparameter, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/optimizers/sqrt.zep.c b/ext/stub/optimizers/sqrt.zep.c index bf98b18fe3..4c939d1bba 100644 --- a/ext/stub/optimizers/sqrt.zep.c +++ b/ext/stub/optimizers/sqrt.zep.c @@ -36,6 +36,7 @@ PHP_METHOD(Stub_Optimizers_Sqrt, testInt) { ZVAL_UNDEF(&_0); + a = 4; ZVAL_LONG(&_0, a); RETURN_DOUBLE(sqrt(a)); @@ -51,6 +52,7 @@ PHP_METHOD(Stub_Optimizers_Sqrt, testVar) { ZVAL_UNDEF(&_0); + a = 4; ZVAL_LONG(&_0, a); RETURN_DOUBLE(sqrt(a)); @@ -65,6 +67,7 @@ PHP_METHOD(Stub_Optimizers_Sqrt, testIntValue1) { ZVAL_UNDEF(&_0); + ZVAL_LONG(&_0, 4); RETURN_DOUBLE(sqrt(4)); @@ -78,6 +81,7 @@ PHP_METHOD(Stub_Optimizers_Sqrt, testIntValue2) { ZVAL_UNDEF(&_0); + ZVAL_LONG(&_0, 16); RETURN_DOUBLE(sqrt(16)); @@ -90,6 +94,14 @@ PHP_METHOD(Stub_Optimizers_Sqrt, testIntParameter) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a_param); @@ -107,6 +119,14 @@ PHP_METHOD(Stub_Optimizers_Sqrt, testVarParameter) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); diff --git a/ext/stub/optimizers/sqrt.zep.h b/ext/stub/optimizers/sqrt.zep.h index ad7cbd79ee..c4f7fc76e0 100644 --- a/ext/stub/optimizers/sqrt.zep.h +++ b/ext/stub/optimizers/sqrt.zep.h @@ -23,11 +23,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_sqrt_testintvalue2, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_sqrt_testintparameter, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_sqrt_testvarparameter, 0, 0, 1) @@ -35,10 +31,26 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_sqrt_testvarparameter, 0, 0, 1) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_optimizers_sqrt_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Sqrt, testInt, arginfo_stub_optimizers_sqrt_testint, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Sqrt, testInt, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Sqrt, testVar, arginfo_stub_optimizers_sqrt_testvar, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Sqrt, testVar, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Sqrt, testIntValue1, arginfo_stub_optimizers_sqrt_testintvalue1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Sqrt, testIntValue1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Sqrt, testIntValue2, arginfo_stub_optimizers_sqrt_testintvalue2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Sqrt, testIntValue2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Optimizers_Sqrt, testIntParameter, arginfo_stub_optimizers_sqrt_testintparameter, ZEND_ACC_PUBLIC) PHP_ME(Stub_Optimizers_Sqrt, testVarParameter, arginfo_stub_optimizers_sqrt_testvarparameter, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/optimizers/strreplace.zep.c b/ext/stub/optimizers/strreplace.zep.c index 0e715ee19e..e432776f82 100644 --- a/ext/stub/optimizers/strreplace.zep.c +++ b/ext/stub/optimizers/strreplace.zep.c @@ -42,6 +42,7 @@ PHP_METHOD(Stub_Optimizers_StrReplace, issue1055) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_3); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -73,6 +74,7 @@ PHP_METHOD(Stub_Optimizers_StrReplace, issue1087) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&filtered); @@ -125,6 +127,7 @@ PHP_METHOD(Stub_Optimizers_StrReplace, issue732A) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&subject); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&search); @@ -183,6 +186,7 @@ PHP_METHOD(Stub_Optimizers_StrReplace, issue732B) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&subject); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&patterns); @@ -209,7 +213,7 @@ PHP_METHOD(Stub_Optimizers_StrReplace, issue732B) { zephir_array_fast_append(&replacements, &_0); ZEPHIR_INIT_VAR(&subject); ZVAL_STRING(&subject, "The quick brown fox jumped over the lazy dog."); - ZEPHIR_RETURN_CALL_FUNCTION("preg_replace", NULL, 63, &patterns, &replacements, &subject); + ZEPHIR_RETURN_CALL_FUNCTION("preg_replace", NULL, 73, &patterns, &replacements, &subject); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/stub/optimizers/strreplace.zep.h b/ext/stub/optimizers/strreplace.zep.h index 715c09dd64..3ba4c7d920 100644 --- a/ext/stub/optimizers/strreplace.zep.h +++ b/ext/stub/optimizers/strreplace.zep.h @@ -21,9 +21,25 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_strreplace_issue732b, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_optimizers_strreplace_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_StrReplace, issue1055, arginfo_stub_optimizers_strreplace_issue1055, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_StrReplace, issue1055, NULL, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_StrReplace, issue1087, arginfo_stub_optimizers_strreplace_issue1087, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_StrReplace, issue1087, NULL, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_StrReplace, issue732A, arginfo_stub_optimizers_strreplace_issue732a, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_StrReplace, issue732A, NULL, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_StrReplace, issue732B, arginfo_stub_optimizers_strreplace_issue732b, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_StrReplace, issue732B, NULL, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/optimizers/substr.zep.c b/ext/stub/optimizers/substr.zep.c index 1d66c007d4..7f67c95605 100644 --- a/ext/stub/optimizers/substr.zep.c +++ b/ext/stub/optimizers/substr.zep.c @@ -33,6 +33,15 @@ PHP_METHOD(Stub_Optimizers_Substr, testTwoArguments) { ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&start_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(str) + Z_PARAM_ZVAL(start) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &str, &start); @@ -51,6 +60,16 @@ PHP_METHOD(Stub_Optimizers_Substr, testThreeArguments) { ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&start_sub); ZVAL_UNDEF(&offset_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_ZVAL(str) + Z_PARAM_ZVAL(start) + Z_PARAM_ZVAL(offset) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(3, 0, &str, &start, &offset); diff --git a/ext/stub/optimizers/tan.zep.c b/ext/stub/optimizers/tan.zep.c index 84dd90e94b..733fffac8b 100644 --- a/ext/stub/optimizers/tan.zep.c +++ b/ext/stub/optimizers/tan.zep.c @@ -36,6 +36,7 @@ PHP_METHOD(Stub_Optimizers_Tan, testInt) { ZVAL_UNDEF(&_0); + a = 0; ZVAL_LONG(&_0, a); RETURN_DOUBLE(tan(a)); @@ -51,6 +52,7 @@ PHP_METHOD(Stub_Optimizers_Tan, testVar) { ZVAL_UNDEF(&_0); + a = 0; ZVAL_LONG(&_0, a); RETURN_DOUBLE(tan(a)); @@ -66,6 +68,7 @@ PHP_METHOD(Stub_Optimizers_Tan, testVar2) { ZVAL_UNDEF(&_0); + a = 1; ZVAL_LONG(&_0, a); RETURN_DOUBLE(tan(a)); @@ -80,6 +83,7 @@ PHP_METHOD(Stub_Optimizers_Tan, testIntValue1) { ZVAL_UNDEF(&_0); + ZVAL_LONG(&_0, 1); RETURN_DOUBLE(tan(1)); @@ -93,6 +97,7 @@ PHP_METHOD(Stub_Optimizers_Tan, testIntValue2) { ZVAL_UNDEF(&_0); + ZVAL_LONG(&_0, 2); RETURN_DOUBLE(tan(2)); @@ -105,6 +110,14 @@ PHP_METHOD(Stub_Optimizers_Tan, testIntParameter) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a_param); @@ -122,6 +135,14 @@ PHP_METHOD(Stub_Optimizers_Tan, testVarParameter) { zval *this_ptr = getThis(); ZVAL_UNDEF(&a_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &a); diff --git a/ext/stub/optimizers/tan.zep.h b/ext/stub/optimizers/tan.zep.h index 79505289ae..2d1c61c8f2 100644 --- a/ext/stub/optimizers/tan.zep.h +++ b/ext/stub/optimizers/tan.zep.h @@ -27,11 +27,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_tan_testintvalue2, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_tan_testintparameter, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_tan_testvarparameter, 0, 0, 1) @@ -39,11 +35,31 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_optimizers_tan_testvarparameter, 0, 0, 1) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_optimizers_tan_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Tan, testInt, arginfo_stub_optimizers_tan_testint, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Tan, testInt, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Tan, testVar, arginfo_stub_optimizers_tan_testvar, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Tan, testVar, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Tan, testVar2, arginfo_stub_optimizers_tan_testvar2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Tan, testVar2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Tan, testIntValue1, arginfo_stub_optimizers_tan_testintvalue1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Tan, testIntValue1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Optimizers_Tan, testIntValue2, arginfo_stub_optimizers_tan_testintvalue2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Optimizers_Tan, testIntValue2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Optimizers_Tan, testIntParameter, arginfo_stub_optimizers_tan_testintparameter, ZEND_ACC_PUBLIC) PHP_ME(Stub_Optimizers_Tan, testVarParameter, arginfo_stub_optimizers_tan_testvarparameter, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/pregmatch.zep.c b/ext/stub/pregmatch.zep.c index 60f40c45ca..67840748fd 100644 --- a/ext/stub/pregmatch.zep.c +++ b/ext/stub/pregmatch.zep.c @@ -40,6 +40,7 @@ PHP_METHOD(Stub_Pregmatch, testWithoutReturnAndMatches) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&pattern); @@ -66,6 +67,7 @@ PHP_METHOD(Stub_Pregmatch, testWithoutReturns) { ZVAL_UNDEF(&matches); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&matches); @@ -91,6 +93,7 @@ PHP_METHOD(Stub_Pregmatch, testWithoutMatches) { ZVAL_UNDEF(&matched); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&pattern); @@ -114,6 +117,7 @@ PHP_METHOD(Stub_Pregmatch, testPregMatchAll) { ZVAL_UNDEF(&subject); ZVAL_UNDEF(&results); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&pattern); @@ -137,6 +141,7 @@ PHP_METHOD(Stub_Pregmatch, testPregMatchFallback) { ZVAL_UNDEF(&subject); ZVAL_UNDEF(&matches); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&matches); @@ -161,6 +166,15 @@ PHP_METHOD(Stub_Pregmatch, testPregMatch2Params) { ZVAL_UNDEF(&pattern_sub); ZVAL_UNDEF(&subject_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(pattern) + Z_PARAM_ZVAL(subject) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &pattern, &subject); @@ -181,6 +195,16 @@ PHP_METHOD(Stub_Pregmatch, testPregMatch3Params) { ZVAL_UNDEF(&pattern_sub); ZVAL_UNDEF(&subject_sub); ZVAL_UNDEF(&matches_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_ZVAL(pattern) + Z_PARAM_ZVAL(subject) + Z_PARAM_ZVAL(matches) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(3, 0, &pattern, &subject, &matches); @@ -200,6 +224,17 @@ PHP_METHOD(Stub_Pregmatch, testPregMatch4Params) { ZVAL_UNDEF(&subject_sub); ZVAL_UNDEF(&matches_sub); ZVAL_UNDEF(&flags_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(4, 4) + Z_PARAM_ZVAL(pattern) + Z_PARAM_ZVAL(subject) + Z_PARAM_ZVAL(matches) + Z_PARAM_ZVAL(flags) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(4, 0, &pattern, &subject, &matches, &flags); @@ -220,6 +255,18 @@ PHP_METHOD(Stub_Pregmatch, testPregMatch5Params) { ZVAL_UNDEF(&matches_sub); ZVAL_UNDEF(&flags_sub); ZVAL_UNDEF(&offset_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(5, 5) + Z_PARAM_ZVAL(pattern) + Z_PARAM_ZVAL(subject) + Z_PARAM_ZVAL(matches) + Z_PARAM_ZVAL(flags) + Z_PARAM_ZVAL(offset) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(5, 0, &pattern, &subject, &matches, &flags, &offset); @@ -244,6 +291,15 @@ PHP_METHOD(Stub_Pregmatch, testPregMatchSaveMatches) { ZVAL_UNDEF(&pattern); ZVAL_UNDEF(&matches); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(str) + Z_PARAM_STR(pattern) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &str_param, &pattern_param); @@ -272,6 +328,14 @@ PHP_METHOD(Stub_Pregmatch, testMatchAll) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(flags) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &flags); @@ -304,6 +368,7 @@ PHP_METHOD(Stub_Pregmatch, testMatchAllInZep) { ZVAL_UNDEF(&m2); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, 1); diff --git a/ext/stub/pregmatch.zep.h b/ext/stub/pregmatch.zep.h index 0bf0130535..d6f813d60d 100644 --- a/ext/stub/pregmatch.zep.h +++ b/ext/stub/pregmatch.zep.h @@ -58,16 +58,8 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_pregmatch_testpregmatch5params, 0, 0, 5) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_pregmatch_testpregmatchsavematches, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, pattern) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_pregmatch_testmatchall, 0, 0, 1) @@ -78,17 +70,41 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_pregmatch_testmatchallinzep, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_pregmatch_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Pregmatch, testWithoutReturnAndMatches, arginfo_stub_pregmatch_testwithoutreturnandmatches, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Pregmatch, testWithoutReturnAndMatches, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Pregmatch, testWithoutReturns, arginfo_stub_pregmatch_testwithoutreturns, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Pregmatch, testWithoutReturns, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Pregmatch, testWithoutMatches, arginfo_stub_pregmatch_testwithoutmatches, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Pregmatch, testWithoutMatches, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Pregmatch, testPregMatchAll, arginfo_stub_pregmatch_testpregmatchall, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Pregmatch, testPregMatchAll, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Pregmatch, testPregMatchFallback, arginfo_stub_pregmatch_testpregmatchfallback, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Pregmatch, testPregMatchFallback, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Pregmatch, testPregMatch2Params, arginfo_stub_pregmatch_testpregmatch2params, ZEND_ACC_PUBLIC) PHP_ME(Stub_Pregmatch, testPregMatch3Params, arginfo_stub_pregmatch_testpregmatch3params, ZEND_ACC_PUBLIC) PHP_ME(Stub_Pregmatch, testPregMatch4Params, arginfo_stub_pregmatch_testpregmatch4params, ZEND_ACC_PUBLIC) PHP_ME(Stub_Pregmatch, testPregMatch5Params, arginfo_stub_pregmatch_testpregmatch5params, ZEND_ACC_PUBLIC) PHP_ME(Stub_Pregmatch, testPregMatchSaveMatches, arginfo_stub_pregmatch_testpregmatchsavematches, ZEND_ACC_PUBLIC) PHP_ME(Stub_Pregmatch, testMatchAll, arginfo_stub_pregmatch_testmatchall, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Pregmatch, testMatchAllInZep, arginfo_stub_pregmatch_testmatchallinzep, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Pregmatch, testMatchAllInZep, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/properties/app.zep.c b/ext/stub/properties/app.zep.c index e481281dbc..020dce93cb 100644 --- a/ext/stub/properties/app.zep.c +++ b/ext/stub/properties/app.zep.c @@ -35,6 +35,7 @@ PHP_METHOD(Stub_Properties_App, getInstance) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "instance"); } @@ -49,6 +50,7 @@ PHP_METHOD(Stub_Properties_App, __construct) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_CALL_CE_STATIC(&_0, stub_properties_staticprivateproperties_ce, "getinstance", &_1, 0); diff --git a/ext/stub/properties/app.zep.h b/ext/stub/properties/app.zep.h index 92a675a5c5..22e9a1daa2 100644 --- a/ext/stub/properties/app.zep.h +++ b/ext/stub/properties/app.zep.h @@ -13,7 +13,15 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_properties_app___construct, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_properties_app_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_App, getInstance, arginfo_stub_properties_app_getinstance, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_App, getInstance, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_App, __construct, arginfo_stub_properties_app___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#else + PHP_ME(Stub_Properties_App, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#endif PHP_FE_END }; diff --git a/ext/stub/properties/extendspublicproperties.zep.c b/ext/stub/properties/extendspublicproperties.zep.c index 6b148e2fd3..8b5f7702fc 100644 --- a/ext/stub/properties/extendspublicproperties.zep.c +++ b/ext/stub/properties/extendspublicproperties.zep.c @@ -49,6 +49,7 @@ zend_object *zephir_init_properties_Stub_Properties_ExtendsPublicProperties(zend ZVAL_UNDEF(&_4$$4); ZVAL_UNDEF(&_6$$5); ZVAL_UNDEF(&_11$$7); + ZEPHIR_MM_GROW(); diff --git a/ext/stub/properties/privateproperties.zep.c b/ext/stub/properties/privateproperties.zep.c index bd32e24587..7f721b3f05 100644 --- a/ext/stub/properties/privateproperties.zep.c +++ b/ext/stub/properties/privateproperties.zep.c @@ -63,6 +63,7 @@ PHP_METHOD(Stub_Properties_PrivateProperties, getSomeNull) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someNull"); } @@ -72,6 +73,7 @@ PHP_METHOD(Stub_Properties_PrivateProperties, getSomeNullInitial) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someNullInitial"); } @@ -81,6 +83,7 @@ PHP_METHOD(Stub_Properties_PrivateProperties, getSomeFalse) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someFalse"); } @@ -90,6 +93,7 @@ PHP_METHOD(Stub_Properties_PrivateProperties, getSomeTrue) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someTrue"); } @@ -99,6 +103,7 @@ PHP_METHOD(Stub_Properties_PrivateProperties, getSomeInteger) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someInteger"); } @@ -108,6 +113,7 @@ PHP_METHOD(Stub_Properties_PrivateProperties, getSomeDouble) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someDouble"); } @@ -117,6 +123,7 @@ PHP_METHOD(Stub_Properties_PrivateProperties, getSomeString) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someString"); } diff --git a/ext/stub/properties/privateproperties.zep.h b/ext/stub/properties/privateproperties.zep.h index d3797e535a..598523ace7 100644 --- a/ext/stub/properties/privateproperties.zep.h +++ b/ext/stub/properties/privateproperties.zep.h @@ -33,12 +33,40 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_properties_privateproperties_getsomestring, ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_properties_privateproperties_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PrivateProperties, getSomeNull, arginfo_stub_properties_privateproperties_getsomenull, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PrivateProperties, getSomeNull, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PrivateProperties, getSomeNullInitial, arginfo_stub_properties_privateproperties_getsomenullinitial, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PrivateProperties, getSomeNullInitial, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PrivateProperties, getSomeFalse, arginfo_stub_properties_privateproperties_getsomefalse, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PrivateProperties, getSomeFalse, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PrivateProperties, getSomeTrue, arginfo_stub_properties_privateproperties_getsometrue, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PrivateProperties, getSomeTrue, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PrivateProperties, getSomeInteger, arginfo_stub_properties_privateproperties_getsomeinteger, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PrivateProperties, getSomeInteger, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PrivateProperties, getSomeDouble, arginfo_stub_properties_privateproperties_getsomedouble, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PrivateProperties, getSomeDouble, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PrivateProperties, getSomeString, arginfo_stub_properties_privateproperties_getsomestring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PrivateProperties, getSomeString, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/properties/propertyarray.zep.c b/ext/stub/properties/propertyarray.zep.c index 1beb4e86a0..a37fbf6f65 100644 --- a/ext/stub/properties/propertyarray.zep.c +++ b/ext/stub/properties/propertyarray.zep.c @@ -56,6 +56,7 @@ PHP_METHOD(Stub_Properties_PropertyArray, __construct) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -77,6 +78,14 @@ PHP_METHOD(Stub_Properties_PropertyArray, appendSome) { ZVAL_UNDEF(&value_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &value); @@ -95,6 +104,14 @@ PHP_METHOD(Stub_Properties_PropertyArray, setOtherArray) { zval *this_ptr = getThis(); ZVAL_UNDEF(&arr_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(arr) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &arr); @@ -109,6 +126,7 @@ PHP_METHOD(Stub_Properties_PropertyArray, getOtherArray) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "otherArray"); } @@ -128,6 +146,7 @@ PHP_METHOD(Stub_Properties_PropertyArray, testIssues1831) { ZVAL_UNDEF(&_3$$3); ZVAL_UNDEF(&_5$$5); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&headers); @@ -138,12 +157,12 @@ PHP_METHOD(Stub_Properties_PropertyArray, testIssues1831) { } zephir_read_property(&_0$$3, this_ptr, ZEND_STRL("otherArray"), PH_NOISY_CC | PH_READONLY); ZEPHIR_MAKE_REF(&_0$$3); - ZEPHIR_CALL_FUNCTION(&info, "array_shift", &_1, 64, &_0$$3); + ZEPHIR_CALL_FUNCTION(&info, "array_shift", &_1, 74, &_0$$3); ZEPHIR_UNREF(&_0$$3); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_2$$3); ZVAL_STRING(&_2$$3, "header"); - ZEPHIR_CALL_FUNCTION(&_3$$3, "stripos", &_4, 65, &info, &_2$$3); + ZEPHIR_CALL_FUNCTION(&_3$$3, "stripos", &_4, 75, &info, &_2$$3); zephir_check_call_status(); if (!ZEPHIR_IS_FALSE_IDENTICAL(&_3$$3)) { zephir_array_append(&headers, &info, PH_SEPARATE, "stub/properties/propertyarray.zep", 51); @@ -151,7 +170,7 @@ PHP_METHOD(Stub_Properties_PropertyArray, testIssues1831) { } else { zephir_read_property(&_5$$5, this_ptr, ZEND_STRL("otherArray"), PH_NOISY_CC | PH_READONLY); ZEPHIR_MAKE_REF(&_5$$5); - ZEPHIR_CALL_FUNCTION(NULL, "array_unshift", &_6, 66, &_5$$5, &info); + ZEPHIR_CALL_FUNCTION(NULL, "array_unshift", &_6, 76, &_5$$5, &info); ZEPHIR_UNREF(&_5$$5); zephir_check_call_status(); break; @@ -173,6 +192,7 @@ zend_object *zephir_init_properties_Stub_Properties_PropertyArray(zend_class_ent ZVAL_UNDEF(&_4$$4); ZVAL_UNDEF(&_6$$5); ZVAL_UNDEF(&_3$$4); + ZEPHIR_MM_GROW(); diff --git a/ext/stub/properties/propertyarray.zep.h b/ext/stub/properties/propertyarray.zep.h index 1e48c56314..652ea134aa 100644 --- a/ext/stub/properties/propertyarray.zep.h +++ b/ext/stub/properties/propertyarray.zep.h @@ -31,10 +31,22 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_properties_propertyarray_zephir_init_propert ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_properties_propertyarray_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PropertyArray, __construct, arginfo_stub_properties_propertyarray___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#else + PHP_ME(Stub_Properties_PropertyArray, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#endif PHP_ME(Stub_Properties_PropertyArray, appendSome, arginfo_stub_properties_propertyarray_appendsome, ZEND_ACC_PUBLIC) PHP_ME(Stub_Properties_PropertyArray, setOtherArray, arginfo_stub_properties_propertyarray_setotherarray, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PropertyArray, getOtherArray, arginfo_stub_properties_propertyarray_getotherarray, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PropertyArray, getOtherArray, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PropertyArray, testIssues1831, arginfo_stub_properties_propertyarray_testissues1831, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PropertyArray, testIssues1831, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/properties/propertyupdate.zep.c b/ext/stub/properties/propertyupdate.zep.c index 20a467b89a..a4cf986117 100644 --- a/ext/stub/properties/propertyupdate.zep.c +++ b/ext/stub/properties/propertyupdate.zep.c @@ -34,6 +34,7 @@ PHP_METHOD(Stub_Properties_PropertyUpdate, update1) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_ZVAL_NREF(_0); diff --git a/ext/stub/properties/propertyupdate.zep.h b/ext/stub/properties/propertyupdate.zep.h index 6eeb1ed247..3c4d182696 100644 --- a/ext/stub/properties/propertyupdate.zep.h +++ b/ext/stub/properties/propertyupdate.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_properties_propertyupdate_update1, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_properties_propertyupdate_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PropertyUpdate, update1, arginfo_stub_properties_propertyupdate_update1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PropertyUpdate, update1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/properties/protectedproperties.zep.c b/ext/stub/properties/protectedproperties.zep.c index 461318af20..31e5307e7f 100644 --- a/ext/stub/properties/protectedproperties.zep.c +++ b/ext/stub/properties/protectedproperties.zep.c @@ -83,6 +83,14 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, setSomeVar) { zval *this_ptr = getThis(); ZVAL_UNDEF(&someVar_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(someVar) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &someVar); @@ -100,6 +108,7 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, getSomeVar) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someVar"); } @@ -115,6 +124,14 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, setSomeArrayVar) { zval *this_ptr = getThis(); ZVAL_UNDEF(&someArrayVar); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(someArrayVar) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &someArrayVar_param); @@ -135,6 +152,7 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, getSomeArrayVar) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someArrayVar"); } @@ -147,6 +165,7 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, getSomeNull) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someNull"); } @@ -160,6 +179,14 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, setSomeNull) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, ¶m); @@ -177,6 +204,7 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, getSomeNullInitial) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someNullInitial"); } @@ -189,6 +217,7 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, getSomeFalse) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someFalse"); } @@ -201,6 +230,7 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, getSomeTrue) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someTrue"); } @@ -213,6 +243,7 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, getSomeInteger) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someInteger"); } @@ -225,6 +256,7 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, getSomeDouble) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someDouble"); } @@ -237,6 +269,7 @@ PHP_METHOD(Stub_Properties_ProtectedProperties, getSomeString) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someString"); } @@ -247,6 +280,7 @@ zend_object *zephir_init_properties_Stub_Properties_ProtectedProperties(zend_cla zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1$$3); + ZEPHIR_MM_GROW(); diff --git a/ext/stub/properties/protectedproperties.zep.h b/ext/stub/properties/protectedproperties.zep.h index 4095bde7f0..7d18ddeec3 100644 --- a/ext/stub/properties/protectedproperties.zep.h +++ b/ext/stub/properties/protectedproperties.zep.h @@ -28,11 +28,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_properties_protectedproperties_setsomearrayv ZEND_ARG_ARRAY_INFO(0, someArrayVar, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_properties_protectedproperties_getsomearrayvar, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_properties_protectedproperties_getsomearrayvar, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_properties_protectedproperties_getsomenull, 0, 0, 0) @@ -65,16 +61,48 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_properties_protectedproperties_method_entry) { PHP_ME(Stub_Properties_ProtectedProperties, setSomeVar, arginfo_stub_properties_protectedproperties_setsomevar, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_ProtectedProperties, getSomeVar, arginfo_stub_properties_protectedproperties_getsomevar, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_ProtectedProperties, getSomeVar, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Properties_ProtectedProperties, setSomeArrayVar, arginfo_stub_properties_protectedproperties_setsomearrayvar, ZEND_ACC_PUBLIC) PHP_ME(Stub_Properties_ProtectedProperties, getSomeArrayVar, arginfo_stub_properties_protectedproperties_getsomearrayvar, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_ProtectedProperties, getSomeNull, arginfo_stub_properties_protectedproperties_getsomenull, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_ProtectedProperties, getSomeNull, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Properties_ProtectedProperties, setSomeNull, arginfo_stub_properties_protectedproperties_setsomenull, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_ProtectedProperties, getSomeNullInitial, arginfo_stub_properties_protectedproperties_getsomenullinitial, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_ProtectedProperties, getSomeNullInitial, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_ProtectedProperties, getSomeFalse, arginfo_stub_properties_protectedproperties_getsomefalse, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_ProtectedProperties, getSomeFalse, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_ProtectedProperties, getSomeTrue, arginfo_stub_properties_protectedproperties_getsometrue, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_ProtectedProperties, getSomeTrue, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_ProtectedProperties, getSomeInteger, arginfo_stub_properties_protectedproperties_getsomeinteger, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_ProtectedProperties, getSomeInteger, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_ProtectedProperties, getSomeDouble, arginfo_stub_properties_protectedproperties_getsomedouble, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_ProtectedProperties, getSomeDouble, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_ProtectedProperties, getSomeString, arginfo_stub_properties_protectedproperties_getsomestring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_ProtectedProperties, getSomeString, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/properties/publicproperties.zep.c b/ext/stub/properties/publicproperties.zep.c index 93729aab9a..919d567de2 100644 --- a/ext/stub/properties/publicproperties.zep.c +++ b/ext/stub/properties/publicproperties.zep.c @@ -98,6 +98,14 @@ PHP_METHOD(Stub_Properties_PublicProperties, setSomeGetterSetterArray) { zval *this_ptr = getThis(); ZVAL_UNDEF(&someGetterSetterArray_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(someGetterSetterArray) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &someGetterSetterArray); @@ -113,6 +121,7 @@ PHP_METHOD(Stub_Properties_PublicProperties, getSomeGetterSetterArray) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someGetterSetterArray"); } @@ -125,6 +134,7 @@ PHP_METHOD(Stub_Properties_PublicProperties, test394Issue) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(&_0); @@ -150,6 +160,7 @@ zend_object *zephir_init_properties_Stub_Properties_PublicProperties(zend_class_ ZVAL_UNDEF(&_4$$4); ZVAL_UNDEF(&_6$$5); ZVAL_UNDEF(&_8$$6); + ZEPHIR_MM_GROW(); diff --git a/ext/stub/properties/publicproperties.zep.h b/ext/stub/properties/publicproperties.zep.h index bea89b626f..59b09e0ffd 100644 --- a/ext/stub/properties/publicproperties.zep.h +++ b/ext/stub/properties/publicproperties.zep.h @@ -23,7 +23,15 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_properties_publicproperties_method_entry) { PHP_ME(Stub_Properties_PublicProperties, setSomeGetterSetterArray, arginfo_stub_properties_publicproperties_setsomegettersetterarray, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PublicProperties, getSomeGetterSetterArray, arginfo_stub_properties_publicproperties_getsomegettersetterarray, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PublicProperties, getSomeGetterSetterArray, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_PublicProperties, test394Issue, arginfo_stub_properties_publicproperties_test394issue, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_PublicProperties, test394Issue, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/properties/staticprivateproperties.zep.c b/ext/stub/properties/staticprivateproperties.zep.c index 2f593f2920..4f73eb9c6c 100644 --- a/ext/stub/properties/staticprivateproperties.zep.c +++ b/ext/stub/properties/staticprivateproperties.zep.c @@ -37,6 +37,7 @@ PHP_METHOD(Stub_Properties_StaticPrivateProperties, getInstance) { ZVAL_UNDEF(&localInstance); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_OBS_VAR(&localInstance); diff --git a/ext/stub/properties/staticprivateproperties.zep.h b/ext/stub/properties/staticprivateproperties.zep.h index c3b83278e3..a0643019c3 100644 --- a/ext/stub/properties/staticprivateproperties.zep.h +++ b/ext/stub/properties/staticprivateproperties.zep.h @@ -5,11 +5,7 @@ ZEPHIR_INIT_CLASS(Stub_Properties_StaticPrivateProperties); PHP_METHOD(Stub_Properties_StaticPrivateProperties, getInstance); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_properties_staticprivateproperties_getinstance, 0, 0, Stub\\Properties\\StaticPrivateProperties, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_properties_staticprivateproperties_getinstance, 0, 0, IS_OBJECT, "Stub\\Properties\\StaticPrivateProperties", 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_properties_staticprivateproperties_method_entry) { diff --git a/ext/stub/properties/staticpropertyarray.zep.c b/ext/stub/properties/staticpropertyarray.zep.c index 310c1cbb14..3818923068 100644 --- a/ext/stub/properties/staticpropertyarray.zep.c +++ b/ext/stub/properties/staticpropertyarray.zep.c @@ -47,6 +47,7 @@ void zephir_init_static_properties_Stub_Properties_StaticPropertyArray() { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); diff --git a/ext/stub/properties/staticprotectedproperties.zep.c b/ext/stub/properties/staticprotectedproperties.zep.c index 4ec925b52f..72a8b6a2a4 100644 --- a/ext/stub/properties/staticprotectedproperties.zep.c +++ b/ext/stub/properties/staticprotectedproperties.zep.c @@ -67,6 +67,14 @@ PHP_METHOD(Stub_Properties_StaticProtectedProperties, setSomeVar) { zval *this_ptr = getThis(); ZVAL_UNDEF(&someVar_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(someVar) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &someVar); @@ -82,6 +90,7 @@ PHP_METHOD(Stub_Properties_StaticProtectedProperties, getSomeVar) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "someVar"); } @@ -94,6 +103,7 @@ PHP_METHOD(Stub_Properties_StaticProtectedProperties, getSomeNull) { ZVAL_UNDEF(&_0); + zephir_read_static_property_ce(&_0, stub_properties_staticprotectedproperties_ce, SL("someNull"), PH_NOISY_CC | PH_READONLY); RETURN_CTORW(&_0); @@ -105,6 +115,14 @@ PHP_METHOD(Stub_Properties_StaticProtectedProperties, setSomeNull) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶m_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(param) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, ¶m); @@ -122,6 +140,7 @@ PHP_METHOD(Stub_Properties_StaticProtectedProperties, getSomeNullInitial) { ZVAL_UNDEF(&_0); + zephir_read_static_property_ce(&_0, stub_properties_staticprotectedproperties_ce, SL("someNullInitial"), PH_NOISY_CC | PH_READONLY); RETURN_CTORW(&_0); @@ -135,6 +154,7 @@ PHP_METHOD(Stub_Properties_StaticProtectedProperties, getSomeFalse) { ZVAL_UNDEF(&_0); + zephir_read_static_property_ce(&_0, stub_properties_staticprotectedproperties_ce, SL("someFalse"), PH_NOISY_CC | PH_READONLY); RETURN_CTORW(&_0); @@ -148,6 +168,7 @@ PHP_METHOD(Stub_Properties_StaticProtectedProperties, getSomeTrue) { ZVAL_UNDEF(&_0); + zephir_read_static_property_ce(&_0, stub_properties_staticprotectedproperties_ce, SL("someTrue"), PH_NOISY_CC | PH_READONLY); RETURN_CTORW(&_0); @@ -161,6 +182,7 @@ PHP_METHOD(Stub_Properties_StaticProtectedProperties, getSomeInteger) { ZVAL_UNDEF(&_0); + zephir_read_static_property_ce(&_0, stub_properties_staticprotectedproperties_ce, SL("someInteger"), PH_NOISY_CC | PH_READONLY); RETURN_CTORW(&_0); @@ -174,6 +196,7 @@ PHP_METHOD(Stub_Properties_StaticProtectedProperties, getSomeDouble) { ZVAL_UNDEF(&_0); + zephir_read_static_property_ce(&_0, stub_properties_staticprotectedproperties_ce, SL("someDouble"), PH_NOISY_CC | PH_READONLY); RETURN_CTORW(&_0); @@ -187,6 +210,7 @@ PHP_METHOD(Stub_Properties_StaticProtectedProperties, getSomeString) { ZVAL_UNDEF(&_0); + zephir_read_static_property_ce(&_0, stub_properties_staticprotectedproperties_ce, SL("someString"), PH_NOISY_CC | PH_READONLY); RETURN_CTORW(&_0); diff --git a/ext/stub/properties/staticprotectedproperties.zep.h b/ext/stub/properties/staticprotectedproperties.zep.h index b3622470b2..4007af9a35 100644 --- a/ext/stub/properties/staticprotectedproperties.zep.h +++ b/ext/stub/properties/staticprotectedproperties.zep.h @@ -48,14 +48,46 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_properties_staticprotectedproperties_method_entry) { PHP_ME(Stub_Properties_StaticProtectedProperties, setSomeVar, arginfo_stub_properties_staticprotectedproperties_setsomevar, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeVar, arginfo_stub_properties_staticprotectedproperties_getsomevar, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeVar, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeNull, arginfo_stub_properties_staticprotectedproperties_getsomenull, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeNull, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif PHP_ME(Stub_Properties_StaticProtectedProperties, setSomeNull, arginfo_stub_properties_staticprotectedproperties_setsomenull, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeNullInitial, arginfo_stub_properties_staticprotectedproperties_getsomenullinitial, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeNullInitial, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeFalse, arginfo_stub_properties_staticprotectedproperties_getsomefalse, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeFalse, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeTrue, arginfo_stub_properties_staticprotectedproperties_getsometrue, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeTrue, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeInteger, arginfo_stub_properties_staticprotectedproperties_getsomeinteger, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeInteger, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeDouble, arginfo_stub_properties_staticprotectedproperties_getsomedouble, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeDouble, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeString, arginfo_stub_properties_staticprotectedproperties_getsomestring, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticProtectedProperties, getSomeString, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif PHP_FE_END }; diff --git a/ext/stub/properties/staticpublicproperties.zep.c b/ext/stub/properties/staticpublicproperties.zep.c index 057ac928b2..d377de479c 100644 --- a/ext/stub/properties/staticpublicproperties.zep.c +++ b/ext/stub/properties/staticpublicproperties.zep.c @@ -69,6 +69,14 @@ PHP_METHOD(Stub_Properties_StaticPublicProperties, setSomeString) { zval *this_ptr = getThis(); ZVAL_UNDEF(&val_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(val) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &val); @@ -86,6 +94,7 @@ PHP_METHOD(Stub_Properties_StaticPublicProperties, testAddAndSub) { ZVAL_UNDEF(&_0); + ZEPHIR_INIT_ZVAL_NREF(_0); ZVAL_LONG(&_0, 1); zephir_add_static_property_ce(stub_properties_staticpublicproperties_ce, ZEND_STRL("someAdd"), &_0); @@ -103,6 +112,7 @@ PHP_METHOD(Stub_Properties_StaticPublicProperties, testAddAndSub2) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -125,6 +135,7 @@ PHP_METHOD(Stub_Properties_StaticPublicProperties, testAddAndSub3) { ZVAL_UNDEF(&_0); + ZEPHIR_INIT_ZVAL_NREF(_0); ZVAL_DOUBLE(&_0, 1.0); zephir_add_static_property_ce(stub_properties_staticpublicproperties_ce, ZEND_STRL("someAdd"), &_0); @@ -143,6 +154,7 @@ PHP_METHOD(Stub_Properties_StaticPublicProperties, testAddAndSub4) { ZVAL_UNDEF(&_0); + v = 1; ZEPHIR_INIT_ZVAL_NREF(_0); ZVAL_LONG(&_0, v); @@ -161,6 +173,7 @@ PHP_METHOD(Stub_Properties_StaticPublicProperties, testAddAndSub5) { ZVAL_UNDEF(&v); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&v); diff --git a/ext/stub/properties/staticpublicproperties.zep.h b/ext/stub/properties/staticpublicproperties.zep.h index 7a163b8d09..446af459fb 100644 --- a/ext/stub/properties/staticpublicproperties.zep.h +++ b/ext/stub/properties/staticpublicproperties.zep.h @@ -31,10 +31,30 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_properties_staticpublicproperties_method_entry) { PHP_ME(Stub_Properties_StaticPublicProperties, setSomeString, arginfo_stub_properties_staticpublicproperties_setsomestring, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticPublicProperties, testAddAndSub, arginfo_stub_properties_staticpublicproperties_testaddandsub, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticPublicProperties, testAddAndSub, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticPublicProperties, testAddAndSub2, arginfo_stub_properties_staticpublicproperties_testaddandsub2, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticPublicProperties, testAddAndSub2, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticPublicProperties, testAddAndSub3, arginfo_stub_properties_staticpublicproperties_testaddandsub3, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticPublicProperties, testAddAndSub3, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticPublicProperties, testAddAndSub4, arginfo_stub_properties_staticpublicproperties_testaddandsub4, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticPublicProperties, testAddAndSub4, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Properties_StaticPublicProperties, testAddAndSub5, arginfo_stub_properties_staticpublicproperties_testaddandsub5, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Properties_StaticPublicProperties, testAddAndSub5, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif PHP_FE_END }; diff --git a/ext/stub/quantum.zep.c b/ext/stub/quantum.zep.c index afdfda1197..c96c04d5d4 100644 --- a/ext/stub/quantum.zep.c +++ b/ext/stub/quantum.zep.c @@ -98,6 +98,14 @@ PHP_METHOD(Stub_Quantum, harmos) { ZVAL_UNDEF(&_8$$4); ZVAL_UNDEF(&_10$$4); ZVAL_UNDEF(&_11$$4); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(x) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &x_param); @@ -135,7 +143,7 @@ PHP_METHOD(Stub_Quantum, harmos) { ZVAL_STRING(&_0, "harmos.txt"); ZEPHIR_INIT_VAR(&_1); ZVAL_STRING(&_1, "w"); - ZEPHIR_CALL_FUNCTION(&fp, "fopen", NULL, 29, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&fp, "fopen", NULL, 31, &_0, &_1); zephir_check_call_status(); if (!(zephir_is_true(&fp))) { RETURN_MM_LONG(1); @@ -340,13 +348,13 @@ PHP_METHOD(Stub_Quantum, harmos) { ZVAL_STRING(&_52$$9, "%16.8lf %16.8lf %16.8lf \n"); ZVAL_DOUBLE(&_53$$9, ((double) i * dx)); ZVAL_DOUBLE(&_54$$9, ((double) n * dt)); - ZEPHIR_CALL_FUNCTION(NULL, "fprintf", &_55, 67, &fp, &_52$$9, &_53$$9, &_54$$9, &_51$$9); + ZEPHIR_CALL_FUNCTION(NULL, "fprintf", &_55, 77, &fp, &_52$$9, &_53$$9, &_54$$9, &_51$$9); zephir_check_call_status(); i = (i + 10); } ZEPHIR_INIT_NVAR(&_56$$8); ZVAL_STRING(&_56$$8, "\n"); - ZEPHIR_CALL_FUNCTION(NULL, "fprintf", &_55, 67, &fp, &_56$$8); + ZEPHIR_CALL_FUNCTION(NULL, "fprintf", &_55, 77, &fp, &_56$$8); zephir_check_call_status(); } j = 1; diff --git a/ext/stub/quantum.zep.h b/ext/stub/quantum.zep.h index 23c054e174..aa13dedea3 100644 --- a/ext/stub/quantum.zep.h +++ b/ext/stub/quantum.zep.h @@ -6,11 +6,7 @@ ZEPHIR_INIT_CLASS(Stub_Quantum); PHP_METHOD(Stub_Quantum, harmos); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_quantum_harmos, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, x, IS_DOUBLE, 0) -#else - ZEND_ARG_INFO(0, x) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_quantum_method_entry) { diff --git a/ext/stub/range.zep.c b/ext/stub/range.zep.c index e298263057..8da5daf375 100644 --- a/ext/stub/range.zep.c +++ b/ext/stub/range.zep.c @@ -42,11 +42,12 @@ PHP_METHOD(Stub_Range, inclusive1) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); + ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, 10); - ZEPHIR_CALL_FUNCTION(&_2, "range", NULL, 68, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&_2, "range", NULL, 78, &_0, &_1); zephir_check_call_status(); zephir_get_arrval(&_3, &_2); RETURN_CTOR(&_3); @@ -66,11 +67,12 @@ PHP_METHOD(Stub_Range, exclusive1) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); + ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, 0); ZVAL_LONG(&_1, 10); - ZEPHIR_CALL_FUNCTION(&_2, "range", NULL, 68, &_0, &_1); + ZEPHIR_CALL_FUNCTION(&_2, "range", NULL, 78, &_0, &_1); zephir_check_call_status(); zephir_get_arrval(&_3, &_2); RETURN_CTOR(&_3); diff --git a/ext/stub/range.zep.h b/ext/stub/range.zep.h index f0a21e3d62..7fdad5e842 100644 --- a/ext/stub/range.zep.h +++ b/ext/stub/range.zep.h @@ -13,7 +13,15 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_range_exclusive1, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_range_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Range, inclusive1, arginfo_stub_range_inclusive1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Range, inclusive1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Range, exclusive1, arginfo_stub_range_exclusive1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Range, exclusive1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/references.zep.c b/ext/stub/references.zep.c index 58e8a3198f..5ca68c66c4 100644 --- a/ext/stub/references.zep.c +++ b/ext/stub/references.zep.c @@ -29,5 +29,6 @@ PHP_METHOD(Stub_References, assignByRef) { + } diff --git a/ext/stub/references.zep.h b/ext/stub/references.zep.h index 488d21cdd8..b4c5d4d063 100644 --- a/ext/stub/references.zep.h +++ b/ext/stub/references.zep.h @@ -9,6 +9,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_references_assignbyref, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_references_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_References, assignByRef, arginfo_stub_references_assignbyref, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_References, assignByRef, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/regexdna.zep.c b/ext/stub/regexdna.zep.c index df1d90c4ed..dd2e1610b6 100644 --- a/ext/stub/regexdna.zep.c +++ b/ext/stub/regexdna.zep.c @@ -60,6 +60,14 @@ PHP_METHOD(Stub_RegexDNA, process) { ZVAL_UNDEF(&_7$$3); ZVAL_UNDEF(&_8$$4); ZVAL_UNDEF(&_9$$4); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(path) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &path); @@ -179,7 +187,7 @@ PHP_METHOD(Stub_RegexDNA, process) { ZEPHIR_CONCAT_SVS(&_1, "/", &stuffToRemove, "/mS"); ZEPHIR_INIT_NVAR(&_0); ZVAL_STRING(&_0, ""); - ZEPHIR_CALL_FUNCTION(&_2, "preg_replace", &_3, 63, &_1, &_0, &contents); + ZEPHIR_CALL_FUNCTION(&_2, "preg_replace", &_3, 73, &_1, &_0, &contents); zephir_check_call_status(); ZEPHIR_CPY_WRT(&contents, &_2); ZEPHIR_INIT_VAR(&codeLength); @@ -223,7 +231,7 @@ PHP_METHOD(Stub_RegexDNA, process) { } } ZEPHIR_INIT_NVAR(®ex); - ZEPHIR_CALL_FUNCTION(&_2, "preg_replace", &_3, 63, &vIUB, &vIUBnew, &contents); + ZEPHIR_CALL_FUNCTION(&_2, "preg_replace", &_3, 73, &vIUB, &vIUBnew, &contents); zephir_check_call_status(); ZEPHIR_CPY_WRT(&contents, &_2); php_printf("%c", '\n'); diff --git a/ext/stub/requires.zep.c b/ext/stub/requires.zep.c index fae4358c78..3481aabf5f 100644 --- a/ext/stub/requires.zep.c +++ b/ext/stub/requires.zep.c @@ -39,6 +39,14 @@ PHP_METHOD(Stub_Requires, requireExternal1) { ZVAL_UNDEF(&path_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(path) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &path); @@ -59,6 +67,14 @@ PHP_METHOD(Stub_Requires, requireExternal2) { zval *this_ptr = getThis(); ZVAL_UNDEF(&path_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(path) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &path); @@ -81,6 +97,14 @@ PHP_METHOD(Stub_Requires, requireExternal3) { ZVAL_UNDEF(&path_sub); ZVAL_UNDEF(&external3); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(path) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &path); @@ -96,7 +120,7 @@ PHP_METHOD(Stub_Requires, requireExternal3) { ZEPHIR_CALL_METHOD(NULL, &external3, "__construct", NULL, 0); zephir_check_call_status(); } - ZEPHIR_CALL_METHOD(NULL, &external3, "req", NULL, 69, path, this_ptr); + ZEPHIR_CALL_METHOD(NULL, &external3, "req", NULL, 79, path, this_ptr); zephir_check_call_status(); RETURN_MM_MEMBER(getThis(), "content"); @@ -108,6 +132,14 @@ PHP_METHOD(Stub_Requires, setContent) { zval *this_ptr = getThis(); ZVAL_UNDEF(&content_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(content) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &content); @@ -136,6 +168,15 @@ PHP_METHOD(Stub_Requires, renderTemplate) { ZVAL_UNDEF(&_2$$3); ZVAL_UNDEF(&_5$$4); ZVAL_UNDEF(&_6$$5); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_STR(templatePath) + Z_PARAM_ZVAL(params) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &templatePath_param, ¶ms); diff --git a/ext/stub/requires.zep.h b/ext/stub/requires.zep.h index 871ec1f71e..8c5c955937 100644 --- a/ext/stub/requires.zep.h +++ b/ext/stub/requires.zep.h @@ -21,26 +21,13 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_requires_requireexternal3, 0, 0, 1) ZEND_ARG_INFO(0, path) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_requires_setcontent, 0, 1, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_requires_setcontent, 0, 1, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_requires_setcontent, 0, 0, 1) -#define arginfo_stub_requires_setcontent NULL -#endif ZEND_ARG_INFO(0, content) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_requires_rendertemplate, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, templatePath, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, templatePath) -#endif ZEND_ARG_INFO(0, params) ZEND_END_ARG_INFO() diff --git a/ext/stub/requires/external3.zep.c b/ext/stub/requires/external3.zep.c index 64392c1418..499290e16e 100644 --- a/ext/stub/requires/external3.zep.c +++ b/ext/stub/requires/external3.zep.c @@ -41,18 +41,27 @@ PHP_METHOD(Stub_Requires_External3, req) { ZVAL_UNDEF(&path_sub); ZVAL_UNDEF(&requires_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(path) + Z_PARAM_ZVAL(requires) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &path, &requires); - ZEPHIR_CALL_FUNCTION(NULL, "ob_clean", NULL, 70); + ZEPHIR_CALL_FUNCTION(NULL, "ob_clean", NULL, 80); zephir_check_call_status(); if (zephir_require_zval(path) == FAILURE) { RETURN_MM_NULL(); } - ZEPHIR_CALL_FUNCTION(&_0, "ob_get_contents", NULL, 71); + ZEPHIR_CALL_FUNCTION(&_0, "ob_get_contents", NULL, 81); zephir_check_call_status(); ZEPHIR_CALL_METHOD(NULL, requires, "setcontent", NULL, 0, &_0); zephir_check_call_status(); diff --git a/ext/stub/requires/external3.zep.h b/ext/stub/requires/external3.zep.h index 6221f2ab71..7bd936ea68 100644 --- a/ext/stub/requires/external3.zep.h +++ b/ext/stub/requires/external3.zep.h @@ -5,16 +5,7 @@ ZEPHIR_INIT_CLASS(Stub_Requires_External3); PHP_METHOD(Stub_Requires_External3, req); -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_requires_external3_req, 0, 2, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_requires_external3_req, 0, 2, IS_VOID, NULL, 0) -#endif -#else -ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_requires_external3_req, 0, 0, 2) -#define arginfo_stub_requires_external3_req NULL -#endif ZEND_ARG_INFO(0, path) ZEND_ARG_INFO(0, requires) diff --git a/ext/stub/resourcetest.zep.c b/ext/stub/resourcetest.zep.c index cc5ce5e8b2..f3cce89d32 100644 --- a/ext/stub/resourcetest.zep.c +++ b/ext/stub/resourcetest.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(Stub_ResourceTest, testLetStatementSTDIN) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -49,6 +50,7 @@ PHP_METHOD(Stub_ResourceTest, testLetStatementSTDOUT) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -65,6 +67,7 @@ PHP_METHOD(Stub_ResourceTest, testLetStatementSTDERR) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -82,6 +85,7 @@ PHP_METHOD(Stub_ResourceTest, testTypeOffResource) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -100,6 +104,7 @@ PHP_METHOD(Stub_ResourceTest, testIsResource) { ZVAL_UNDEF(&a); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -118,12 +123,13 @@ PHP_METHOD(Stub_ResourceTest, testFunctionsForSTDIN) { ZVAL_UNDEF(&a); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); ZEPHIR_GET_CONSTANT(&a, "STDIN"); ZVAL_LONG(&_0, 1); - ZEPHIR_CALL_FUNCTION(NULL, "stream_set_blocking", NULL, 72, &a, &_0); + ZEPHIR_CALL_FUNCTION(NULL, "stream_set_blocking", NULL, 82, &a, &_0); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); diff --git a/ext/stub/resourcetest.zep.h b/ext/stub/resourcetest.zep.h index b8bcbe9c52..58f3a9622b 100644 --- a/ext/stub/resourcetest.zep.h +++ b/ext/stub/resourcetest.zep.h @@ -29,11 +29,35 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_resourcetest_testfunctionsforstdin, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_resourcetest_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ResourceTest, testLetStatementSTDIN, arginfo_stub_resourcetest_testletstatementstdin, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ResourceTest, testLetStatementSTDIN, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ResourceTest, testLetStatementSTDOUT, arginfo_stub_resourcetest_testletstatementstdout, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ResourceTest, testLetStatementSTDOUT, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ResourceTest, testLetStatementSTDERR, arginfo_stub_resourcetest_testletstatementstderr, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ResourceTest, testLetStatementSTDERR, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ResourceTest, testTypeOffResource, arginfo_stub_resourcetest_testtypeoffresource, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ResourceTest, testTypeOffResource, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ResourceTest, testIsResource, arginfo_stub_resourcetest_testisresource, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ResourceTest, testIsResource, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ResourceTest, testFunctionsForSTDIN, arginfo_stub_resourcetest_testfunctionsforstdin, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ResourceTest, testFunctionsForSTDIN, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/returns.zep.c b/ext/stub/returns.zep.c index 4a0aac1a17..0582a98aa0 100644 --- a/ext/stub/returns.zep.c +++ b/ext/stub/returns.zep.c @@ -30,6 +30,7 @@ PHP_METHOD(Stub_Returns, testReturnCast1) { zval *this_ptr = getThis(); + RETURN_LONG((int) 5.0); } @@ -39,6 +40,7 @@ PHP_METHOD(Stub_Returns, testReturnCast2) { zval *this_ptr = getThis(); + RETURN_LONG(1); } @@ -48,6 +50,7 @@ PHP_METHOD(Stub_Returns, testReturnCast3) { zval *this_ptr = getThis(); + RETURN_LONG(0); } @@ -57,6 +60,7 @@ PHP_METHOD(Stub_Returns, testReturnCast4) { zval *this_ptr = getThis(); + if (1) { RETURN_LONG(1); } else { @@ -73,6 +77,14 @@ PHP_METHOD(Stub_Returns, returnWithParameter) { zval *this_ptr = getThis(); ZVAL_UNDEF(¶meter); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(parameter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, ¶meter_param); @@ -89,6 +101,7 @@ PHP_METHOD(Stub_Returns, returnWithoutParameter) { zval *this_ptr = getThis(); + RETURN_STRING("Return back"); } diff --git a/ext/stub/returns.zep.h b/ext/stub/returns.zep.h index 099248884a..3d5dd2d644 100644 --- a/ext/stub/returns.zep.h +++ b/ext/stub/returns.zep.h @@ -10,40 +10,20 @@ PHP_METHOD(Stub_Returns, testReturnCast4); PHP_METHOD(Stub_Returns, returnWithParameter); PHP_METHOD(Stub_Returns, returnWithoutParameter); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_returns_testreturncast1, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_returns_testreturncast1, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_returns_testreturncast2, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_returns_testreturncast2, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_returns_testreturncast3, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_returns_testreturncast3, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_returns_testreturncast4, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_returns_testreturncast4, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_returns_returnwithparameter, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, parameter, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, parameter) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_returns_returnwithoutparameter, 0, 0, 0) @@ -55,6 +35,10 @@ ZEPHIR_INIT_FUNCS(stub_returns_method_entry) { PHP_ME(Stub_Returns, testReturnCast3, arginfo_stub_returns_testreturncast3, ZEND_ACC_PUBLIC) PHP_ME(Stub_Returns, testReturnCast4, arginfo_stub_returns_testreturncast4, ZEND_ACC_PUBLIC) PHP_ME(Stub_Returns, returnWithParameter, arginfo_stub_returns_returnwithparameter, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Returns, returnWithoutParameter, arginfo_stub_returns_returnwithoutparameter, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Returns, returnWithoutParameter, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif PHP_FE_END }; diff --git a/ext/stub/router.zep.c b/ext/stub/router.zep.c index 165fa26180..c2fc2f7f91 100644 --- a/ext/stub/router.zep.c +++ b/ext/stub/router.zep.c @@ -118,6 +118,15 @@ PHP_METHOD(Stub_Router, __construct) { ZVAL_UNDEF(&_5$$3); ZVAL_UNDEF(&_1$$3); ZVAL_UNDEF(&_4$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_BOOL(defaultRoutes) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &defaultRoutes_param); @@ -139,7 +148,7 @@ PHP_METHOD(Stub_Router, __construct) { add_assoc_long_ex(&_1$$3, SL("controller"), 1); ZEPHIR_INIT_VAR(&_2$$3); ZVAL_STRING(&_2$$3, "#^/([a-zA-Z0-9\\_\\-]+)[/]{0,1}$#"); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", &_3, 73, &_2$$3, &_1$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", &_3, 83, &_2$$3, &_1$$3); zephir_check_call_status(); zephir_array_append(&routes, &_0$$3, PH_SEPARATE, "stub/router.zep", 89); ZEPHIR_INIT_NVAR(&_2$$3); @@ -151,7 +160,7 @@ PHP_METHOD(Stub_Router, __construct) { add_assoc_long_ex(&_4$$3, SL("params"), 3); ZEPHIR_INIT_VAR(&_5$$3); ZVAL_STRING(&_5$$3, "#^/([a-zA-Z0-9\\_\\-]+)/([a-zA-Z0-9\\.\\_]+)(/.*)*$#"); - ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", &_3, 73, &_5$$3, &_4$$3); + ZEPHIR_CALL_METHOD(NULL, &_2$$3, "__construct", &_3, 83, &_5$$3, &_4$$3); zephir_check_call_status(); zephir_array_append(&routes, &_2$$3, PH_SEPARATE, "stub/router.zep", 95); } @@ -174,6 +183,14 @@ PHP_METHOD(Stub_Router, setDI) { zval *this_ptr = getThis(); ZVAL_UNDEF(&dependencyInjector_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_OBJECT_OF_CLASS(dependencyInjector, stub_diinterface_ce) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &dependencyInjector); @@ -193,6 +210,7 @@ PHP_METHOD(Stub_Router, getDI) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_dependencyInjector"); } @@ -215,6 +233,7 @@ PHP_METHOD(Stub_Router, getRewriteUri) { ZVAL_UNDEF(&realUri); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); zephir_get_global(&_SERVER, SL("_SERVER")); zephir_get_global(&_GET, SL("_GET")); @@ -258,6 +277,14 @@ PHP_METHOD(Stub_Router, setUriSource) { zval *this_ptr = getThis(); ZVAL_UNDEF(&uriSource_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(uriSource) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &uriSource); @@ -280,6 +307,14 @@ PHP_METHOD(Stub_Router, removeExtraSlashes) { zval *this_ptr = getThis(); ZVAL_UNDEF(&remove_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(remove) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &remove); @@ -302,6 +337,14 @@ PHP_METHOD(Stub_Router, setDefaultNamespace) { zval *this_ptr = getThis(); ZVAL_UNDEF(&namespaceName_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(namespaceName) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &namespaceName); @@ -324,6 +367,14 @@ PHP_METHOD(Stub_Router, setDefaultModule) { zval *this_ptr = getThis(); ZVAL_UNDEF(&moduleName_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(moduleName) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &moduleName); @@ -346,6 +397,14 @@ PHP_METHOD(Stub_Router, setDefaultController) { zval *this_ptr = getThis(); ZVAL_UNDEF(&controllerName_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(controllerName) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &controllerName); @@ -368,6 +427,14 @@ PHP_METHOD(Stub_Router, setDefaultAction) { zval *this_ptr = getThis(); ZVAL_UNDEF(&actionName_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(actionName) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &actionName); @@ -403,6 +470,14 @@ PHP_METHOD(Stub_Router, setDefaults) { ZVAL_UNDEF(&controller); ZVAL_UNDEF(&action); ZVAL_UNDEF(¶ms); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(defaults) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &defaults); @@ -440,6 +515,14 @@ PHP_METHOD(Stub_Router, doRemoveExtraSlashes) { zval *this_ptr = getThis(); ZVAL_UNDEF(&route_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(route) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &route); @@ -530,6 +613,15 @@ PHP_METHOD(Stub_Router, handle) { ZVAL_UNDEF(&_29$$96); ZVAL_UNDEF(&_30$$96); ZVAL_UNDEF(&_31$$96); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(uri) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &uri); @@ -1020,6 +1112,17 @@ PHP_METHOD(Stub_Router, add) { ZVAL_UNDEF(&httpMethods_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&route); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 3) + Z_PARAM_ZVAL(pattern) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(paths) + Z_PARAM_ZVAL(httpMethods) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &pattern, &paths, &httpMethods); @@ -1036,7 +1139,7 @@ PHP_METHOD(Stub_Router, add) { ZEPHIR_INIT_VAR(&route); object_init_ex(&route, stub_router_route_ce); - ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 73, pattern, paths, httpMethods); + ZEPHIR_CALL_METHOD(NULL, &route, "__construct", NULL, 83, pattern, paths, httpMethods); zephir_check_call_status(); zephir_update_property_array_append(this_ptr, SL("_routes"), &route); RETURN_CCTOR(&route); @@ -1061,6 +1164,16 @@ PHP_METHOD(Stub_Router, addGet) { ZVAL_UNDEF(&paths_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(pattern) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(paths) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &pattern, &paths); @@ -1097,6 +1210,16 @@ PHP_METHOD(Stub_Router, addPost) { ZVAL_UNDEF(&paths_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(pattern) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(paths) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &pattern, &paths); @@ -1133,6 +1256,16 @@ PHP_METHOD(Stub_Router, addPut) { ZVAL_UNDEF(&paths_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(pattern) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(paths) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &pattern, &paths); @@ -1169,6 +1302,16 @@ PHP_METHOD(Stub_Router, addPatch) { ZVAL_UNDEF(&paths_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(pattern) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(paths) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &pattern, &paths); @@ -1205,6 +1348,16 @@ PHP_METHOD(Stub_Router, addDelete) { ZVAL_UNDEF(&paths_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(pattern) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(paths) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &pattern, &paths); @@ -1241,6 +1394,16 @@ PHP_METHOD(Stub_Router, addOptions) { ZVAL_UNDEF(&paths_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(pattern) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(paths) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &pattern, &paths); @@ -1277,6 +1440,16 @@ PHP_METHOD(Stub_Router, addHead) { ZVAL_UNDEF(&paths_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(pattern) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(paths) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &pattern, &paths); @@ -1317,6 +1490,14 @@ PHP_METHOD(Stub_Router, mount) { ZVAL_UNDEF(&_1$$5); ZVAL_UNDEF(&_3$$8); ZVAL_UNDEF(&_4$$11); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(group) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &group); @@ -1420,6 +1601,14 @@ PHP_METHOD(Stub_Router, notFound) { zval *this_ptr = getThis(); ZVAL_UNDEF(&paths_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(paths) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &paths); @@ -1447,6 +1636,7 @@ PHP_METHOD(Stub_Router, clear) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -1466,6 +1656,7 @@ PHP_METHOD(Stub_Router, getNamespaceName) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_namespace"); } @@ -1480,6 +1671,7 @@ PHP_METHOD(Stub_Router, getModuleName) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_module"); } @@ -1494,6 +1686,7 @@ PHP_METHOD(Stub_Router, getControllerName) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_controller"); } @@ -1508,6 +1701,7 @@ PHP_METHOD(Stub_Router, getActionName) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_action"); } @@ -1522,6 +1716,7 @@ PHP_METHOD(Stub_Router, getParams) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_params"); } @@ -1536,6 +1731,7 @@ PHP_METHOD(Stub_Router, getMatchedRoute) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_matchedRoute"); } @@ -1550,6 +1746,7 @@ PHP_METHOD(Stub_Router, getMatches) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_matches"); } @@ -1564,6 +1761,7 @@ PHP_METHOD(Stub_Router, wasMatched) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_wasMatched"); } @@ -1578,6 +1776,7 @@ PHP_METHOD(Stub_Router, getRoutes) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_routes"); } @@ -1601,6 +1800,14 @@ PHP_METHOD(Stub_Router, getRouteById) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3$$3); ZVAL_UNDEF(&_4$$5); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(id) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &id); @@ -1664,6 +1871,14 @@ PHP_METHOD(Stub_Router, getRouteByName) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3$$3); ZVAL_UNDEF(&_4$$5); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(name) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &name); diff --git a/ext/stub/router.zep.h b/ext/stub/router.zep.h index 20941078fe..0cff207b84 100644 --- a/ext/stub/router.zep.h +++ b/ext/stub/router.zep.h @@ -40,11 +40,7 @@ PHP_METHOD(Stub_Router, getRouteById); PHP_METHOD(Stub_Router, getRouteByName); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_router___construct, 0, 0, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, defaultRoutes, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, defaultRoutes) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_router_setdi, 0, 0, 1) @@ -183,8 +179,16 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_router_method_entry) { PHP_ME(Stub_Router, __construct, arginfo_stub_router___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) PHP_ME(Stub_Router, setDI, arginfo_stub_router_setdi, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, getDI, arginfo_stub_router_getdi, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, getDI, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, getRewriteUri, arginfo_stub_router_getrewriteuri, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, getRewriteUri, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Router, setUriSource, arginfo_stub_router_seturisource, ZEND_ACC_PUBLIC) PHP_ME(Stub_Router, removeExtraSlashes, arginfo_stub_router_removeextraslashes, ZEND_ACC_PUBLIC) PHP_ME(Stub_Router, setDefaultNamespace, arginfo_stub_router_setdefaultnamespace, ZEND_ACC_PUBLIC) @@ -204,16 +208,56 @@ ZEPHIR_INIT_FUNCS(stub_router_method_entry) { PHP_ME(Stub_Router, addHead, arginfo_stub_router_addhead, ZEND_ACC_PUBLIC) PHP_ME(Stub_Router, mount, arginfo_stub_router_mount, ZEND_ACC_PUBLIC) PHP_ME(Stub_Router, notFound, arginfo_stub_router_notfound, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, clear, arginfo_stub_router_clear, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, clear, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, getNamespaceName, arginfo_stub_router_getnamespacename, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, getNamespaceName, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, getModuleName, arginfo_stub_router_getmodulename, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, getModuleName, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, getControllerName, arginfo_stub_router_getcontrollername, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, getControllerName, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, getActionName, arginfo_stub_router_getactionname, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, getActionName, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, getParams, arginfo_stub_router_getparams, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, getParams, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, getMatchedRoute, arginfo_stub_router_getmatchedroute, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, getMatchedRoute, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, getMatches, arginfo_stub_router_getmatches, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, getMatches, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, wasMatched, arginfo_stub_router_wasmatched, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, wasMatched, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router, getRoutes, arginfo_stub_router_getroutes, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router, getRoutes, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Router, getRouteById, arginfo_stub_router_getroutebyid, ZEND_ACC_PUBLIC) PHP_ME(Stub_Router, getRouteByName, arginfo_stub_router_getroutebyname, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/router/exception.zep.c b/ext/stub/router/exception.zep.c index a7c21dc483..b911b1f05f 100644 --- a/ext/stub/router/exception.zep.c +++ b/ext/stub/router/exception.zep.c @@ -21,7 +21,7 @@ */ ZEPHIR_INIT_CLASS(Stub_Router_Exception) { - ZEPHIR_REGISTER_CLASS_EX(Stub\\Router, Exception, stub, router_exception, zend_exception_get_default(), NULL, 0); + ZEPHIR_REGISTER_CLASS_EX(Stub\\Router, Exception, stub, router_exception, zend_ce_exception, NULL, 0); return SUCCESS; diff --git a/ext/stub/router/route.zep.c b/ext/stub/router/route.zep.c index c91809d651..936b3fb8df 100644 --- a/ext/stub/router/route.zep.c +++ b/ext/stub/router/route.zep.c @@ -71,6 +71,17 @@ PHP_METHOD(Stub_Router_Route, __construct) { ZVAL_UNDEF(&paths_sub); ZVAL_UNDEF(&httpMethods_sub); ZVAL_NULL(&__$null); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 3) + Z_PARAM_ZVAL(pattern) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(paths) + Z_PARAM_ZVAL(httpMethods) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 2, &pattern, &paths, &httpMethods); @@ -120,6 +131,14 @@ PHP_METHOD(Stub_Router_Route, compilePattern) { ZVAL_UNDEF(&_11$$9); ZVAL_UNDEF(&_12$$9); ZVAL_UNDEF(&_13$$9); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(pattern) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &pattern); @@ -207,6 +226,14 @@ PHP_METHOD(Stub_Router_Route, via) { zval *this_ptr = getThis(); ZVAL_UNDEF(&httpMethods_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(httpMethods) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &httpMethods); @@ -253,6 +280,14 @@ PHP_METHOD(Stub_Router_Route, extractNamedParams) { ZVAL_UNDEF(&_23$$16); ZVAL_UNDEF(&_27$$19); ZVAL_UNDEF(&_28$$28); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(pattern) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &pattern_param); @@ -483,6 +518,16 @@ PHP_METHOD(Stub_Router_Route, reConfigure) { ZVAL_UNDEF(&_1$$10); ZVAL_UNDEF(&_2$$19); ZVAL_UNDEF(&_3$$19); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(pattern) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(paths) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &pattern, &paths); @@ -602,6 +647,7 @@ PHP_METHOD(Stub_Router_Route, getName) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_name"); } @@ -624,6 +670,14 @@ PHP_METHOD(Stub_Router_Route, setName) { zval *this_ptr = getThis(); ZVAL_UNDEF(&name_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(name) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &name); @@ -648,6 +702,14 @@ PHP_METHOD(Stub_Router_Route, beforeMatch) { zval *this_ptr = getThis(); ZVAL_UNDEF(&callback_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(callback) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &callback); @@ -668,6 +730,7 @@ PHP_METHOD(Stub_Router_Route, getBeforeMatch) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_beforeMatch"); } @@ -682,6 +745,7 @@ PHP_METHOD(Stub_Router_Route, getRouteId) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_id"); } @@ -696,6 +760,7 @@ PHP_METHOD(Stub_Router_Route, getPattern) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_pattern"); } @@ -710,6 +775,7 @@ PHP_METHOD(Stub_Router_Route, getCompiledPattern) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_compiledPattern"); } @@ -724,6 +790,7 @@ PHP_METHOD(Stub_Router_Route, getPaths) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_paths"); } @@ -748,6 +815,7 @@ PHP_METHOD(Stub_Router_Route, getReversedPaths) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&reversed); @@ -808,6 +876,14 @@ PHP_METHOD(Stub_Router_Route, setHttpMethods) { zval *this_ptr = getThis(); ZVAL_UNDEF(&httpMethods_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(httpMethods) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &httpMethods); @@ -828,6 +904,7 @@ PHP_METHOD(Stub_Router_Route, getHttpMethods) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_methods"); } @@ -848,6 +925,14 @@ PHP_METHOD(Stub_Router_Route, setHostname) { zval *this_ptr = getThis(); ZVAL_UNDEF(&hostname_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(hostname) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &hostname); @@ -868,6 +953,7 @@ PHP_METHOD(Stub_Router_Route, getHostname) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_hostname"); } @@ -886,6 +972,15 @@ PHP_METHOD(Stub_Router_Route, convert) { ZVAL_UNDEF(&name_sub); ZVAL_UNDEF(&converter_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(name) + Z_PARAM_ZVAL(converter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &name, &converter); @@ -906,6 +1001,7 @@ PHP_METHOD(Stub_Router_Route, getConverters) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "_converters"); } diff --git a/ext/stub/router/route.zep.h b/ext/stub/router/route.zep.h index 2e58cf616f..a55bc0e79c 100644 --- a/ext/stub/router/route.zep.h +++ b/ext/stub/router/route.zep.h @@ -39,11 +39,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_router_route_via, 0, 0, 1) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_router_route_extractnamedparams, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, pattern, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, pattern) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_router_route_reconfigure, 0, 0, 1) @@ -108,20 +104,60 @@ ZEPHIR_INIT_FUNCS(stub_router_route_method_entry) { PHP_ME(Stub_Router_Route, via, arginfo_stub_router_route_via, ZEND_ACC_PUBLIC) PHP_ME(Stub_Router_Route, extractNamedParams, arginfo_stub_router_route_extractnamedparams, ZEND_ACC_PUBLIC) PHP_ME(Stub_Router_Route, reConfigure, arginfo_stub_router_route_reconfigure, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router_Route, getName, arginfo_stub_router_route_getname, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router_Route, getName, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Router_Route, setName, arginfo_stub_router_route_setname, ZEND_ACC_PUBLIC) PHP_ME(Stub_Router_Route, beforeMatch, arginfo_stub_router_route_beforematch, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router_Route, getBeforeMatch, arginfo_stub_router_route_getbeforematch, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router_Route, getBeforeMatch, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router_Route, getRouteId, arginfo_stub_router_route_getrouteid, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router_Route, getRouteId, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router_Route, getPattern, arginfo_stub_router_route_getpattern, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router_Route, getPattern, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router_Route, getCompiledPattern, arginfo_stub_router_route_getcompiledpattern, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router_Route, getCompiledPattern, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router_Route, getPaths, arginfo_stub_router_route_getpaths, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router_Route, getPaths, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router_Route, getReversedPaths, arginfo_stub_router_route_getreversedpaths, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router_Route, getReversedPaths, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Router_Route, setHttpMethods, arginfo_stub_router_route_sethttpmethods, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router_Route, getHttpMethods, arginfo_stub_router_route_gethttpmethods, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router_Route, getHttpMethods, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Router_Route, setHostname, arginfo_stub_router_route_sethostname, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router_Route, getHostname, arginfo_stub_router_route_gethostname, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router_Route, getHostname, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Router_Route, convert, arginfo_stub_router_route_convert, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Router_Route, getConverters, arginfo_stub_router_route_getconverters, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Router_Route, getConverters, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/scall.zep.c b/ext/stub/scall.zep.c index 78ec45a389..2c5357c4dc 100644 --- a/ext/stub/scall.zep.c +++ b/ext/stub/scall.zep.c @@ -34,6 +34,7 @@ PHP_METHOD(Stub_Scall, testMethod1) { zval *this_ptr = getThis(); + RETURN_STRING("hello public"); } @@ -43,6 +44,7 @@ PHP_METHOD(Stub_Scall, testMethod2) { zval *this_ptr = getThis(); + RETURN_STRING("hello protected"); } @@ -52,6 +54,7 @@ PHP_METHOD(Stub_Scall, testMethod3) { zval *this_ptr = getThis(); + RETURN_STRING("hello private"); } @@ -63,6 +66,15 @@ PHP_METHOD(Stub_Scall, testMethod4) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); @@ -80,6 +92,15 @@ PHP_METHOD(Stub_Scall, testMethod5) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); @@ -97,6 +118,15 @@ PHP_METHOD(Stub_Scall, testMethod6) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a, &b); @@ -112,6 +142,7 @@ PHP_METHOD(Stub_Scall, testMethod7) { zval *this_ptr = getThis(); + object_init(return_value); return; @@ -124,6 +155,7 @@ PHP_METHOD(Stub_Scall, testCall1) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_SELF("testmethod1", NULL, 0); @@ -139,6 +171,7 @@ PHP_METHOD(Stub_Scall, testCall2) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_SELF("testmethod2", NULL, 0); @@ -155,9 +188,10 @@ PHP_METHOD(Stub_Scall, testCall3) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); - ZEPHIR_RETURN_CALL_SELF("testmethod3", &_0, 74); + ZEPHIR_RETURN_CALL_SELF("testmethod3", &_0, 84); zephir_check_call_status(); RETURN_MM(); @@ -172,6 +206,15 @@ PHP_METHOD(Stub_Scall, testCall4) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -193,6 +236,15 @@ PHP_METHOD(Stub_Scall, testCall5) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -215,13 +267,22 @@ PHP_METHOD(Stub_Scall, testCall6) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); - ZEPHIR_RETURN_CALL_SELF("testmethod6", &_0, 75, a, b); + ZEPHIR_RETURN_CALL_SELF("testmethod6", &_0, 85, a, b); zephir_check_call_status(); RETURN_MM(); @@ -234,6 +295,7 @@ PHP_METHOD(Stub_Scall, testCall7) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_SELF("testmethod1", NULL, 0); @@ -249,6 +311,7 @@ PHP_METHOD(Stub_Scall, testCall8) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_SELF("testmethod2", NULL, 0); @@ -265,9 +328,10 @@ PHP_METHOD(Stub_Scall, testCall9) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); - ZEPHIR_RETURN_CALL_SELF("testmethod3", &_0, 74); + ZEPHIR_RETURN_CALL_SELF("testmethod3", &_0, 84); zephir_check_call_status(); RETURN_MM(); @@ -282,6 +346,15 @@ PHP_METHOD(Stub_Scall, testCall10) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -303,6 +376,15 @@ PHP_METHOD(Stub_Scall, testCall11) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -325,13 +407,22 @@ PHP_METHOD(Stub_Scall, testCall12) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); - ZEPHIR_RETURN_CALL_SELF("testmethod6", &_0, 75, a, b); + ZEPHIR_RETURN_CALL_SELF("testmethod6", &_0, 85, a, b); zephir_check_call_status(); RETURN_MM(); @@ -345,6 +436,7 @@ PHP_METHOD(Stub_Scall, testCall13) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_PARENT(stub_scall_ce, getThis(), "testmethod1", &_0, 0); @@ -361,6 +453,7 @@ PHP_METHOD(Stub_Scall, testCall14) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_PARENT(stub_scall_ce, getThis(), "testmethod2", &_0, 0); @@ -376,6 +469,7 @@ PHP_METHOD(Stub_Scall, testCall15) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_SELF("testmethod7", NULL, 0); @@ -390,6 +484,15 @@ PHP_METHOD(Stub_Scall, testMethod16) { long a, b; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a_param, &b_param); @@ -413,6 +516,15 @@ PHP_METHOD(Stub_Scall, testCall17) { ZVAL_UNDEF(&p_sub); ZVAL_UNDEF(&_3$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(k) + Z_PARAM_ZVAL(p) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &k_param, &p); @@ -456,6 +568,15 @@ PHP_METHOD(Stub_Scall, testCall18) { ZVAL_UNDEF(&p_sub); ZVAL_UNDEF(&_3$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(k) + Z_PARAM_ZVAL(p) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &k_param, &p); @@ -492,6 +613,7 @@ PHP_METHOD(Stub_Scall, testMethodStatic) { zval *this_ptr = getThis(); + RETURN_STRING("hello Scall"); } @@ -507,6 +629,7 @@ PHP_METHOD(Stub_Scall, interpolatedStaticReturn) { ZVAL_UNDEF(&className); ZVAL_UNDEF(&methodName); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&className); @@ -533,6 +656,7 @@ PHP_METHOD(Stub_Scall, interpolatedStaticEcho) { ZVAL_UNDEF(&methodName); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&className); diff --git a/ext/stub/scall.zep.h b/ext/stub/scall.zep.h index 871581d5de..e9a61d09bc 100644 --- a/ext/stub/scall.zep.h +++ b/ext/stub/scall.zep.h @@ -32,25 +32,13 @@ PHP_METHOD(Stub_Scall, testMethodStatic); PHP_METHOD(Stub_Scall, interpolatedStaticReturn); PHP_METHOD(Stub_Scall, interpolatedStaticEcho); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_testmethod1, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_testmethod1, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_testmethod2, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_testmethod2, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_testmethod3, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_testmethod3, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scall_testmethod4, 0, 0, 2) @@ -68,11 +56,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scall_testmethod6, 0, 0, 2) ZEND_ARG_INFO(0, b) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_stub_scall_testmethod7, 0, 0, stdClass, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_testmethod7, 0, 0, IS_OBJECT, "stdClass", 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scall_testcall1, 0, 0, 0) @@ -132,65 +116,29 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scall_testcall15, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_testmethod16, 0, 2, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_testmethod16, 0, 2, IS_LONG, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scall_testcall17, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, k, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, k) -#endif ZEND_ARG_INFO(0, p) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scall_testcall18, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, k, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, k) -#endif ZEND_ARG_INFO(0, p) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_testmethodstatic, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_testmethodstatic, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_interpolatedstaticreturn, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_interpolatedstaticreturn, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70100 -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_interpolatedstaticecho, 0, 0, IS_VOID, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scall_interpolatedstaticecho, 0, 0, IS_VOID, NULL, 0) -#endif ZEND_END_ARG_INFO() -#else -#define arginfo_stub_scall_interpolatedstaticecho NULL -#endif ZEPHIR_INIT_FUNCS(stub_scall_method_entry) { PHP_ME(Stub_Scall, testMethod1, arginfo_stub_scall_testmethod1, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) @@ -200,21 +148,57 @@ ZEPHIR_INIT_FUNCS(stub_scall_method_entry) { PHP_ME(Stub_Scall, testMethod5, arginfo_stub_scall_testmethod5, ZEND_ACC_STATIC|ZEND_ACC_PROTECTED) PHP_ME(Stub_Scall, testMethod6, arginfo_stub_scall_testmethod6, ZEND_ACC_STATIC|ZEND_ACC_PRIVATE) PHP_ME(Stub_Scall, testMethod7, arginfo_stub_scall_testmethod7, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scall, testCall1, arginfo_stub_scall_testcall1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Scall, testCall1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scall, testCall2, arginfo_stub_scall_testcall2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Scall, testCall2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scall, testCall3, arginfo_stub_scall_testcall3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Scall, testCall3, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Scall, testCall4, arginfo_stub_scall_testcall4, ZEND_ACC_PUBLIC) PHP_ME(Stub_Scall, testCall5, arginfo_stub_scall_testcall5, ZEND_ACC_PUBLIC) PHP_ME(Stub_Scall, testCall6, arginfo_stub_scall_testcall6, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scall, testCall7, arginfo_stub_scall_testcall7, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Scall, testCall7, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scall, testCall8, arginfo_stub_scall_testcall8, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Scall, testCall8, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scall, testCall9, arginfo_stub_scall_testcall9, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Scall, testCall9, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Scall, testCall10, arginfo_stub_scall_testcall10, ZEND_ACC_PUBLIC) PHP_ME(Stub_Scall, testCall11, arginfo_stub_scall_testcall11, ZEND_ACC_PUBLIC) PHP_ME(Stub_Scall, testCall12, arginfo_stub_scall_testcall12, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scall, testCall13, arginfo_stub_scall_testcall13, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Scall, testCall13, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scall, testCall14, arginfo_stub_scall_testcall14, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Scall, testCall14, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scall, testCall15, arginfo_stub_scall_testcall15, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Scall, testCall15, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Scall, testMethod16, arginfo_stub_scall_testmethod16, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) PHP_ME(Stub_Scall, testCall17, arginfo_stub_scall_testcall17, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) PHP_ME(Stub_Scall, testCall18, arginfo_stub_scall_testcall18, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) diff --git a/ext/stub/scalldynamic.zep.c b/ext/stub/scalldynamic.zep.c index 09dc5c255b..5e34b1180a 100644 --- a/ext/stub/scalldynamic.zep.c +++ b/ext/stub/scalldynamic.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(Stub_ScallDynamic, testMethod1) { zval *this_ptr = getThis(); + RETURN_STRING("hello public"); } @@ -42,6 +43,7 @@ PHP_METHOD(Stub_ScallDynamic, testMethod2) { zval *this_ptr = getThis(); + RETURN_STRING("hello protected"); } @@ -51,6 +53,7 @@ PHP_METHOD(Stub_ScallDynamic, testMethod3) { zval *this_ptr = getThis(); + RETURN_STRING("hello private"); } @@ -62,6 +65,14 @@ PHP_METHOD(Stub_ScallDynamic, selfDynamicCall1) { zval *this_ptr = getThis(); ZVAL_UNDEF(&methodName_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(methodName) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &methodName); diff --git a/ext/stub/scalldynamic.zep.h b/ext/stub/scalldynamic.zep.h index 0ae9d47dbe..6917108826 100644 --- a/ext/stub/scalldynamic.zep.h +++ b/ext/stub/scalldynamic.zep.h @@ -8,32 +8,16 @@ PHP_METHOD(Stub_ScallDynamic, testMethod2); PHP_METHOD(Stub_ScallDynamic, testMethod3); PHP_METHOD(Stub_ScallDynamic, selfDynamicCall1); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scalldynamic_testmethod1, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scalldynamic_testmethod1, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scalldynamic_testmethod2, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scalldynamic_testmethod2, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scalldynamic_testmethod3, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scalldynamic_testmethod3, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scalldynamic_selfdynamiccall1, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scalldynamic_selfdynamiccall1, 0, 1, IS_STRING, NULL, 0) -#endif ZEND_ARG_INFO(0, methodName) ZEND_END_ARG_INFO() diff --git a/ext/stub/scallexternal.zep.c b/ext/stub/scallexternal.zep.c index a439ae1dbb..4d3084b0bc 100644 --- a/ext/stub/scallexternal.zep.c +++ b/ext/stub/scallexternal.zep.c @@ -39,6 +39,7 @@ PHP_METHOD(Stub_ScallExternal, testCall1) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_CE_STATIC(stub_scall_ce, "testmethod1", &_0, 0); @@ -57,6 +58,15 @@ PHP_METHOD(Stub_ScallExternal, testCall2) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&b_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &b); @@ -75,6 +85,15 @@ PHP_METHOD(Stub_ScallExternal, testMethod3) { long a, b; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &a_param, &b_param); diff --git a/ext/stub/scallexternal.zep.h b/ext/stub/scallexternal.zep.h index bb2165c702..ca8217a5af 100644 --- a/ext/stub/scallexternal.zep.h +++ b/ext/stub/scallexternal.zep.h @@ -16,20 +16,16 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scallexternal_testcall2, 0, 0, 2) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scallexternal_testmethod3, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, a) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_scallexternal_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_ScallExternal, testCall1, arginfo_stub_scallexternal_testcall1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ScallExternal, testCall1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_ScallExternal, testCall2, arginfo_stub_scallexternal_testcall2, ZEND_ACC_PUBLIC) PHP_ME(Stub_ScallExternal, testMethod3, arginfo_stub_scallexternal_testmethod3, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) PHP_FE_END diff --git a/ext/stub/scalllateconstruct.zep.c b/ext/stub/scalllateconstruct.zep.c new file mode 100644 index 0000000000..9ac3fa5411 --- /dev/null +++ b/ext/stub/scalllateconstruct.zep.c @@ -0,0 +1,87 @@ + +#ifdef HAVE_CONFIG_H +#include "../ext_config.h" +#endif + +#include +#include "../php_ext.h" +#include "../ext.h" + +#include +#include +#include + +#include "kernel/main.h" +#include "kernel/fcall.h" +#include "kernel/object.h" +#include "kernel/memory.h" + + +/** + * Static Function call via constructor and late binding + */ +ZEPHIR_INIT_CLASS(Stub_ScallLateConstruct) { + + ZEPHIR_REGISTER_CLASS(Stub, ScallLateConstruct, stub, scalllateconstruct, stub_scalllateconstruct_method_entry, 0); + + zend_declare_property_null(stub_scalllateconstruct_ce, SL("protectedVar"), ZEND_ACC_PROTECTED); + + return SUCCESS; + +} + +PHP_METHOD(Stub_ScallLateConstruct, __construct) { + + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *this_ptr = getThis(); + + + + ZEPHIR_MM_GROW(); + + ZEPHIR_CALL_METHOD(NULL, this_ptr, "testpublicinit", NULL, 0); + zephir_check_call_status(); + ZEPHIR_MM_RESTORE(); + +} + +PHP_METHOD(Stub_ScallLateConstruct, testStaticInit) { + + zval *this_ptr = getThis(); + + + + RETURN_STRING("hello public"); + +} + +PHP_METHOD(Stub_ScallLateConstruct, testPublicInit) { + + zval _0; + zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; + zend_long ZEPHIR_LAST_CALL_STATUS; + zval *this_ptr = getThis(); + + ZVAL_UNDEF(&_0); + + + ZEPHIR_MM_GROW(); + + ZEPHIR_CALL_SELF(&_0, "teststaticinit", NULL, 0); + zephir_check_call_status(); + zephir_update_property_zval(this_ptr, ZEND_STRL("protectedVar"), &_0); + ZEPHIR_MM_RESTORE(); + +} + +PHP_METHOD(Stub_ScallLateConstruct, varValue) { + + zval *this_ptr = getThis(); + + + + RETURN_MEMBER(getThis(), "protectedVar"); + +} + diff --git a/ext/stub/scalllateconstruct.zep.h b/ext/stub/scalllateconstruct.zep.h new file mode 100644 index 0000000000..4c8a480459 --- /dev/null +++ b/ext/stub/scalllateconstruct.zep.h @@ -0,0 +1,37 @@ + +extern zend_class_entry *stub_scalllateconstruct_ce; + +ZEPHIR_INIT_CLASS(Stub_ScallLateConstruct); + +PHP_METHOD(Stub_ScallLateConstruct, __construct); +PHP_METHOD(Stub_ScallLateConstruct, testStaticInit); +PHP_METHOD(Stub_ScallLateConstruct, testPublicInit); +PHP_METHOD(Stub_ScallLateConstruct, varValue); + +ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scalllateconstruct___construct, 0, 0, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scalllateconstruct_teststaticinit, 0, 0, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scalllateconstruct_testpublicinit, 0, 0, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scalllateconstruct_varvalue, 0, 0, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEPHIR_INIT_FUNCS(stub_scalllateconstruct_method_entry) { +#if PHP_VERSION_ID >= 80000 + PHP_ME(Stub_ScallLateConstruct, __construct, arginfo_stub_scalllateconstruct___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#else + PHP_ME(Stub_ScallLateConstruct, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#endif + PHP_ME(Stub_ScallLateConstruct, testStaticInit, arginfo_stub_scalllateconstruct_teststaticinit, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 + PHP_ME(Stub_ScallLateConstruct, testPublicInit, arginfo_stub_scalllateconstruct_testpublicinit, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_ScallLateConstruct, testPublicInit, NULL, ZEND_ACC_PUBLIC) +#endif + PHP_ME(Stub_ScallLateConstruct, varValue, arginfo_stub_scalllateconstruct_varvalue, ZEND_ACC_PUBLIC) + PHP_FE_END +}; diff --git a/ext/stub/scallparent.zep.c b/ext/stub/scallparent.zep.c index b5177bc091..2fc172091a 100644 --- a/ext/stub/scallparent.zep.c +++ b/ext/stub/scallparent.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(Stub_ScallParent, testMethod1) { zval *this_ptr = getThis(); + RETURN_STRING("hello parent public"); } @@ -42,6 +43,7 @@ PHP_METHOD(Stub_ScallParent, testMethod2) { zval *this_ptr = getThis(); + RETURN_STRING("hello parent protected"); } @@ -53,6 +55,7 @@ PHP_METHOD(Stub_ScallParent, testCallStatic) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); ZEPHIR_RETURN_CALL_STATIC("testmethodstatic", NULL, 0); @@ -66,6 +69,7 @@ PHP_METHOD(Stub_ScallParent, testMethodStatic) { zval *this_ptr = getThis(); + RETURN_STRING("hello ScallParent"); } diff --git a/ext/stub/scallparent.zep.h b/ext/stub/scallparent.zep.h index 719c55249f..c98834adc4 100644 --- a/ext/stub/scallparent.zep.h +++ b/ext/stub/scallparent.zep.h @@ -8,32 +8,16 @@ PHP_METHOD(Stub_ScallParent, testMethod2); PHP_METHOD(Stub_ScallParent, testCallStatic); PHP_METHOD(Stub_ScallParent, testMethodStatic); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scallparent_testmethod1, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scallparent_testmethod1, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scallparent_testmethod2, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scallparent_testmethod2, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scallparent_testcallstatic, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scallparent_testcallstatic, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scallparent_testmethodstatic, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_scallparent_testmethodstatic, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_scallparent_method_entry) { diff --git a/ext/stub/scope.zep.c b/ext/stub/scope.zep.c index 1f06f2eb55..fbf95a7cbf 100644 --- a/ext/stub/scope.zep.c +++ b/ext/stub/scope.zep.c @@ -33,6 +33,7 @@ PHP_METHOD(Stub_Scope, getStr) { zval *this_ptr = getThis(); + RETURN_STRING("internal_string"); } @@ -45,6 +46,14 @@ PHP_METHOD(Stub_Scope, getDyStr) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(g) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &g_param); @@ -71,11 +80,12 @@ PHP_METHOD(Stub_Scope, test1) { ZVAL_UNDEF(&k); ZVAL_UNDEF(&k$$3); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&ret); ZVAL_STRING(&ret, ""); - ZEPHIR_CALL_SELF(&k, "getstr", &_0, 76); + ZEPHIR_CALL_SELF(&k, "getstr", &_0, 86); zephir_check_call_status(); r = 1; if (r == 1) { @@ -102,6 +112,7 @@ PHP_METHOD(Stub_Scope, test2) { ZVAL_UNDEF(&_3$$3); ZVAL_UNDEF(&_4$$3); + ZEPHIR_MM_GROW(); p = 15; @@ -152,6 +163,7 @@ PHP_METHOD(Stub_Scope, test3) { ZVAL_UNDEF(&c); ZVAL_UNDEF(&str$$3); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&k); @@ -171,7 +183,7 @@ PHP_METHOD(Stub_Scope, test3) { } ZEPHIR_INIT_NVAR(&c); ZVAL_LONG(&c, _1); - ZEPHIR_CALL_SELF(&str$$3, "getdystr", &_3, 77, &c); + ZEPHIR_CALL_SELF(&str$$3, "getdystr", &_3, 87, &c); zephir_check_call_status(); zephir_concat_self(&k, &str$$3); } diff --git a/ext/stub/scope.zep.h b/ext/stub/scope.zep.h index 8dbb2d0a4b..5b4b68e810 100644 --- a/ext/stub/scope.zep.h +++ b/ext/stub/scope.zep.h @@ -13,11 +13,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scope_getstr, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scope_getdystr, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, g, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, g) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scope_test1, 0, 0, 0) @@ -30,10 +26,26 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_scope_test3, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_scope_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scope, getStr, arginfo_stub_scope_getstr, ZEND_ACC_PRIVATE|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Scope, getStr, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_STATIC) +#endif PHP_ME(Stub_Scope, getDyStr, arginfo_stub_scope_getdystr, ZEND_ACC_PRIVATE|ZEND_ACC_STATIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scope, test1, arginfo_stub_scope_test1, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Scope, test1, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scope, test2, arginfo_stub_scope_test2, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Scope, test2, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Scope, test3, arginfo_stub_scope_test3, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#else + PHP_ME(Stub_Scope, test3, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif PHP_FE_END }; diff --git a/ext/stub/sort.zep.c b/ext/stub/sort.zep.c index 4855aab08c..4263503dd1 100644 --- a/ext/stub/sort.zep.c +++ b/ext/stub/sort.zep.c @@ -48,6 +48,14 @@ PHP_METHOD(Stub_Sort, quick) { ZVAL_UNDEF(&_4$$4); ZVAL_UNDEF(&_5$$5); ZVAL_UNDEF(&_6$$6); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(arr) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &arr_param); @@ -94,16 +102,16 @@ PHP_METHOD(Stub_Sort, quick) { } } } - ZEPHIR_CALL_METHOD(&_7, this_ptr, "quick", &_8, 78, &left); + ZEPHIR_CALL_METHOD(&_7, this_ptr, "quick", &_8, 88, &left); zephir_check_call_status(); ZEPHIR_INIT_VAR(&_9); zephir_create_array(&_9, 1, 0); ZEPHIR_INIT_VAR(&_10); ZVAL_LONG(&_10, pivot); zephir_array_fast_append(&_9, &_10); - ZEPHIR_CALL_METHOD(&_11, this_ptr, "quick", &_8, 78, &right); + ZEPHIR_CALL_METHOD(&_11, this_ptr, "quick", &_8, 88, &right); zephir_check_call_status(); - ZEPHIR_RETURN_CALL_FUNCTION("array_merge", NULL, 79, &_7, &_9, &_11); + ZEPHIR_RETURN_CALL_FUNCTION("array_merge", NULL, 89, &_7, &_9, &_11); zephir_check_call_status(); RETURN_MM(); diff --git a/ext/stub/spectralnorm.zep.c b/ext/stub/spectralnorm.zep.c index 0e4b766c1e..0cd92ef46b 100644 --- a/ext/stub/spectralnorm.zep.c +++ b/ext/stub/spectralnorm.zep.c @@ -43,6 +43,15 @@ PHP_METHOD(Stub_SpectralNorm, Ax) { ZVAL_UNDEF(&j_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(i) + Z_PARAM_ZVAL(j) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &i, &j); @@ -75,6 +84,16 @@ PHP_METHOD(Stub_SpectralNorm, Au) { ZVAL_UNDEF(&_8$$4); ZVAL_UNDEF(&_10$$4); ZVAL_UNDEF(&_12$$4); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_LONG(n) + Z_PARAM_OBJECT_OF_CLASS(u, spl_ce_SplFixedArray) + Z_PARAM_OBJECT_OF_CLASS(v, spl_ce_SplFixedArray) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 3, 0, &n_param, &u, &v); @@ -113,7 +132,7 @@ PHP_METHOD(Stub_SpectralNorm, Au) { j = _4$$3; ZVAL_LONG(&_7$$4, i); ZVAL_LONG(&_8$$4, j); - ZEPHIR_CALL_METHOD(&_6$$4, this_ptr, "ax", &_9, 80, &_7$$4, &_8$$4); + ZEPHIR_CALL_METHOD(&_6$$4, this_ptr, "ax", &_9, 90, &_7$$4, &_8$$4); zephir_check_call_status(); ZVAL_LONG(&_7$$4, j); ZEPHIR_CALL_METHOD(&_10$$4, u, "offsetget", &_11, 0, &_7$$4); @@ -151,6 +170,16 @@ PHP_METHOD(Stub_SpectralNorm, Atu) { ZVAL_UNDEF(&_8$$4); ZVAL_UNDEF(&_10$$4); ZVAL_UNDEF(&_12$$4); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_LONG(n) + Z_PARAM_OBJECT_OF_CLASS(u, spl_ce_SplFixedArray) + Z_PARAM_OBJECT_OF_CLASS(v, spl_ce_SplFixedArray) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 3, 0, &n_param, &u, &v); @@ -189,7 +218,7 @@ PHP_METHOD(Stub_SpectralNorm, Atu) { j = _4$$3; ZVAL_LONG(&_7$$4, j); ZVAL_LONG(&_8$$4, i); - ZEPHIR_CALL_METHOD(&_6$$4, this_ptr, "ax", &_9, 80, &_7$$4, &_8$$4); + ZEPHIR_CALL_METHOD(&_6$$4, this_ptr, "ax", &_9, 90, &_7$$4, &_8$$4); zephir_check_call_status(); ZVAL_LONG(&_7$$4, j); ZEPHIR_CALL_METHOD(&_10$$4, u, "offsetget", &_11, 0, &_7$$4); @@ -220,15 +249,26 @@ PHP_METHOD(Stub_SpectralNorm, AtAu) { ZVAL_UNDEF(&u_sub); ZVAL_UNDEF(&v_sub); ZVAL_UNDEF(&w_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(4, 4) + Z_PARAM_ZVAL(n) + Z_PARAM_ZVAL(u) + Z_PARAM_ZVAL(v) + Z_PARAM_ZVAL(w) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 4, 0, &n, &u, &v, &w); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "au", NULL, 81, n, u, w); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "au", NULL, 91, n, u, w); zephir_check_call_status(); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "atu", NULL, 82, n, w, v); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "atu", NULL, 92, n, w, v); zephir_check_call_status(); ZEPHIR_MM_RESTORE(); @@ -255,6 +295,14 @@ PHP_METHOD(Stub_SpectralNorm, process) { ZVAL_UNDEF(&_18$$5); ZVAL_UNDEF(&_19$$5); ZVAL_UNDEF(&_20$$5); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(n) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &n_param); @@ -267,17 +315,17 @@ PHP_METHOD(Stub_SpectralNorm, process) { ZEPHIR_INIT_VAR(&u); object_init_ex(&u, spl_ce_SplFixedArray); ZVAL_LONG(&_0, n); - ZEPHIR_CALL_METHOD(NULL, &u, "__construct", NULL, 83, &_0); + ZEPHIR_CALL_METHOD(NULL, &u, "__construct", NULL, 93, &_0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&v); object_init_ex(&v, spl_ce_SplFixedArray); ZVAL_LONG(&_0, n); - ZEPHIR_CALL_METHOD(NULL, &v, "__construct", NULL, 83, &_0); + ZEPHIR_CALL_METHOD(NULL, &v, "__construct", NULL, 93, &_0); zephir_check_call_status(); ZEPHIR_INIT_VAR(&w); object_init_ex(&w, spl_ce_SplFixedArray); ZVAL_LONG(&_0, n); - ZEPHIR_CALL_METHOD(NULL, &w, "__construct", NULL, 83, &_0); + ZEPHIR_CALL_METHOD(NULL, &w, "__construct", NULL, 93, &_0); zephir_check_call_status(); _3 = (n - 1); _2 = 0; @@ -295,15 +343,15 @@ PHP_METHOD(Stub_SpectralNorm, process) { i = _2; ZVAL_LONG(&_4$$3, i); ZVAL_LONG(&_5$$3, 1); - ZEPHIR_CALL_METHOD(NULL, &u, "offsetset", &_6, 84, &_4$$3, &_5$$3); + ZEPHIR_CALL_METHOD(NULL, &u, "offsetset", &_6, 94, &_4$$3, &_5$$3); zephir_check_call_status(); ZVAL_LONG(&_4$$3, i); ZVAL_LONG(&_5$$3, 1); - ZEPHIR_CALL_METHOD(NULL, &v, "offsetset", &_6, 84, &_4$$3, &_5$$3); + ZEPHIR_CALL_METHOD(NULL, &v, "offsetset", &_6, 94, &_4$$3, &_5$$3); zephir_check_call_status(); ZVAL_LONG(&_4$$3, i); ZVAL_LONG(&_5$$3, 1); - ZEPHIR_CALL_METHOD(NULL, &w, "offsetset", &_6, 84, &_4$$3, &_5$$3); + ZEPHIR_CALL_METHOD(NULL, &w, "offsetset", &_6, 94, &_4$$3, &_5$$3); zephir_check_call_status(); } } @@ -322,10 +370,10 @@ PHP_METHOD(Stub_SpectralNorm, process) { } i = _8; ZVAL_LONG(&_10$$4, n); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "atau", &_11, 85, &_10$$4, &u, &v, &w); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "atau", &_11, 95, &_10$$4, &u, &v, &w); zephir_check_call_status(); ZVAL_LONG(&_10$$4, n); - ZEPHIR_CALL_METHOD(NULL, this_ptr, "atau", &_11, 85, &_10$$4, &v, &u, &w); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "atau", &_11, 95, &_10$$4, &v, &u, &w); zephir_check_call_status(); } } @@ -344,19 +392,19 @@ PHP_METHOD(Stub_SpectralNorm, process) { } i = _13; ZVAL_LONG(&_16$$5, i); - ZEPHIR_CALL_METHOD(&_15$$5, &u, "offsetget", &_17, 86, &_16$$5); + ZEPHIR_CALL_METHOD(&_15$$5, &u, "offsetget", &_17, 96, &_16$$5); zephir_check_call_status(); ZVAL_LONG(&_16$$5, i); - ZEPHIR_CALL_METHOD(&_18$$5, &v, "offsetget", &_17, 86, &_16$$5); + ZEPHIR_CALL_METHOD(&_18$$5, &v, "offsetget", &_17, 96, &_16$$5); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_19$$5); mul_function(&_19$$5, &_15$$5, &_18$$5); vBv += zephir_get_numberval(&_19$$5); ZVAL_LONG(&_16$$5, i); - ZEPHIR_CALL_METHOD(&_15$$5, &v, "offsetget", &_17, 86, &_16$$5); + ZEPHIR_CALL_METHOD(&_15$$5, &v, "offsetget", &_17, 96, &_16$$5); zephir_check_call_status(); ZVAL_LONG(&_16$$5, i); - ZEPHIR_CALL_METHOD(&_18$$5, &v, "offsetget", &_17, 86, &_16$$5); + ZEPHIR_CALL_METHOD(&_18$$5, &v, "offsetget", &_17, 96, &_16$$5); zephir_check_call_status(); ZEPHIR_INIT_NVAR(&_20$$5); mul_function(&_20$$5, &_15$$5, &_18$$5); diff --git a/ext/stub/spectralnorm.zep.h b/ext/stub/spectralnorm.zep.h index 20ac2135c7..fbeb754751 100644 --- a/ext/stub/spectralnorm.zep.h +++ b/ext/stub/spectralnorm.zep.h @@ -15,21 +15,13 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_spectralnorm_ax, 0, 0, 2) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_spectralnorm_au, 0, 0, 3) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, n) -#endif ZEND_ARG_OBJ_INFO(0, u, SplFixedArray, 0) ZEND_ARG_OBJ_INFO(0, v, SplFixedArray, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_spectralnorm_atu, 0, 0, 3) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, n) -#endif ZEND_ARG_OBJ_INFO(0, u, SplFixedArray, 0) ZEND_ARG_OBJ_INFO(0, v, SplFixedArray, 0) ZEND_END_ARG_INFO() @@ -42,11 +34,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_spectralnorm_atau, 0, 0, 4) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_spectralnorm_process, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, n, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, n) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_spectralnorm_method_entry) { diff --git a/ext/stub/spropertyaccess.zep.c b/ext/stub/spropertyaccess.zep.c index 0c245203f8..7eb5c9f00c 100644 --- a/ext/stub/spropertyaccess.zep.c +++ b/ext/stub/spropertyaccess.zep.c @@ -59,6 +59,7 @@ PHP_METHOD(Stub_SPropertyAccess, __construct) { ZVAL_UNDEF(&_3); ZVAL_UNDEF(&_4); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_ZVAL_NREF(_0); @@ -89,6 +90,15 @@ PHP_METHOD(Stub_SPropertyAccess, testArgumentWithUnderscore) { ZVAL_UNDEF(&delimiter_sub); ZVAL_NULL(&__$null); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(delimiter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &delimiter); @@ -119,6 +129,15 @@ PHP_METHOD(Stub_SPropertyAccess, testArgument) { ZVAL_UNDEF(&delimiter_sub); ZVAL_NULL(&__$null); ZVAL_UNDEF(&_0$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(delimiter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &delimiter); @@ -154,6 +173,7 @@ PHP_METHOD(Stub_SPropertyAccess, mutateStringVarInsideCycle) { ZVAL_UNDEF(&_3$$3); ZVAL_UNDEF(&_4$$3); + ZEPHIR_MM_GROW(); _2 = 3; @@ -198,6 +218,7 @@ PHP_METHOD(Stub_SPropertyAccess, mutateIntVarInsideCycle) { ZVAL_UNDEF(&_3$$3); + _2 = 3; _1 = 0; _0 = 0; @@ -238,6 +259,7 @@ PHP_METHOD(Stub_SPropertyAccess, mutateDoubleVarInsideCycle) { ZVAL_UNDEF(&_3$$3); + _2 = 3; _1 = 0; _0 = 0; @@ -277,6 +299,7 @@ PHP_METHOD(Stub_SPropertyAccess, mutateArrayVarInsideCycle) { ZVAL_UNDEF(&_3$$3); ZVAL_UNDEF(&_4$$3); + ZEPHIR_MM_GROW(); _2 = 3; @@ -314,6 +337,7 @@ void zephir_init_static_properties_Stub_SPropertyAccess() { zephir_method_globals *ZEPHIR_METHOD_GLOBALS_PTR = NULL; ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); diff --git a/ext/stub/spropertyaccess.zep.h b/ext/stub/spropertyaccess.zep.h index 37861b9cfc..798cd7f4df 100644 --- a/ext/stub/spropertyaccess.zep.h +++ b/ext/stub/spropertyaccess.zep.h @@ -23,39 +23,27 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_spropertyaccess_testargument, 0, 0, 0) ZEND_ARG_INFO(0, delimiter) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_spropertyaccess_mutatestringvarinsidecycle, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_spropertyaccess_mutatestringvarinsidecycle, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_spropertyaccess_mutateintvarinsidecycle, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_spropertyaccess_mutateintvarinsidecycle, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_spropertyaccess_mutatedoublevarinsidecycle, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_spropertyaccess_mutatedoublevarinsidecycle, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_spropertyaccess_mutatearrayvarinsidecycle, 0, 0, IS_ARRAY, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_spropertyaccess_mutatearrayvarinsidecycle, 0, 0, IS_ARRAY, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_spropertyaccess_zephir_init_static_properties_stub_spropertyaccess, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_spropertyaccess_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_SPropertyAccess, __construct, arginfo_stub_spropertyaccess___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#else + PHP_ME(Stub_SPropertyAccess, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) +#endif PHP_ME(Stub_SPropertyAccess, testArgumentWithUnderscore, arginfo_stub_spropertyaccess_testargumentwithunderscore, ZEND_ACC_PUBLIC) PHP_ME(Stub_SPropertyAccess, testArgument, arginfo_stub_spropertyaccess_testargument, ZEND_ACC_PUBLIC) PHP_ME(Stub_SPropertyAccess, mutateStringVarInsideCycle, arginfo_stub_spropertyaccess_mutatestringvarinsidecycle, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) diff --git a/ext/stub/statements.zep.c b/ext/stub/statements.zep.c index 27e6b59495..353c8b2157 100644 --- a/ext/stub/statements.zep.c +++ b/ext/stub/statements.zep.c @@ -66,6 +66,7 @@ PHP_METHOD(Stub_Statements, testPropertyAcccessAvoidTmpReuse) { ZVAL_UNDEF(&_6); ZVAL_UNDEF(&_7); + ZEPHIR_MM_GROW(); zephir_read_property(&_0, this_ptr, ZEND_STRL("tmp2"), PH_NOISY_CC | PH_READONLY); @@ -94,6 +95,14 @@ PHP_METHOD(Stub_Statements, testElseIf) { zend_long num; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &num_param); @@ -118,6 +127,14 @@ PHP_METHOD(Stub_Statements, testElseIf1) { zend_long num, total; zval *this_ptr = getThis(); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(num) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &num_param); @@ -142,6 +159,15 @@ PHP_METHOD(Stub_Statements, testElseIf2) { zval *this_ptr = getThis(); ZVAL_UNDEF(&total_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_LONG(num) + Z_PARAM_ZVAL(total) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &num_param, &total); @@ -181,6 +207,14 @@ PHP_METHOD(Stub_Statements, test544Issue) { ZVAL_UNDEF(&_13$$4); ZVAL_UNDEF(&_14$$5); ZVAL_UNDEF(&_15$$5); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(step) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &step_param); @@ -202,25 +236,25 @@ PHP_METHOD(Stub_Statements, test544Issue) { unfilledWidth = (((zephir_get_numberval(&_4$$3) - 1)) - filledWidth); zephir_read_property(&_5$$3, this_ptr, ZEND_STRL("filledChar"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_6$$3, filledWidth); - ZEPHIR_CALL_FUNCTION(&_7$$3, "str_repeat", &_8, 19, &_5$$3, &_6$$3); + ZEPHIR_CALL_FUNCTION(&_7$$3, "str_repeat", &_8, 21, &_5$$3, &_6$$3); zephir_check_call_status(); zephir_read_property(&_6$$3, this_ptr, ZEND_STRL("arrow"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_9$$3, this_ptr, ZEND_STRL("unfilledChar"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_10$$3, unfilledWidth); - ZEPHIR_CALL_FUNCTION(&_11$$3, "str_repeat", &_8, 19, &_9$$3, &_10$$3); + ZEPHIR_CALL_FUNCTION(&_11$$3, "str_repeat", &_8, 21, &_9$$3, &_10$$3); zephir_check_call_status(); ZEPHIR_CONCAT_VVV(return_value, &_7$$3, &_6$$3, &_11$$3); RETURN_MM(); } else if (ZEPHIR_IS_LONG_IDENTICAL(&_1, step)) { zephir_read_property(&_12$$4, this_ptr, ZEND_STRL("filledChar"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_13$$4, this_ptr, ZEND_STRL("width"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_8, 19, &_12$$4, &_13$$4); + ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_8, 21, &_12$$4, &_13$$4); zephir_check_call_status(); RETURN_MM(); } else { zephir_read_property(&_14$$5, this_ptr, ZEND_STRL("unfilledChar"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_15$$5, this_ptr, ZEND_STRL("width"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_8, 19, &_14$$5, &_15$$5); + ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_8, 21, &_14$$5, &_15$$5); zephir_check_call_status(); RETURN_MM(); } @@ -248,6 +282,14 @@ PHP_METHOD(Stub_Statements, test544IssueWithVariable) { ZVAL_UNDEF(&_11$$4); ZVAL_UNDEF(&_12$$5); ZVAL_UNDEF(&_13$$5); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_LONG(step) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &step_param); @@ -268,25 +310,25 @@ PHP_METHOD(Stub_Statements, test544IssueWithVariable) { unfilledWidth = (((zephir_get_numberval(&_2$$3) - 1)) - filledWidth); zephir_read_property(&_3$$3, this_ptr, ZEND_STRL("filledChar"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_4$$3, filledWidth); - ZEPHIR_CALL_FUNCTION(&_5$$3, "str_repeat", &_6, 19, &_3$$3, &_4$$3); + ZEPHIR_CALL_FUNCTION(&_5$$3, "str_repeat", &_6, 21, &_3$$3, &_4$$3); zephir_check_call_status(); zephir_read_property(&_4$$3, this_ptr, ZEND_STRL("arrow"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_7$$3, this_ptr, ZEND_STRL("unfilledChar"), PH_NOISY_CC | PH_READONLY); ZVAL_LONG(&_8$$3, unfilledWidth); - ZEPHIR_CALL_FUNCTION(&_9$$3, "str_repeat", &_6, 19, &_7$$3, &_8$$3); + ZEPHIR_CALL_FUNCTION(&_9$$3, "str_repeat", &_6, 21, &_7$$3, &_8$$3); zephir_check_call_status(); ZEPHIR_CONCAT_VVV(return_value, &_5$$3, &_4$$3, &_9$$3); RETURN_MM(); } else if (step == totalSteps) { zephir_read_property(&_10$$4, this_ptr, ZEND_STRL("filledChar"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_11$$4, this_ptr, ZEND_STRL("width"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_6, 19, &_10$$4, &_11$$4); + ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_6, 21, &_10$$4, &_11$$4); zephir_check_call_status(); RETURN_MM(); } else { zephir_read_property(&_12$$5, this_ptr, ZEND_STRL("unfilledChar"), PH_NOISY_CC | PH_READONLY); zephir_read_property(&_13$$5, this_ptr, ZEND_STRL("width"), PH_NOISY_CC | PH_READONLY); - ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_6, 19, &_12$$5, &_13$$5); + ZEPHIR_RETURN_CALL_FUNCTION("str_repeat", &_6, 21, &_12$$5, &_13$$5); zephir_check_call_status(); RETURN_MM(); } diff --git a/ext/stub/statements.zep.h b/ext/stub/statements.zep.h index 6cae5a19d2..fb266864d1 100644 --- a/ext/stub/statements.zep.h +++ b/ext/stub/statements.zep.h @@ -14,48 +14,32 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_statements_testpropertyacccessavoidtmpreuse, ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_statements_testelseif, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_statements_testelseif1, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_statements_testelseif2, 0, 0, 2) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, num) -#endif ZEND_ARG_INFO(0, total) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_statements_test544issue, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, step, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, step) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_statements_test544issuewithvariable, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, step, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, step) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_statements_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Statements, testPropertyAcccessAvoidTmpReuse, arginfo_stub_statements_testpropertyacccessavoidtmpreuse, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Statements, testPropertyAcccessAvoidTmpReuse, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Statements, testElseIf, arginfo_stub_statements_testelseif, ZEND_ACC_PUBLIC) PHP_ME(Stub_Statements, testElseIf1, arginfo_stub_statements_testelseif1, ZEND_ACC_PUBLIC) PHP_ME(Stub_Statements, testElseIf2, arginfo_stub_statements_testelseif2, ZEND_ACC_PUBLIC) diff --git a/ext/stub/strings.zep.c b/ext/stub/strings.zep.c index 0a53298620..41125e2456 100644 --- a/ext/stub/strings.zep.c +++ b/ext/stub/strings.zep.c @@ -38,6 +38,16 @@ PHP_METHOD(Stub_Strings, camelize) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&delimiter_sub); ZVAL_NULL(&__$null); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_STR(str) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(delimiter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &str_param, &delimiter); @@ -64,6 +74,16 @@ PHP_METHOD(Stub_Strings, uncamelize) { ZVAL_UNDEF(&str); ZVAL_UNDEF(&delimiter_sub); ZVAL_NULL(&__$null); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_STR(str) + Z_PARAM_OPTIONAL + Z_PARAM_ZVAL(delimiter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, &str_param, &delimiter); @@ -86,6 +106,14 @@ PHP_METHOD(Stub_Strings, testTrim) { zval *this_ptr = getThis(); ZVAL_UNDEF(&str_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &str); @@ -102,6 +130,14 @@ PHP_METHOD(Stub_Strings, testRtrim) { zval *this_ptr = getThis(); ZVAL_UNDEF(&str_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &str); @@ -118,6 +154,14 @@ PHP_METHOD(Stub_Strings, testLtrim) { zval *this_ptr = getThis(); ZVAL_UNDEF(&str_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &str); @@ -135,6 +179,15 @@ PHP_METHOD(Stub_Strings, testTrim2Params) { ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&charlist_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(str) + Z_PARAM_ZVAL(charlist) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &str, &charlist); @@ -152,6 +205,15 @@ PHP_METHOD(Stub_Strings, testRtrim2Params) { ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&charlist_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(str) + Z_PARAM_ZVAL(charlist) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &str, &charlist); @@ -169,6 +231,15 @@ PHP_METHOD(Stub_Strings, testLtrim2Params) { ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&charlist_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(str) + Z_PARAM_ZVAL(charlist) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &str, &charlist); @@ -186,6 +257,15 @@ PHP_METHOD(Stub_Strings, testImplode) { ZVAL_UNDEF(&glue_sub); ZVAL_UNDEF(&pieces_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(glue) + Z_PARAM_ZVAL(pieces) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &glue, &pieces); @@ -203,6 +283,15 @@ PHP_METHOD(Stub_Strings, testStrpos) { ZVAL_UNDEF(&haystack_sub); ZVAL_UNDEF(&needle_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(haystack) + Z_PARAM_ZVAL(needle) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &haystack, &needle); @@ -222,6 +311,16 @@ PHP_METHOD(Stub_Strings, testStrposOffset) { ZVAL_UNDEF(&haystack_sub); ZVAL_UNDEF(&needle_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_ZVAL(haystack) + Z_PARAM_ZVAL(needle) + Z_PARAM_LONG(offset) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(3, 0, &haystack, &needle, &offset_param); @@ -241,6 +340,15 @@ PHP_METHOD(Stub_Strings, testExplode) { ZVAL_UNDEF(&delimiter_sub); ZVAL_UNDEF(&str_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(delimiter) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &delimiter, &str); @@ -257,6 +365,14 @@ PHP_METHOD(Stub_Strings, testExplodeStr) { zval *this_ptr = getThis(); ZVAL_UNDEF(&str_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &str); @@ -275,6 +391,15 @@ PHP_METHOD(Stub_Strings, testExplodeLimit) { ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(str) + Z_PARAM_LONG(limit) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &str, &limit_param); @@ -296,6 +421,16 @@ PHP_METHOD(Stub_Strings, testSubstr) { ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_ZVAL(str) + Z_PARAM_LONG(from) + Z_PARAM_LONG(len) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(3, 0, &str, &from_param, &len_param); @@ -318,6 +453,15 @@ PHP_METHOD(Stub_Strings, testSubstr2) { ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(str) + Z_PARAM_LONG(from) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &str, &from_param); @@ -337,6 +481,14 @@ PHP_METHOD(Stub_Strings, testSubstr3) { ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &str); @@ -356,6 +508,14 @@ PHP_METHOD(Stub_Strings, testSubstr4) { ZVAL_UNDEF(&str_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &str); @@ -374,6 +534,14 @@ PHP_METHOD(Stub_Strings, testAddslashes) { zval *this_ptr = getThis(); ZVAL_UNDEF(&str_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &str); @@ -390,6 +558,14 @@ PHP_METHOD(Stub_Strings, testStripslashes) { zval *this_ptr = getThis(); ZVAL_UNDEF(&str_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &str); @@ -406,6 +582,14 @@ PHP_METHOD(Stub_Strings, testStripcslashes) { zval *this_ptr = getThis(); ZVAL_UNDEF(&str_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(str) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &str); @@ -423,6 +607,15 @@ PHP_METHOD(Stub_Strings, testHashEquals) { ZVAL_UNDEF(&str1_sub); ZVAL_UNDEF(&str2_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(str1) + Z_PARAM_ZVAL(str2) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &str1, &str2); @@ -437,6 +630,7 @@ PHP_METHOD(Stub_Strings, testHardcodedMultilineString) { zval *this_ptr = getThis(); + RETURN_STRING("\n Hello world\n "); } @@ -446,6 +640,7 @@ PHP_METHOD(Stub_Strings, testEchoMultilineString) { zval *this_ptr = getThis(); + php_printf("%s", "\n Hello world\n "); } @@ -458,6 +653,7 @@ PHP_METHOD(Stub_Strings, testTrimMultilineString) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -475,6 +671,7 @@ PHP_METHOD(Stub_Strings, testWellEscapedMultilineString) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -489,6 +686,7 @@ PHP_METHOD(Stub_Strings, testInternedString1) { zval *this_ptr = getThis(); + RETURN_STRING("hello"); } @@ -502,6 +700,7 @@ PHP_METHOD(Stub_Strings, testInternedString2) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -528,6 +727,14 @@ PHP_METHOD(Stub_Strings, strToHex) { ZVAL_UNDEF(&_2$$3); ZVAL_UNDEF(&_3$$3); ZVAL_UNDEF(&_5$$3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &value_param); @@ -545,7 +752,7 @@ PHP_METHOD(Stub_Strings, strToHex) { _1$$3 = ZEPHIR_STRING_OFFSET(&value, i); ZEPHIR_INIT_NVAR(&_2$$3); ZVAL_STRINGL(&_2$$3, &_1$$3, 1); - ZEPHIR_CALL_FUNCTION(&_3$$3, "ord", &_4, 87, &_2$$3); + ZEPHIR_CALL_FUNCTION(&_3$$3, "ord", &_4, 97, &_2$$3); zephir_check_call_status(); ZEPHIR_CALL_FUNCTION(&_5$$3, "dechex", &_6, 10, &_3$$3); zephir_check_call_status(); @@ -574,6 +781,14 @@ PHP_METHOD(Stub_Strings, issue1267) { ZVAL_UNDEF(&_6); ZVAL_UNDEF(&_7); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &value); @@ -598,17 +813,17 @@ PHP_METHOD(Stub_Strings, issue1267) { zephir_fast_str_replace(&_0, &_1, &_2, value); ZEPHIR_CPY_WRT(value, &_0); ZVAL_LONG(&_3, 513); - ZEPHIR_CALL_FUNCTION(&_4, "filter_var", NULL, 88, value, &_3); + ZEPHIR_CALL_FUNCTION(&_4, "filter_var", NULL, 43, value, &_3); zephir_check_call_status(); ZEPHIR_CPY_WRT(value, &_4); ZEPHIR_INIT_NVAR(&_0); - ZEPHIR_CALL_FUNCTION(&_4, "strip_tags", &_5, 89, value); + ZEPHIR_CALL_FUNCTION(&_4, "strip_tags", &_5, 98, value); zephir_check_call_status(); zephir_stripslashes(&_0, &_4); ZEPHIR_INIT_VAR(&x); zephir_fast_trim(&x, &_0, NULL , ZEPHIR_TRIM_BOTH); ZEPHIR_INIT_VAR(&_6); - ZEPHIR_CALL_FUNCTION(&_7, "strip_tags", &_5, 89, value); + ZEPHIR_CALL_FUNCTION(&_7, "strip_tags", &_5, 98, value); zephir_check_call_status(); zephir_stripcslashes(&_6, &_7); zephir_fast_trim(return_value, &_6, NULL , ZEPHIR_TRIM_BOTH); diff --git a/ext/stub/strings.zep.h b/ext/stub/strings.zep.h index 78023de750..8963b682fd 100644 --- a/ext/stub/strings.zep.h +++ b/ext/stub/strings.zep.h @@ -35,20 +35,12 @@ PHP_METHOD(Stub_Strings, strToHex); PHP_METHOD(Stub_Strings, issue1267); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_strings_camelize, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_ARG_INFO(0, delimiter) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_strings_uncamelize, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, str) -#endif ZEND_ARG_INFO(0, delimiter) ZEND_END_ARG_INFO() @@ -92,11 +84,7 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_strings_teststrposoffset, 0, 0, 3) ZEND_ARG_INFO(0, haystack) ZEND_ARG_INFO(0, needle) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, offset, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, offset) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_strings_testexplode, 0, 0, 2) @@ -110,34 +98,18 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_strings_testexplodelimit, 0, 0, 2) ZEND_ARG_INFO(0, str) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, limit, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, limit) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_strings_testsubstr, 0, 0, 3) ZEND_ARG_INFO(0, str) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, from, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, from) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, len, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, len) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_strings_testsubstr2, 0, 0, 2) ZEND_ARG_INFO(0, str) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, from, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, from) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_strings_testsubstr3, 0, 0, 1) @@ -156,19 +128,11 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_strings_teststripslashes, 0, 0, 1) ZEND_ARG_INFO(0, str) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_strings_teststripcslashes, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_strings_teststripcslashes, 0, 1, IS_STRING, NULL, 0) -#endif ZEND_ARG_INFO(0, str) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_strings_testhashequals, 0, 2, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_strings_testhashequals, 0, 2, _IS_BOOL, NULL, 0) -#endif ZEND_ARG_INFO(0, str1) ZEND_ARG_INFO(0, str2) ZEND_END_ARG_INFO() @@ -191,16 +155,8 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_strings_testinternedstring2, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_strings_strtohex, 0, 1, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_strings_strtohex, 0, 1, IS_STRING, NULL, 0) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, value, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, value) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_strings_issue1267, 0, 0, 1) @@ -230,12 +186,36 @@ ZEPHIR_INIT_FUNCS(stub_strings_method_entry) { PHP_ME(Stub_Strings, testStripslashes, arginfo_stub_strings_teststripslashes, ZEND_ACC_PUBLIC) PHP_ME(Stub_Strings, testStripcslashes, arginfo_stub_strings_teststripcslashes, ZEND_ACC_PUBLIC) PHP_ME(Stub_Strings, testHashEquals, arginfo_stub_strings_testhashequals, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Strings, testHardcodedMultilineString, arginfo_stub_strings_testhardcodedmultilinestring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Strings, testHardcodedMultilineString, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Strings, testEchoMultilineString, arginfo_stub_strings_testechomultilinestring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Strings, testEchoMultilineString, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Strings, testTrimMultilineString, arginfo_stub_strings_testtrimmultilinestring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Strings, testTrimMultilineString, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Strings, testWellEscapedMultilineString, arginfo_stub_strings_testwellescapedmultilinestring, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Strings, testWellEscapedMultilineString, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Strings, testInternedString1, arginfo_stub_strings_testinternedstring1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Strings, testInternedString1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Strings, testInternedString2, arginfo_stub_strings_testinternedstring2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Strings, testInternedString2, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Strings, strToHex, arginfo_stub_strings_strtohex, ZEND_ACC_PUBLIC) PHP_ME(Stub_Strings, issue1267, arginfo_stub_strings_issue1267, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/stubs.zep.c b/ext/stub/stubs.zep.c index 5c82194756..2c88a08e76 100644 --- a/ext/stub/stubs.zep.c +++ b/ext/stub/stubs.zep.c @@ -54,6 +54,7 @@ PHP_METHOD(Stub_Stubs, testDockBlockAndReturnType) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propString"); } @@ -68,6 +69,7 @@ PHP_METHOD(Stub_Stubs, testDocBlockAndReturnTypeDeclared) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "propStringProtected"); } @@ -87,6 +89,16 @@ PHP_METHOD(Stub_Stubs, testMixedInputParamsDocBlock) { zval *this_ptr = getThis(); ZVAL_UNDEF(&intOrString_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(intOrString) + Z_PARAM_OPTIONAL + Z_PARAM_LONG(number) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 1, &intOrString, &number_param); @@ -117,6 +129,16 @@ PHP_METHOD(Stub_Stubs, testMixedInputParamsDocBlockDeclared) { zval *this_ptr = getThis(); ZVAL_UNDEF(&intOrString_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_ZVAL(intOrString) + Z_PARAM_OPTIONAL + Z_PARAM_LONG(number) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 1, &intOrString, &number_param); diff --git a/ext/stub/stubs.zep.h b/ext/stub/stubs.zep.h index 098d1a7bbb..719bf21527 100644 --- a/ext/stub/stubs.zep.h +++ b/ext/stub/stubs.zep.h @@ -8,44 +8,20 @@ PHP_METHOD(Stub_Stubs, testDocBlockAndReturnTypeDeclared); PHP_METHOD(Stub_Stubs, testMixedInputParamsDocBlock); PHP_METHOD(Stub_Stubs, testMixedInputParamsDocBlockDeclared); -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_stubs_testdockblockandreturntype, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_stubs_testdockblockandreturntype, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_stubs_testdocblockandreturntypedeclared, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_stubs_testdocblockandreturntypedeclared, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_stubs_testmixedinputparamsdocblock, 0, 1, IS_LONG, 1) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_stubs_testmixedinputparamsdocblock, 0, 1, IS_LONG, NULL, 1) -#endif ZEND_ARG_INFO(0, intOrString) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, number, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, number) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_stubs_testmixedinputparamsdocblockdeclared, 0, 1, IS_LONG, 1) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_stubs_testmixedinputparamsdocblockdeclared, 0, 1, IS_LONG, NULL, 1) -#endif ZEND_ARG_INFO(0, intOrString) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, number, IS_LONG, 0) -#else - ZEND_ARG_INFO(0, number) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_stubs_method_entry) { diff --git a/ext/stub/ternary.zep.c b/ext/stub/ternary.zep.c index 8b1d6301bd..997bf60ed5 100644 --- a/ext/stub/ternary.zep.c +++ b/ext/stub/ternary.zep.c @@ -39,6 +39,7 @@ PHP_METHOD(Stub_Ternary, testTernary1) { ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -59,6 +60,14 @@ PHP_METHOD(Stub_Ternary, testTernary2) { zval *this_ptr = getThis(); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_BOOL(b) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &b_param); @@ -87,6 +96,15 @@ PHP_METHOD(Stub_Ternary, testTernaryComplex1) { ZVAL_UNDEF(&y_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(y) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &y); @@ -122,6 +140,15 @@ PHP_METHOD(Stub_Ternary, testTernaryComplex2) { ZVAL_UNDEF(&y_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(a) + Z_PARAM_ZVAL(y) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &a, &y); @@ -155,6 +182,14 @@ PHP_METHOD(Stub_Ternary, testTernaryComplex3) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a); @@ -188,6 +223,7 @@ PHP_METHOD(Stub_Ternary, testTernaryWithPromotedTemporaryVariable) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&var2); @@ -223,6 +259,7 @@ PHP_METHOD(Stub_Ternary, testTernaryAfterLetVariable) { ZVAL_UNDEF(&s); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&s); @@ -246,6 +283,14 @@ PHP_METHOD(Stub_Ternary, testShortTernary) { ZVAL_UNDEF(&a_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a); @@ -271,6 +316,15 @@ PHP_METHOD(Stub_Ternary, testShortTernaryComplex) { ZVAL_UNDEF(&left_sub); ZVAL_UNDEF(&value_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(left) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &left, &value); diff --git a/ext/stub/ternary.zep.h b/ext/stub/ternary.zep.h index 1bd77593da..48e20926e5 100644 --- a/ext/stub/ternary.zep.h +++ b/ext/stub/ternary.zep.h @@ -17,11 +17,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_ternary_testternary1, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_ternary_testternary2, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, b, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, b) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_ternary_testternarycomplex1, 0, 0, 2) @@ -54,13 +50,25 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_ternary_testshortternarycomplex, 0, 0, 2) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_ternary_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Ternary, testTernary1, arginfo_stub_ternary_testternary1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Ternary, testTernary1, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Ternary, testTernary2, arginfo_stub_ternary_testternary2, ZEND_ACC_PUBLIC) PHP_ME(Stub_Ternary, testTernaryComplex1, arginfo_stub_ternary_testternarycomplex1, ZEND_ACC_PUBLIC) PHP_ME(Stub_Ternary, testTernaryComplex2, arginfo_stub_ternary_testternarycomplex2, ZEND_ACC_PUBLIC) PHP_ME(Stub_Ternary, testTernaryComplex3, arginfo_stub_ternary_testternarycomplex3, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Ternary, testTernaryWithPromotedTemporaryVariable, arginfo_stub_ternary_testternarywithpromotedtemporaryvariable, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Ternary, testTernaryWithPromotedTemporaryVariable, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Ternary, testTernaryAfterLetVariable, arginfo_stub_ternary_testternaryafterletvariable, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Ternary, testTernaryAfterLetVariable, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Ternary, testShortTernary, arginfo_stub_ternary_testshortternary, ZEND_ACC_PUBLIC) PHP_ME(Stub_Ternary, testShortTernaryComplex, arginfo_stub_ternary_testshortternarycomplex, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/trytest.zep.c b/ext/stub/trytest.zep.c index 3b6607144e..1268bb5540 100644 --- a/ext/stub/trytest.zep.c +++ b/ext/stub/trytest.zep.c @@ -33,7 +33,8 @@ PHP_METHOD(Stub_TryTest, testThrow1) { zval *this_ptr = getThis(); - ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(zend_exception_get_default(), "error", "stub/trytest.zep", 10); + + ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(zend_ce_exception, "error", "stub/trytest.zep", 10); return; } @@ -48,13 +49,14 @@ PHP_METHOD(Stub_TryTest, testThrow2) { ZVAL_UNDEF(&message); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&message); ZVAL_STRING(&message, "error"); ZEPHIR_INIT_VAR(&_0); - object_init_ex(&_0, zend_exception_get_default()); - ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 26, &message); + object_init_ex(&_0, zend_ce_exception); + ZEPHIR_CALL_METHOD(NULL, &_0, "__construct", NULL, 28, &message); zephir_check_call_status(); zephir_throw_exception_debug(&_0, "stub/trytest.zep", 16); ZEPHIR_MM_RESTORE(); @@ -68,6 +70,7 @@ PHP_METHOD(Stub_TryTest, testTry1) { + /* try_start_1: */ @@ -87,16 +90,17 @@ PHP_METHOD(Stub_TryTest, testTry2) { ZVAL_UNDEF(&_0$$3); ZVAL_UNDEF(&_1$$3); + ZEPHIR_MM_GROW(); /* try_start_1: */ ZEPHIR_INIT_VAR(&_0$$3); - object_init_ex(&_0$$3, zend_exception_get_default()); + object_init_ex(&_0$$3, zend_ce_exception); ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "error!"); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 26, &_1$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 28, &_1$$3); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_0$$3, "stub/trytest.zep", 27); goto try_end_1; @@ -120,16 +124,17 @@ PHP_METHOD(Stub_TryTest, testTry3) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); + ZEPHIR_MM_GROW(); /* try_start_1: */ ZEPHIR_INIT_VAR(&_0$$3); - object_init_ex(&_0$$3, zend_exception_get_default()); + object_init_ex(&_0$$3, zend_ce_exception); ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "error!"); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 26, &_1$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 28, &_1$$3); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_0$$3, "stub/trytest.zep", 34); goto try_end_1; @@ -142,7 +147,7 @@ PHP_METHOD(Stub_TryTest, testTry3) { ZVAL_OBJ(&_2, EG(exception)); Z_ADDREF_P(&_2); ZEPHIR_INIT_VAR(&_3); - if (zephir_instance_of_ev(&_2, zend_exception_get_default())) { + if (zephir_instance_of_ev(&_2, zend_ce_exception)) { zend_clear_exception(); ZEPHIR_CPY_WRT(&_3, &_2); RETURN_MM_STRING("error"); @@ -167,6 +172,14 @@ PHP_METHOD(Stub_TryTest, testTry4) { ZVAL_UNDEF(&_4); ZVAL_UNDEF(&_5); ZVAL_UNDEF(&_6); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_BOOL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); @@ -179,10 +192,10 @@ PHP_METHOD(Stub_TryTest, testTry4) { if (a) { ZEPHIR_INIT_VAR(&_0$$4); - object_init_ex(&_0$$4, zend_exception_get_default()); + object_init_ex(&_0$$4, zend_ce_exception); ZEPHIR_INIT_VAR(&_1$$4); ZVAL_STRING(&_1$$4, "error!"); - ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 26, &_1$$4); + ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 28, &_1$$4); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_0$$4, "stub/trytest.zep", 46); goto try_end_1; @@ -192,7 +205,7 @@ PHP_METHOD(Stub_TryTest, testTry4) { object_init_ex(&_2$$5, spl_ce_RuntimeException); ZEPHIR_INIT_VAR(&_3$$5); ZVAL_STRING(&_3$$5, "error!"); - ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 90, &_3$$5); + ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 99, &_3$$5); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_2$$5, "stub/trytest.zep", 48); goto try_end_1; @@ -212,7 +225,7 @@ PHP_METHOD(Stub_TryTest, testTry4) { ZEPHIR_CPY_WRT(&_5, &_4); RETURN_MM_STRING("domain error"); } else { - if (zephir_instance_of_ev(&_4, zend_exception_get_default())) { + if (zephir_instance_of_ev(&_4, zend_ce_exception)) { zend_clear_exception(); ZEPHIR_CPY_WRT(&_6, &_4); RETURN_MM_STRING("error"); @@ -237,6 +250,14 @@ PHP_METHOD(Stub_TryTest, testTry5) { ZVAL_UNDEF(&_3$$5); ZVAL_UNDEF(&_4); ZVAL_UNDEF(&_5); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_BOOL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); @@ -249,10 +270,10 @@ PHP_METHOD(Stub_TryTest, testTry5) { if (a) { ZEPHIR_INIT_VAR(&_0$$4); - object_init_ex(&_0$$4, zend_exception_get_default()); + object_init_ex(&_0$$4, zend_ce_exception); ZEPHIR_INIT_VAR(&_1$$4); ZVAL_STRING(&_1$$4, "error!"); - ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 26, &_1$$4); + ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 28, &_1$$4); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_0$$4, "stub/trytest.zep", 63); goto try_end_1; @@ -262,7 +283,7 @@ PHP_METHOD(Stub_TryTest, testTry5) { object_init_ex(&_2$$5, spl_ce_RuntimeException); ZEPHIR_INIT_VAR(&_3$$5); ZVAL_STRING(&_3$$5, "error!"); - ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 90, &_3$$5); + ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 99, &_3$$5); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_2$$5, "stub/trytest.zep", 65); goto try_end_1; @@ -281,7 +302,7 @@ PHP_METHOD(Stub_TryTest, testTry5) { ZEPHIR_CPY_WRT(&_5, &_4); RETURN_MM_STRING("any error"); } else { - if (zephir_instance_of_ev(&_4, zend_exception_get_default())) { + if (zephir_instance_of_ev(&_4, zend_ce_exception)) { zend_clear_exception(); ZEPHIR_CPY_WRT(&_5, &_4); RETURN_MM_STRING("any error"); @@ -306,6 +327,14 @@ PHP_METHOD(Stub_TryTest, testTry6) { ZVAL_UNDEF(&_1$$4); ZVAL_UNDEF(&_2$$5); ZVAL_UNDEF(&_3$$5); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_BOOL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); @@ -318,10 +347,10 @@ PHP_METHOD(Stub_TryTest, testTry6) { if (a) { ZEPHIR_INIT_VAR(&_0$$4); - object_init_ex(&_0$$4, zend_exception_get_default()); + object_init_ex(&_0$$4, zend_ce_exception); ZEPHIR_INIT_VAR(&_1$$4); ZVAL_STRING(&_1$$4, "error!"); - ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 26, &_1$$4); + ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 28, &_1$$4); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_0$$4, "stub/trytest.zep", 80); goto try_end_1; @@ -331,7 +360,7 @@ PHP_METHOD(Stub_TryTest, testTry6) { object_init_ex(&_2$$5, spl_ce_RuntimeException); ZEPHIR_INIT_VAR(&_3$$5); ZVAL_STRING(&_3$$5, "error!"); - ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 90, &_3$$5); + ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 99, &_3$$5); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_2$$5, "stub/trytest.zep", 82); goto try_end_1; @@ -349,7 +378,7 @@ PHP_METHOD(Stub_TryTest, testTry6) { ZEPHIR_CPY_WRT(&e, &_4); RETURN_MM_STRING("domain error"); } else { - if (zephir_instance_of_ev(&_4, zend_exception_get_default())) { + if (zephir_instance_of_ev(&_4, zend_ce_exception)) { zend_clear_exception(); ZEPHIR_CPY_WRT(&e, &_4); RETURN_MM_STRING("error"); @@ -374,6 +403,14 @@ PHP_METHOD(Stub_TryTest, testTry7) { ZVAL_UNDEF(&_1$$4); ZVAL_UNDEF(&_2$$5); ZVAL_UNDEF(&_3$$5); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_BOOL(a) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &a_param); @@ -386,10 +423,10 @@ PHP_METHOD(Stub_TryTest, testTry7) { if (a) { ZEPHIR_INIT_VAR(&_0$$4); - object_init_ex(&_0$$4, zend_exception_get_default()); + object_init_ex(&_0$$4, zend_ce_exception); ZEPHIR_INIT_VAR(&_1$$4); ZVAL_STRING(&_1$$4, "error!"); - ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 26, &_1$$4); + ZEPHIR_CALL_METHOD(NULL, &_0$$4, "__construct", NULL, 28, &_1$$4); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_0$$4, "stub/trytest.zep", 99); goto try_end_1; @@ -399,7 +436,7 @@ PHP_METHOD(Stub_TryTest, testTry7) { object_init_ex(&_2$$5, spl_ce_RuntimeException); ZEPHIR_INIT_VAR(&_3$$5); ZVAL_STRING(&_3$$5, "error!"); - ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 90, &_3$$5); + ZEPHIR_CALL_METHOD(NULL, &_2$$5, "__construct", NULL, 99, &_3$$5); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_2$$5, "stub/trytest.zep", 101); goto try_end_1; @@ -417,7 +454,7 @@ PHP_METHOD(Stub_TryTest, testTry7) { ZEPHIR_CPY_WRT(&e, &_4); RETURN_MM_STRING("any error"); } else { - if (zephir_instance_of_ev(&_4, zend_exception_get_default())) { + if (zephir_instance_of_ev(&_4, zend_ce_exception)) { zend_clear_exception(); ZEPHIR_CPY_WRT(&e, &_4); RETURN_MM_STRING("any error"); @@ -437,16 +474,17 @@ PHP_METHOD(Stub_TryTest, testTry8) { ZVAL_UNDEF(&_0$$3); ZVAL_UNDEF(&_1$$3); + ZEPHIR_MM_GROW(); /* try_start_1: */ ZEPHIR_INIT_VAR(&_0$$3); - object_init_ex(&_0$$3, zend_exception_get_default()); + object_init_ex(&_0$$3, zend_ce_exception); ZEPHIR_INIT_VAR(&_1$$3); ZVAL_STRING(&_1$$3, "error 1!"); - ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 26, &_1$$3); + ZEPHIR_CALL_METHOD(NULL, &_0$$3, "__construct", NULL, 28, &_1$$3); zephir_check_call_status_or_jump(try_end_1); zephir_throw_exception_debug(&_0$$3, "stub/trytest.zep", 111); goto try_end_1; @@ -455,7 +493,7 @@ PHP_METHOD(Stub_TryTest, testTry8) { try_end_1: zend_clear_exception(); - ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_exception_get_default(), "error 2!", "stub/trytest.zep", 113); + ZEPHIR_THROW_EXCEPTION_DEBUG_STR(zend_ce_exception, "error 2!", "stub/trytest.zep", 113); return; } @@ -465,6 +503,7 @@ PHP_METHOD(Stub_TryTest, someMethod1) { zval *this_ptr = getThis(); + ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(spl_ce_RuntimeException, "some external exception", "stub/trytest.zep", 118); return; @@ -475,6 +514,7 @@ PHP_METHOD(Stub_TryTest, someMethod2) { zval *this_ptr = getThis(); + ZEPHIR_THROW_EXCEPTION_DEBUG_STRW(spl_ce_DomainException, "some external exception", "stub/trytest.zep", 123); return; @@ -490,12 +530,13 @@ PHP_METHOD(Stub_TryTest, testTry9) { ZVAL_UNDEF(&e); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); /* try_start_1: */ - ZEPHIR_CALL_METHOD(NULL, this_ptr, "somemethod1", NULL, 91); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "somemethod1", NULL, 100); zephir_check_call_status_or_jump(try_end_1); RETURN_MM_STRING("not catched"); @@ -525,12 +566,13 @@ PHP_METHOD(Stub_TryTest, testTry10) { ZVAL_UNDEF(&e); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); /* try_start_1: */ - ZEPHIR_CALL_METHOD(NULL, this_ptr, "somemethod2", NULL, 92); + ZEPHIR_CALL_METHOD(NULL, this_ptr, "somemethod2", NULL, 101); zephir_check_call_status_or_jump(try_end_1); RETURN_MM_STRING("not catched"); @@ -559,6 +601,7 @@ PHP_METHOD(Stub_TryTest, testTry11) { ZVAL_UNDEF(&ex); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); @@ -572,7 +615,7 @@ PHP_METHOD(Stub_TryTest, testTry11) { ZEPHIR_INIT_VAR(&_0); ZVAL_OBJ(&_0, EG(exception)); Z_ADDREF_P(&_0); - if (zephir_instance_of_ev(&_0, zend_exception_get_default())) { + if (zephir_instance_of_ev(&_0, zend_ce_exception)) { zend_clear_exception(); ZEPHIR_CPY_WRT(&ex, &_0); } diff --git a/ext/stub/trytest.zep.h b/ext/stub/trytest.zep.h index 34bd2a1b44..aa4e7f609b 100644 --- a/ext/stub/trytest.zep.h +++ b/ext/stub/trytest.zep.h @@ -35,35 +35,19 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_trytest_testtry3, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_trytest_testtry4, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_trytest_testtry5, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_trytest_testtry6, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_trytest_testtry7, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, a, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, a) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_trytest_testtry8, 0, 0, 0) @@ -85,20 +69,64 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_trytest_testtry11, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_trytest_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TryTest, testThrow1, arginfo_stub_trytest_testthrow1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TryTest, testThrow1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TryTest, testThrow2, arginfo_stub_trytest_testthrow2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TryTest, testThrow2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TryTest, testTry1, arginfo_stub_trytest_testtry1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TryTest, testTry1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TryTest, testTry2, arginfo_stub_trytest_testtry2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TryTest, testTry2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TryTest, testTry3, arginfo_stub_trytest_testtry3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TryTest, testTry3, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_TryTest, testTry4, arginfo_stub_trytest_testtry4, ZEND_ACC_PUBLIC) PHP_ME(Stub_TryTest, testTry5, arginfo_stub_trytest_testtry5, ZEND_ACC_PUBLIC) PHP_ME(Stub_TryTest, testTry6, arginfo_stub_trytest_testtry6, ZEND_ACC_PUBLIC) PHP_ME(Stub_TryTest, testTry7, arginfo_stub_trytest_testtry7, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TryTest, testTry8, arginfo_stub_trytest_testtry8, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TryTest, testTry8, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TryTest, someMethod1, arginfo_stub_trytest_somemethod1, ZEND_ACC_PRIVATE) +#else + PHP_ME(Stub_TryTest, someMethod1, NULL, ZEND_ACC_PRIVATE) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TryTest, someMethod2, arginfo_stub_trytest_somemethod2, ZEND_ACC_PRIVATE) +#else + PHP_ME(Stub_TryTest, someMethod2, NULL, ZEND_ACC_PRIVATE) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TryTest, testTry9, arginfo_stub_trytest_testtry9, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TryTest, testTry9, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TryTest, testTry10, arginfo_stub_trytest_testtry10, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TryTest, testTry10, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TryTest, testTry11, arginfo_stub_trytest_testtry11, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TryTest, testTry11, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/typehinting/testabstract.zep.h b/ext/stub/typehinting/testabstract.zep.h index cabce5bf6e..5814bdac46 100644 --- a/ext/stub/typehinting/testabstract.zep.h +++ b/ext/stub/typehinting/testabstract.zep.h @@ -16,85 +16,45 @@ PHP_METHOD(Stub_TypeHinting_TestAbstract, returnChar); ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_typehinting_testabstract_testfunc, 0, 0, 0) ZEND_ARG_ARRAY_INFO(0, text, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, text2, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, text2) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, flag, _IS_BOOL, 0) -#else - ZEND_ARG_INFO(0, flag) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, optional, IS_LONG, 1) -#else - ZEND_ARG_INFO(0, optional) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_typehinting_testabstract_returnoneofscalar, 0, 0, 0) ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnint, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnint, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnuint, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnuint, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnlong, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnlong, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnfloat, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnfloat, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returndouble, 0, 0, IS_DOUBLE, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returndouble, 0, 0, IS_DOUBLE, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnstring, 0, 0, IS_STRING, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnstring, 0, 0, IS_STRING, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnboolean, 0, 0, _IS_BOOL, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnboolean, 0, 0, _IS_BOOL, NULL, 0) -#endif ZEND_END_ARG_INFO() -#if PHP_VERSION_ID >= 70200 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnchar, 0, 0, IS_LONG, 0) -#else -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stub_typehinting_testabstract_returnchar, 0, 0, IS_LONG, NULL, 0) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_typehinting_testabstract_method_entry) { PHP_ME(Stub_TypeHinting_TestAbstract, testFunc, arginfo_stub_typehinting_testabstract_testfunc, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TypeHinting_TestAbstract, returnOneOfScalar, arginfo_stub_typehinting_testabstract_returnoneofscalar, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TypeHinting_TestAbstract, returnOneOfScalar, NULL, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_TypeHinting_TestAbstract, returnInt, arginfo_stub_typehinting_testabstract_returnint, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) PHP_ME(Stub_TypeHinting_TestAbstract, returnUint, arginfo_stub_typehinting_testabstract_returnuint, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) PHP_ME(Stub_TypeHinting_TestAbstract, returnLong, arginfo_stub_typehinting_testabstract_returnlong, ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC) diff --git a/ext/stub/typeinstances.zep.c b/ext/stub/typeinstances.zep.c index 4164300a1e..8b54e52ffa 100644 --- a/ext/stub/typeinstances.zep.c +++ b/ext/stub/typeinstances.zep.c @@ -42,6 +42,7 @@ PHP_METHOD(Stub_TypeInstances, testInstanceOfString1) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, 24); @@ -64,6 +65,7 @@ PHP_METHOD(Stub_TypeInstances, testInstanceOfString2) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, -24); @@ -86,6 +88,7 @@ PHP_METHOD(Stub_TypeInstances, testInstanceOfString3) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZVAL_LONG(&_0, 0); diff --git a/ext/stub/typeinstances.zep.h b/ext/stub/typeinstances.zep.h index c98de1dca7..0ead29c972 100644 --- a/ext/stub/typeinstances.zep.h +++ b/ext/stub/typeinstances.zep.h @@ -17,8 +17,20 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_typeinstances_testinstanceofstring3, 0, 0, 0 ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_typeinstances_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TypeInstances, testInstanceOfString1, arginfo_stub_typeinstances_testinstanceofstring1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TypeInstances, testInstanceOfString1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TypeInstances, testInstanceOfString2, arginfo_stub_typeinstances_testinstanceofstring2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TypeInstances, testInstanceOfString2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_TypeInstances, testInstanceOfString3, arginfo_stub_typeinstances_testinstanceofstring3, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_TypeInstances, testInstanceOfString3, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/typeoff.zep.c b/ext/stub/typeoff.zep.c index e12d6c32f0..6aadf9be51 100644 --- a/ext/stub/typeoff.zep.c +++ b/ext/stub/typeoff.zep.c @@ -37,6 +37,7 @@ PHP_METHOD(Stub_Typeoff, testNativeStringFalse) { ZVAL_UNDEF(&testVar); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&testVar); @@ -53,6 +54,7 @@ PHP_METHOD(Stub_Typeoff, testNativeStringTrue) { ZVAL_UNDEF(&testVar); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&testVar); @@ -68,6 +70,7 @@ PHP_METHOD(Stub_Typeoff, testNativeIntFalse) { + testVar = 12345; RETURN_BOOL(1 == 0); @@ -80,6 +83,7 @@ PHP_METHOD(Stub_Typeoff, testNativeIntTrue) { + testVar = 12345; RETURN_BOOL(1 == 1); @@ -92,6 +96,7 @@ PHP_METHOD(Stub_Typeoff, testNativeDoubleTrue) { + testVar = (double) (12345); RETURN_BOOL(1 == 1); @@ -104,6 +109,7 @@ PHP_METHOD(Stub_Typeoff, testNativeBoolTrue) { + testVar = 1; RETURN_BOOL(1 == 1); @@ -117,6 +123,7 @@ PHP_METHOD(Stub_Typeoff, testNotBoolTrue) { ZVAL_UNDEF(&testVar); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&testVar); @@ -134,6 +141,7 @@ PHP_METHOD(Stub_Typeoff, testNativeBoolFalse) { + testVar = 0; RETURN_BOOL(1 == 0); @@ -147,6 +155,7 @@ PHP_METHOD(Stub_Typeoff, testArrayFalse) { ZVAL_UNDEF(&testVar); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&testVar); @@ -163,6 +172,7 @@ PHP_METHOD(Stub_Typeoff, testArrayTrue) { ZVAL_UNDEF(&testVar); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&testVar); @@ -180,6 +190,7 @@ PHP_METHOD(Stub_Typeoff, testClassPropertyAccess) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&_0); @@ -200,6 +211,14 @@ PHP_METHOD(Stub_Typeoff, testUnknownTypeOf) { ZVAL_UNDEF(&u_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(u) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &u); @@ -218,6 +237,14 @@ PHP_METHOD(Stub_Typeoff, testCallableTypeOf) { zval *this_ptr = getThis(); ZVAL_UNDEF(&cb_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(cb) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &cb); diff --git a/ext/stub/typeoff.zep.h b/ext/stub/typeoff.zep.h index 4f640aaa31..fff8eb9b6a 100644 --- a/ext/stub/typeoff.zep.h +++ b/ext/stub/typeoff.zep.h @@ -59,17 +59,61 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_typeoff_testcallabletypeof, 0, 0, 1) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_typeoff_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Typeoff, testNativeStringFalse, arginfo_stub_typeoff_testnativestringfalse, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Typeoff, testNativeStringFalse, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Typeoff, testNativeStringTrue, arginfo_stub_typeoff_testnativestringtrue, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Typeoff, testNativeStringTrue, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Typeoff, testNativeIntFalse, arginfo_stub_typeoff_testnativeintfalse, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Typeoff, testNativeIntFalse, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Typeoff, testNativeIntTrue, arginfo_stub_typeoff_testnativeinttrue, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Typeoff, testNativeIntTrue, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Typeoff, testNativeDoubleTrue, arginfo_stub_typeoff_testnativedoubletrue, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Typeoff, testNativeDoubleTrue, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Typeoff, testNativeBoolTrue, arginfo_stub_typeoff_testnativebooltrue, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Typeoff, testNativeBoolTrue, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Typeoff, testNotBoolTrue, arginfo_stub_typeoff_testnotbooltrue, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Typeoff, testNotBoolTrue, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Typeoff, testNativeBoolFalse, arginfo_stub_typeoff_testnativeboolfalse, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Typeoff, testNativeBoolFalse, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Typeoff, testArrayFalse, arginfo_stub_typeoff_testarrayfalse, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Typeoff, testArrayFalse, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Typeoff, testArrayTrue, arginfo_stub_typeoff_testarraytrue, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Typeoff, testArrayTrue, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Typeoff, testClassPropertyAccess, arginfo_stub_typeoff_testclasspropertyaccess, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Typeoff, testClassPropertyAccess, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Typeoff, testUnknownTypeOf, arginfo_stub_typeoff_testunknowntypeof, ZEND_ACC_PUBLIC) PHP_ME(Stub_Typeoff, testCallableTypeOf, arginfo_stub_typeoff_testcallabletypeof, ZEND_ACC_PUBLIC) PHP_FE_END diff --git a/ext/stub/unsettest.zep.c b/ext/stub/unsettest.zep.c index d62364bb19..cfd3458105 100644 --- a/ext/stub/unsettest.zep.c +++ b/ext/stub/unsettest.zep.c @@ -36,6 +36,7 @@ PHP_METHOD(Stub_Unsettest, getProperty) { zval *this_ptr = getThis(); + RETURN_MEMBER(getThis(), "property"); } @@ -47,6 +48,14 @@ PHP_METHOD(Stub_Unsettest, has) { ZVAL_UNDEF(&key_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(key) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &key); @@ -64,6 +73,15 @@ PHP_METHOD(Stub_Unsettest, addValueToProperty) { ZVAL_UNDEF(&key_sub); ZVAL_UNDEF(&value_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(key) + Z_PARAM_ZVAL(value) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &key, &value); @@ -80,6 +98,14 @@ PHP_METHOD(Stub_Unsettest, testUnsetValueFromProperty) { ZVAL_UNDEF(&key_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(key) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(1, 0, &key); @@ -97,6 +123,14 @@ PHP_METHOD(Stub_Unsettest, testUnsetFromArray) { zval *this_ptr = getThis(); ZVAL_UNDEF(&arrayParameter_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(arrayParameter) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &arrayParameter); @@ -118,6 +152,15 @@ PHP_METHOD(Stub_Unsettest, testUnsetFromArrayByIndexVar) { ZVAL_UNDEF(&arrayParameter_sub); ZVAL_UNDEF(&index_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(arrayParameter) + Z_PARAM_ZVAL(index) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &arrayParameter, &index); @@ -136,6 +179,7 @@ PHP_METHOD(Stub_Unsettest, testUnsetProperty) { zval *this_ptr = getThis(); + zephir_unset_property(this_ptr, "property"); RETURN_MEMBER(getThis(), "property"); @@ -151,6 +195,7 @@ PHP_METHOD(Stub_Unsettest, testStdClassUnset) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&simpleObject); @@ -180,6 +225,15 @@ PHP_METHOD(Stub_Unsettest, testUnsetTypedArray) { ZVAL_UNDEF(&arr); ZVAL_UNDEF(&key); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ARRAY(arr) + Z_PARAM_STR(key) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 2, 0, &arr_param, &key_param); diff --git a/ext/stub/unsettest.zep.h b/ext/stub/unsettest.zep.h index ac21df0cd6..068f5147b5 100644 --- a/ext/stub/unsettest.zep.h +++ b/ext/stub/unsettest.zep.h @@ -46,22 +46,30 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_unsettest_testunsettypedarray, 0, 0, 2) ZEND_ARG_ARRAY_INFO(0, arr, 0) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, key, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, key) -#endif ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_unsettest_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Unsettest, getProperty, arginfo_stub_unsettest_getproperty, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Unsettest, getProperty, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Unsettest, has, arginfo_stub_unsettest_has, ZEND_ACC_PUBLIC) PHP_ME(Stub_Unsettest, addValueToProperty, arginfo_stub_unsettest_addvaluetoproperty, ZEND_ACC_PUBLIC) PHP_ME(Stub_Unsettest, testUnsetValueFromProperty, arginfo_stub_unsettest_testunsetvaluefromproperty, ZEND_ACC_PUBLIC) PHP_ME(Stub_Unsettest, testUnsetFromArray, arginfo_stub_unsettest_testunsetfromarray, ZEND_ACC_PUBLIC) PHP_ME(Stub_Unsettest, testUnsetFromArrayByIndexVar, arginfo_stub_unsettest_testunsetfromarraybyindexvar, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Unsettest, testUnsetProperty, arginfo_stub_unsettest_testunsetproperty, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Unsettest, testUnsetProperty, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Unsettest, testStdClassUnset, arginfo_stub_unsettest_teststdclassunset, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Unsettest, testStdClassUnset, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Unsettest, testUnsetTypedArray, arginfo_stub_unsettest_testunsettypedarray, ZEND_ACC_PUBLIC) PHP_FE_END }; diff --git a/ext/stub/usetest.zep.c b/ext/stub/usetest.zep.c index b240cacfe5..f499a178a6 100644 --- a/ext/stub/usetest.zep.c +++ b/ext/stub/usetest.zep.c @@ -12,7 +12,6 @@ #include #include "kernel/main.h" -#include "ext/spl/spl_iterators.h" #include "kernel/object.h" #include "kernel/fcall.h" #include "kernel/memory.h" @@ -22,7 +21,7 @@ ZEPHIR_INIT_CLASS(Stub_UseTest) { ZEPHIR_REGISTER_CLASS(Stub, UseTest, stub, usetest, stub_usetest_method_entry, 0); - zend_class_implements(stub_usetest_ce, 1, spl_ce_Countable); + zend_class_implements(stub_usetest_ce, 1, zend_ce_countable); return SUCCESS; } @@ -32,6 +31,7 @@ PHP_METHOD(Stub_UseTest, createInstance) { zval *this_ptr = getThis(); + object_init(return_value); return; @@ -43,6 +43,7 @@ PHP_METHOD(Stub_UseTest, count) { + } PHP_METHOD(Stub_UseTest, testUseClass1) { @@ -53,6 +54,7 @@ PHP_METHOD(Stub_UseTest, testUseClass1) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); if (!_0) { @@ -75,6 +77,7 @@ PHP_METHOD(Stub_UseTest, testUseClass2) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); if (!_0) { @@ -97,6 +100,7 @@ PHP_METHOD(Stub_UseTest, testUseNamespaceAlias) { zval *this_ptr = getThis(); + ZEPHIR_MM_GROW(); if (!_0) { diff --git a/ext/stub/usetest.zep.h b/ext/stub/usetest.zep.h index 4f3dcba99a..d0a0d0fa0e 100644 --- a/ext/stub/usetest.zep.h +++ b/ext/stub/usetest.zep.h @@ -25,10 +25,30 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_usetest_testusenamespacealias, 0, 0, 0) ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_usetest_method_entry) { +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_UseTest, createInstance, arginfo_stub_usetest_createinstance, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_UseTest, createInstance, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_UseTest, count, arginfo_stub_usetest_count, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_UseTest, count, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_UseTest, testUseClass1, arginfo_stub_usetest_testuseclass1, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_UseTest, testUseClass1, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_UseTest, testUseClass2, arginfo_stub_usetest_testuseclass2, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_UseTest, testUseClass2, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_UseTest, testUseNamespaceAlias, arginfo_stub_usetest_testusenamespacealias, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_UseTest, testUseNamespaceAlias, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END }; diff --git a/ext/stub/vars.zep.c b/ext/stub/vars.zep.c index 6a137878d0..c40c3be492 100644 --- a/ext/stub/vars.zep.c +++ b/ext/stub/vars.zep.c @@ -48,6 +48,14 @@ PHP_METHOD(Stub_Vars, testParam) { ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_5$$3); ZVAL_UNDEF(&_7$$4); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ARRAY(config) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &config_param); @@ -68,7 +76,7 @@ PHP_METHOD(Stub_Vars, testParam) { } ZEPHIR_INIT_NVAR(&v); ZVAL_COPY(&v, _1); - ZEPHIR_CALL_FUNCTION(&_5$$3, "realpath", &_6, 56, &v); + ZEPHIR_CALL_FUNCTION(&_5$$3, "realpath", &_6, 59, &v); zephir_check_call_status(); zephir_array_update_multi(&config, &_5$$3, SL("sz"), 3, SL("dir"), &k); } ZEND_HASH_FOREACH_END(); @@ -85,7 +93,7 @@ PHP_METHOD(Stub_Vars, testParam) { zephir_check_call_status(); ZEPHIR_CALL_METHOD(&v, &_0, "current", NULL, 0); zephir_check_call_status(); - ZEPHIR_CALL_FUNCTION(&_7$$4, "realpath", &_6, 56, &v); + ZEPHIR_CALL_FUNCTION(&_7$$4, "realpath", &_6, 59, &v); zephir_check_call_status(); zephir_array_update_multi(&config, &_7$$4, SL("sz"), 3, SL("dir"), &k); ZEPHIR_CALL_METHOD(NULL, &_0, "next", NULL, 0); @@ -109,6 +117,7 @@ PHP_METHOD(Stub_Vars, testVarDump) { ZVAL_UNDEF(&ar); ZVAL_UNDEF(&_0); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -136,6 +145,14 @@ PHP_METHOD(Stub_Vars, testVarDump2) { ZVAL_UNDEF(&ret_sub); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(ret) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &ret); @@ -164,6 +181,7 @@ PHP_METHOD(Stub_Vars, testVarExport) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); + ZEPHIR_MM_GROW(); ZEPHIR_INIT_VAR(&a); @@ -204,6 +222,16 @@ PHP_METHOD(Stub_Vars, test88Issue) { ZVAL_UNDEF(&_1); ZVAL_UNDEF(&_2); ZVAL_UNDEF(&_3); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_STR(param1) + Z_PARAM_OPTIONAL + Z_PARAM_STR_OR_NULL(param2) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, ¶m1_param, ¶m2_param); @@ -252,6 +280,16 @@ PHP_METHOD(Stub_Vars, test88IssueParam2InitString) { ZVAL_UNDEF(¶m1); ZVAL_UNDEF(¶m2); ZVAL_UNDEF(&_0); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_STR(param1) + Z_PARAM_OPTIONAL + Z_PARAM_STR(param2) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 1, ¶m1_param, ¶m2_param); @@ -288,6 +326,15 @@ PHP_METHOD(Stub_Vars, testVarDump2param) { ZVAL_UNDEF(&p1_sub); ZVAL_UNDEF(&p2_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_ZVAL(p1) + Z_PARAM_ZVAL(p2) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(2, 0, &p1, &p2); @@ -306,6 +353,16 @@ PHP_METHOD(Stub_Vars, testVarDump3param) { ZVAL_UNDEF(&p1_sub); ZVAL_UNDEF(&p2_sub); ZVAL_UNDEF(&p3_sub); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(3, 3) + Z_PARAM_ZVAL(p1) + Z_PARAM_ZVAL(p2) + Z_PARAM_ZVAL(p3) + ZEND_PARSE_PARAMETERS_END(); + +#endif + zephir_fetch_params_without_memory_grow(3, 0, &p1, &p2, &p3); @@ -326,6 +383,14 @@ PHP_METHOD(Stub_Vars, testCountOptimizerVarDumpAndExport) { ZVAL_UNDEF(&testVar_sub); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_ZVAL(testVar) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 1, 0, &testVar); @@ -354,6 +419,15 @@ PHP_METHOD(Stub_Vars, testArrayTypeVarDumpAndExport) { ZVAL_UNDEF(&testVar); ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); +#if PHP_VERSION_ID >= 80000 + bool is_null_true = 1; + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_ARRAY(testVar) + ZEND_PARSE_PARAMETERS_END(); + +#endif + ZEPHIR_MM_GROW(); zephir_fetch_params(1, 0, 1, &testVar_param); @@ -389,6 +463,7 @@ PHP_METHOD(Stub_Vars, testIntVarDump) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); a = 1; @@ -414,6 +489,7 @@ PHP_METHOD(Stub_Vars, testDoubleVarDump) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); a = (double) (1); @@ -439,6 +515,7 @@ PHP_METHOD(Stub_Vars, testBoolVarDump) { ZVAL_UNDEF(&_0); ZVAL_UNDEF(&_1); + ZEPHIR_MM_GROW(); a = 1; @@ -462,6 +539,7 @@ PHP_METHOD(Stub_Vars, testGetDefinedVars) { + a = 1; pi = 3.14; zephir_get_defined_vars(return_value); diff --git a/ext/stub/vars.zep.h b/ext/stub/vars.zep.h index bb337bafbf..eb1e2008ef 100644 --- a/ext/stub/vars.zep.h +++ b/ext/stub/vars.zep.h @@ -33,29 +33,13 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_vars_testvarexport, 0, 0, 0) ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_vars_test88issue, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, param1, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, param1) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, param2, IS_STRING, 1) -#else - ZEND_ARG_INFO(0, param2) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_vars_test88issueparam2initstring, 0, 0, 1) -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, param1, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, param1) -#endif -#if PHP_VERSION_ID >= 70200 ZEND_ARG_TYPE_INFO(0, param2, IS_STRING, 0) -#else - ZEND_ARG_INFO(0, param2) -#endif ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_INFO_EX(arginfo_stub_vars_testvardump2param, 0, 0, 2) @@ -91,18 +75,42 @@ ZEND_END_ARG_INFO() ZEPHIR_INIT_FUNCS(stub_vars_method_entry) { PHP_ME(Stub_Vars, testParam, arginfo_stub_vars_testparam, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Vars, testVarDump, arginfo_stub_vars_testvardump, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Vars, testVarDump, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Vars, testVarDump2, arginfo_stub_vars_testvardump2, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Vars, testVarExport, arginfo_stub_vars_testvarexport, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Vars, testVarExport, NULL, ZEND_ACC_PUBLIC) +#endif PHP_ME(Stub_Vars, test88Issue, arginfo_stub_vars_test88issue, ZEND_ACC_PUBLIC) PHP_ME(Stub_Vars, test88IssueParam2InitString, arginfo_stub_vars_test88issueparam2initstring, ZEND_ACC_PUBLIC) PHP_ME(Stub_Vars, testVarDump2param, arginfo_stub_vars_testvardump2param, ZEND_ACC_PUBLIC) PHP_ME(Stub_Vars, testVarDump3param, arginfo_stub_vars_testvardump3param, ZEND_ACC_PUBLIC) PHP_ME(Stub_Vars, testCountOptimizerVarDumpAndExport, arginfo_stub_vars_testcountoptimizervardumpandexport, ZEND_ACC_PUBLIC) PHP_ME(Stub_Vars, testArrayTypeVarDumpAndExport, arginfo_stub_vars_testarraytypevardumpandexport, ZEND_ACC_PUBLIC) +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Vars, testIntVarDump, arginfo_stub_vars_testintvardump, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Vars, testIntVarDump, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Vars, testDoubleVarDump, arginfo_stub_vars_testdoublevardump, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Vars, testDoubleVarDump, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Vars, testBoolVarDump, arginfo_stub_vars_testboolvardump, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Vars, testBoolVarDump, NULL, ZEND_ACC_PUBLIC) +#endif +#if PHP_VERSION_ID >= 80000 PHP_ME(Stub_Vars, testGetDefinedVars, arginfo_stub_vars_testgetdefinedvars, ZEND_ACC_PUBLIC) +#else + PHP_ME(Stub_Vars, testGetDefinedVars, NULL, ZEND_ACC_PUBLIC) +#endif PHP_FE_END };