From 764f5b4a2c6c40aa5b337259288b59fc9407e74c Mon Sep 17 00:00:00 2001 From: Remi Collet Date: Wed, 25 Mar 2026 14:59:04 +0100 Subject: drop pear/pecl dependency sources from github --- php-pecl-fann.spec | 50 +- phpc.h | 1610 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1637 insertions(+), 23 deletions(-) create mode 100644 phpc.h diff --git a/php-pecl-fann.spec b/php-pecl-fann.spec index 7a60d1b..8ee020d 100644 --- a/php-pecl-fann.spec +++ b/php-pecl-fann.spec @@ -3,7 +3,7 @@ # # Fedora spec file for php-pecl-fann # -# SPDX-FileCopyrightText: Copyright 2013-2025 Remi Collet +# SPDX-FileCopyrightText: Copyright 2013-2026 Remi Collet # SPDX-License-Identifier: CECILL-2.1 # http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt # @@ -20,30 +20,40 @@ %global upstream_version 1.2.0 #global upstream_prever RC2 -%global sources %{pecl_name}-%{upstream_version}%{?upstream_prever} +%global sources %{gh_proj}-%{upstream_version}%{?upstream_prever} %global _configure ../%{sources}/configure -Summary: Wrapper for FANN Library +# Github forge +%global gh_vend bukka +%global gh_proj php-fann +%global forgeurl https://github.com/%{gh_vend}/%{gh_proj} +%global tag %{upstream_version}%{?upstream_prever} + Name: %{?scl_prefix}php-pecl-%{pecl_name} -Version: %{upstream_version}%{?upstream_prever:~%{upstream_prever}} -Release: 3%{?dist}%{!?nophptag:%(%{__php} -r 'echo ".".PHP_MAJOR_VERSION.".".PHP_MINOR_VERSION;')} +Summary: Wrapper for FANN Library License: PHP-3.01 -URL: https://pecl.php.net/package/%{pecl_name} -Source0: https://pecl.php.net/get/%{sources}.tgz +Version: %{upstream_version}%{?upstream_prever:~%{upstream_prever}} +Release: 4%{?dist} +%forgemeta +URL: %{forgeurl} +Source0: %{forgesource} +Source1: https://raw.githubusercontent.com/bukka/phpc/8ffc867f050ab63b162dca25dbca60c4b4579b77/phpc.h BuildRequires: make BuildRequires: %{?dtsprefix}gcc BuildRequires: fann-devel > 2.1 BuildRequires: %{?scl_prefix}php-devel -BuildRequires: %{?scl_prefix}php-pear Requires: %{?scl_prefix}php(zend-abi) = %{php_zend_api} Requires: %{?scl_prefix}php(api) = %{php_core_api} +# Extension Provides: %{?scl_prefix}php-%{pecl_name} = %{version} Provides: %{?scl_prefix}php-%{pecl_name}%{?_isa} = %{version} +# PECL Provides: %{?scl_prefix}php-pecl(%{pecl_name}) = %{version} Provides: %{?scl_prefix}php-pecl(%{pecl_name})%{?_isa} = %{version} +# No PIE for now %description @@ -58,12 +68,9 @@ Package built for PHP %(%{__php} -r 'echo PHP_MAJOR_VERSION.".".PHP_MINOR_VERSIO %prep %setup -q -c -# Don't install tests -sed -e 's/role="test"/role="src"/' \ - -e '/LICENSE/s/role="doc"/role="src"/' \ - -i package.xml - cd %{sources} +cp %{SOURCE1} phpc/ + # Sanity check, really often broken extver=$(sed -n '/#define PHP_FANN_VERSION/{s/.* "//;s/".*$//;p}' php_fann.h) if test "x${extver}" != "x%{upstream_version}%{?upstream_prever}"; then @@ -113,20 +120,12 @@ cd ../ZTS # install config file install -D -m 644 %{ini_name} %{buildroot}%{php_inidir}/%{ini_name} -# Install XML package description -install -D -m 644 package.xml %{buildroot}%{pecl_xmldir}/%{name}.xml - %if %{with_zts} %make_install -C ZTS install -D -m 644 %{ini_name} %{buildroot}%{php_ztsinidir}/%{ini_name} %endif -# Documentation -for i in $(grep 'role="doc"' package.xml | sed -e 's/^.*name="//;s/".*$//') -do install -Dpm 644 %{sources}/$i %{buildroot}%{pecl_docdir}/%{pecl_name}/$i -done - %check cd %{sources} @@ -158,10 +157,11 @@ REPORT_EXIT_STATUS=1 \ %files -%doc %{pecl_docdir}/%{pecl_name} %license %{sources}/LICENSE +%doc %{sources}/CREDITS +%doc %{sources}/*.md +%doc %{sources}/examples -%{pecl_xmldir}/%{name}.xml %config(noreplace) %{php_inidir}/%{ini_name} %{php_extdir}/%{pecl_name}.so @@ -172,6 +172,10 @@ REPORT_EXIT_STATUS=1 \ %changelog +* Wed Mar 25 2026 Remi Collet - 1.2.0-4 +- drop pear/pecl dependency +- sources from github + * Thu Sep 25 2025 Remi Collet - 1.2.0-3 - rebuild for PHP 8.5.0RC1 diff --git a/phpc.h b/phpc.h new file mode 100644 index 0000000..4b55747 --- /dev/null +++ b/phpc.h @@ -0,0 +1,1610 @@ +/* + * Copyright (c) 2014-2016 Jakub Zelenka. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + */ + + +#ifndef PHPC_H +#define PHPC_H + +#if PHP_VERSION_ID < 50199 +#error "Only PHP 5.2+ supported" +#endif + +/* no operation */ +#define PHPC_NOOP ((void) 0) + +/* COMMON (used definitions) */ + +/* common object macros */ +#define PHPC_CLASS_TYPE _phpc_class_type +#define PHPC_SELF _phpc_self +#define PHPC_OBJ_STRUCT_NAME(_name) struct _phpc_##_name##__obj +#define PHPC_OBJ_STRUCT_DECLARE(_name, _ptr) PHPC_OBJ_STRUCT_NAME(_name) *_ptr +#define PHPC_OBJ_GET_HANDLER_FCE(_name, _type) _name##__##_type +#define PHPC_OBJ_DEFINE_HANDLER_FCE(_rtype, _name, _type) \ + static _rtype PHPC_OBJ_GET_HANDLER_FCE(_name, _type) +#define PHPC_OBJ_GET_HANDLER_FCE_INLINE_DEF(_rtype, _name, _type) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(inline _rtype, _name, _type) +#define PHPC_OBJ_GET_HANDLER_VAR_NAME(_name) _phpc_##_name##__handlers +#define PHPC_OBJ_DEFINE_HANDLER_VAR(_name) \ + static zend_object_handlers PHPC_OBJ_GET_HANDLER_VAR_NAME(_name) +#define PHPC_OBJ_INIT_HANDLERS(_name) \ + memcpy(&PHPC_OBJ_GET_HANDLER_VAR_NAME(_name), \ + zend_get_std_object_handlers(), sizeof(zend_object_handlers)) + +/* ZEND_ACC_CTOR and ZEND_ACC_DTOR is removed in 7.4 */ +#ifndef ZEND_ACC_CTOR +#define ZEND_ACC_CTOR 0 +#endif +#ifndef ZEND_ACC_DTOR +#define ZEND_ACC_DTOR 0 +#endif + +#if PHP_VERSION_ID < 50299 +#define phpc_function_entry zend_function_entry +#else +#define phpc_function_entry const zend_function_entry +#endif + +#if PHP_VERSION_ID < 50399 +/* initializing properties in obejct (object_properties_init was added in PHP 5.4) */ +#define PHPC_OBJ_PROPERTIES_INIT(_zo, _class_type) \ + do { \ + zval *_phpc_tmp; \ + zend_hash_copy((*(_zo)).properties, \ + &(_class_type)->default_properties, \ + (copy_ctor_func_t) zval_add_ref, \ + (void *) &_phpc_tmp, \ + sizeof(zval *)); \ + } while(0) + +/* write property */ +#define PHPC_OBJ_STD_WRITE_PROPERTY(_obj, _member, _value) \ + Z_OBJ_HT_P(_obj)->write_property(_obj, _member, _value TSRMLS_CC) +#else +#define PHPC_OBJ_PROPERTIES_INIT object_properties_init +#define PHPC_OBJ_STD_WRITE_PROPERTY(_obj, _member, _value) \ + zend_std_write_property(_obj, _member, _value, NULL TSRMLS_CC) +#endif + +/* common fcall macros */ +#define PHPC_FCALL_PARAMS_NAME(_pname) _phpc_fcall_params__ ## _pname + +/* integer conversions */ +#define PHPC_CONVERT_NUMBER(_pn, _n, _exc_over, _exc_under, _type_from, _type_to, _max, _min) \ + if (_pn > (_type_from) _max) { \ + _exc_over; \ + } else if (_pn < (_type_from) _min) { \ + _exc_under; \ + } \ + _n = (_type_to) _pn + +#define PHPC_CONVERT_NUMBER_SIGNED(_pn, _n, _exc_over, _type_from, _type_to, _max) \ + if (_pn > (_type_from) _max) { \ + _exc_over; \ + } \ + _n = (_type_to) _pn + +#define PHPC_LONG_TO_INT_EX2(_plv, _lv, _exc_over, _exc_under) \ + PHPC_CONVERT_NUMBER(_plv, _lv, _exc_over, _exc_under, long, int, INT_MAX, INT_MIN) +#define PHPC_LONG_TO_INT_EX(_plv, _lv, _exc) \ + PHPC_LONG_TO_INT_EX2(_plv, _lv, _exc, _exc) +#define PHPC_LONG_TO_INT(_plv, _lv) \ + PHPC_LONG_TO_INT_EX2(_plv, _lv, _lv = INT_MAX, _lv = INT_MIN) + + +#if PHP_MAJOR_VERSION < 8 +/* PHP 5 and 7 */ +/* object */ +#define phpc_obj_t zval +#define PHPC_OBJ_TO_POBJ(_obj) Z_OBJ_P(_obj) +#define PHPC_OBJ_FOR_PROP(_obj) (_obj) +#define PHPC_OBJ_HANDLER_COMPARE_NAME compare_objects + +#define PHPC_FCALL_FCI_INIT(_fci, _callback, _count, _no_separ) \ + do { \ + (_fci).params = PHPC_FCALL_PARAMS_NAME(_callback); \ + (_fci).param_count = (_count); \ + (_fci).no_separation = (_no_separ); \ + } while (0) +#else +/* PHP 8 */ + +/* object */ +#define phpc_obj_t zend_object +#define PHPC_OBJ_TO_POBJ(_obj) (_obj) +#define PHPC_OBJ_FOR_PROP(_obj) Z_OBJ_P(_obj) +#define PHPC_OBJ_HANDLER_COMPARE_NAME compare + +/* fcall */ +#define PHPC_FCALL_FCI_INIT(_fci, _callback, _count, _no_separ) \ + do { \ + (_fci).params = PHPC_FCALL_PARAMS_NAME(_callback); \ + (_fci).param_count = (_count); \ + } while (0) +/* ZTS */ +#define TSRMLS_D void +#define TSRMLS_DC +#define TSRMLS_C +#define TSRMLS_CC +#define TSRMLS_FETCH() +#endif + +#define PHPC_OBJ_STD_GET_PROPERTIES(_obj) \ + zend_std_get_properties((_obj) TSRMLS_CC) + + +#if PHP_MAJOR_VERSION == 5 + +/* MODULE */ + +#ifdef ZTS +#define PHPC_MODULE_GLOBALS_ACCESSOR(_module, _v) \ + TSRMG(_module ## _globals_id, zend_ ## _module ## _globals *, _v) +#else +#define PHPC_MODULE_GLOBALS_ACCESSOR(_module, _v) \ + (_module ## _globals._v) +#endif + +#define PHPC_MODULE_HAS_THREAD_CACHE 0 + + +/* INTEGER */ + +/* long type */ +typedef long phpc_long_t; +/* unsigned long type */ +typedef unsigned long phpc_ulong_t; +/* offset type */ +typedef off_t phpc_off_t; +/* string length type */ +typedef int phpc_str_size_t; + +#define PHPC_LONG_TO_LONG_EX2(_plv, _lv, _exc_over, _exc_under) \ + _lv = _plv +#define PHPC_LONG_TO_LONG_EX(_plv, _lv, _exc) \ + _lv = _plv +#define PHPC_LONG_TO_LONG(_plv, _lv) \ + _lv = _plv + +#define PHPC_SIZE_TO_LONG_EX PHPC_LONG_TO_LONG_EX +#define PHPC_SIZE_TO_LONG PHPC_LONG_TO_LONG + +#define PHPC_SIZE_TO_INT_EX PHPC_LONG_TO_LONG_EX +#define PHPC_SIZE_TO_INT PHPC_LONG_TO_LONG + + +/* STRING */ + +/* accessor and convertor macros */ +#define PHPC_STR_VAL(_name) _name##__val +#define PHPC_STR_LEN(_name) _name##__len +#define PHPC_STR_LEN_FMT "d" +#define PHPC_STR_LEN_UNUSED(_name) (void) PHPC_STR_LEN(_name) +#define PHPC_STR_LEN_FROM_VAL(_name) strlen(PHPC_STR_VAL(_name)) +#define PHPC_STR_LEN_DECLARE(_name) int PHPC_STR_LEN(_name) +#define PHPC_STR_LEN_FETCH(_name) PHPC_STR_LEN(_name) = PHPC_STR_LEN_FROM_VAL(_name) +#define PHPC_STR_LEN_DECLARE_AND_FETCH(_name) int PHPC_STR_LEN_FETCH(_name) +#define PHPC_STR_EXISTS(_name) PHPC_STR_VAL(_name) +#define PHPC_STR_DECLARE(_name) char *PHPC_STR_VAL(_name); int PHPC_STR_LEN(_name) +#define PHPC_STR_ARG(_name) char *PHPC_STR_VAL(_name), int PHPC_STR_LEN(_name) +#define PHPC_STR_ARG_VAL(_name) char *PHPC_STR_VAL(_name) +#define PHPC_STR_ARG_PTR(_name) char **PHPC_STR_VAL(_name), int *PHPC_STR_LEN(_name) +#define PHPC_STR_ARG_PTR_VAL(_name) char **PHPC_STR_VAL(_name) +#define PHPC_STR_PASS(_name) PHPC_STR_VAL(_name), PHPC_STR_LEN(_name) +#define PHPC_STR_PASS_VAL(_name) PHPC_STR_VAL(_name) +#define PHPC_STR_PASS_PTR(_name) &PHPC_STR_VAL(_name), &PHPC_STR_LEN(_name) +#define PHPC_STR_PASS_PTR_VAL(_name) &PHPC_STR_VAL(_name) +#define PHPC_STR_DEREF_VAL(_name) *PHPC_STR_VAL(_name) +#define PHPC_STR_FROM_PTR_STR(_str, _strp) \ + PHPC_STR_VAL(_str) = *PHPC_STR_VAL(_strp); \ + PHPC_STR_LEN(_str) = *PHPC_STR_LEN(_strp) +#define PHPC_STR_FROM_PTR_VAL(_str, _strpv) \ + PHPC_STR_VAL(_str) = *PHPC_STR_VAL(_strpv); \ + PHPC_STR_LEN(_str) = strlen(*PHPC_STR_VAL(_strpv)) +#define PHPC_STR_FROM_ZVAL(_str, _zv) \ + PHPC_STR_VAL(_str) = Z_STRVAL(_zv); \ + PHPC_STR_LEN(_str) = Z_STRLEN(_zv) +#define PHPC_STR_FROM_PZVAL(_str, _pzv) \ + PHPC_STR_VAL(_str) = Z_STRVAL_P(_pzv); \ + PHPC_STR_LEN(_str) = Z_STRLEN_P(_pzv) +#define PHPC_STR_RETURN(_name) \ + RETURN_STRINGL(PHPC_STR_VAL(_name), PHPC_STR_LEN(_name), 0) + +/* wrapper macros */ +#define PHPC_STR_INIT(_name, _cstr, _len) do { \ + PHPC_STR_VAL(_name) = emalloc(_len + 1); \ + memcpy(PHPC_STR_VAL(_name), _cstr, _len); \ + PHPC_STR_VAL(_name)[_len] = 0; \ + PHPC_STR_LEN(_name) = _len; \ + } while (0) +#define PHPC_STR_ALLOC(_name, _len) do { \ + PHPC_STR_VAL(_name) = emalloc(_len + 1); \ + PHPC_STR_LEN(_name) = _len; \ + } while (0) +#define PHPC_STR_REALLOC(_name, _len) do { \ + PHPC_STR_VAL(_name) = erealloc(PHPC_STR_VAL(_name), _len + 1); \ + PHPC_STR_LEN(_name) = _len; \ + } while (0) +#define PHPC_STR_RELEASE(_name) efree(PHPC_STR_VAL(_name)) + +/* C string */ +#define PHPC_CSTRL_RETURN(_name, _len) RETURN_STRINGL(_name, _len, 1) +#define PHPC_CSTR_RETURN(_name) RETURN_STRING(_name, 1) +#define PHPC_CSTRL_RETVAL(_name, _len) RETVAL_STRINGL(_name, _len, 1) +#define PHPC_CSTR_RETVAL(_name) RETVAL_STRING(_name, 1) + +/* ZSTR */ +#define PHPC_ZSTR_VAL(_name) _name + +/* Smart string */ +#if defined(PHPC_SMART_STR_INCLUDE) || defined(PHPC_SMART_CSTR_INCLUDE) +#include "ext/standard/php_smart_str.h" + +#ifdef PHPC_SMART_CSTR_INCLUDE +/* smart_str for C string has been renamed in PHP 7 so we have to wrap it */ +#define phpc_smart_cstr smart_str +#define phpc_smart_cstr_alloc smart_str_alloc +#define phpc_smart_cstr_free smart_str_free +#define phpc_smart_cstr_append smart_str_append +#define phpc_smart_cstr_appends smart_str_appends +#define phpc_smart_cstr_appendl smart_str_appendl +#define phpc_smart_cstr_appendc smart_str_appendc +#define phpc_smart_cstr_append_long smart_str_append_long +#define phpc_smart_cstr_append_unsigned smart_str_append_unsigned +#define phpc_smart_cstr_0 smart_str_0 +#endif /* PHPC_SMART_CSTR_INCLUDE */ + +#endif /* PHPC_SMART_STR_INCLUDE || PHPC_SMART_CSTR_INCLUDE */ + + +/* RESOURCE */ +typedef zend_rsrc_list_entry phpc_res_entry_t; +typedef long phpc_res_value_t; + +#define PHPC_RES_REGISTER(_entry, _type) \ + zend_list_insert(_entry, _type TSRMLS_CC) +#define PHPC_RES_FETCH(_pz_res, _res_type_name, _res_type) \ + zend_fetch_resource(&(_pz_res) TSRMLS_CC, -1, _res_type_name, NULL, 1, _res_type) +#define PHPC_RES_FETCH2(_pz_res, _res_type_name, _res_type_1, _res_type_2) \ + zend_fetch_resource(&(_pz_res) TSRMLS_CC, -1, _res_type_name, NULL, 2, _res_type_1, _res_type_2) +#define PHPC_RES_DELETE(_pz_res) \ + zend_list_delete(Z_LVAL_P(_pz_res)) +#define PHPC_RES_CLOSE PHPC_RES_DELETE + +/* resource to zval */ +#define PHPC_RES_PZVAL(_res, _pzv) \ + ZVAL_RESOURCE(_pzv, _res) +#define PHPC_RES_RETVAL RETVAL_RESOURCE +#define PHPC_RES_RETURN RETURN_RESOURCE + + +/* OBJECT */ +#define PHPC_CLASS_REGISTER_EX(_orig_class_entry, _parent_ce, _parent_name) \ + zend_register_internal_class_ex(&_orig_class_entry, _parent_ce, _parent_name TSRMLS_CC) +#define PHPC_CLASS_REGISTER(_orig_class_entry) \ + zend_register_internal_class(&_orig_class_entry TSRMLS_CC) + +/* struct spec */ +#define PHPC_OBJ_STRUCT_MEMBER_FIRST zend_object std; +#define PHPC_OBJ_STRUCT_MEMBER_LAST +#define PHPC_OBJ_STRUCT_BEGIN(_name) \ + PHPC_OBJ_STRUCT_NAME(_name) { PHPC_OBJ_STRUCT_MEMBER_FIRST +#define PHPC_OBJ_STRUCT_END() \ + PHPC_OBJ_STRUCT_MEMBER_LAST }; + +/* object convertors */ +#define PHPC_OBJ_FROM_ZOBJ(_name, _object) \ + (PHPC_OBJ_STRUCT_NAME(_name) *) _object +#define PHPC_OBJ_FROM_ZVAL(_name, _zv) \ + (PHPC_OBJ_STRUCT_NAME(_name) *) zend_object_store_get_object(_zv TSRMLS_CC) +#define PHPC_OBJ_FROM_POBJ PHPC_OBJ_FROM_ZVAL + +/* create_ex object handler helper */ +#define PHPC_OBJ_HANDLER_CREATE_EX(_name) \ + PHPC_OBJ_GET_HANDLER_FCE_INLINE_DEF(zend_object_value, _name, create_ex) \ + (zend_class_entry *PHPC_CLASS_TYPE, PHPC_OBJ_STRUCT_NAME(_name) **_phpc_objptr TSRMLS_DC) +#define PHPC_OBJ_HANDLER_CREATE_EX_IS_NEW() (_phpc_objptr == NULL) +#define PHPC_OBJ_HANDLER_CREATE_EX_DECLARE() zend_object_value _phpc_retval +#define PHPC_OBJ_HANDLER_CREATE_EX_ALLOC(_name) \ + ecalloc(1, sizeof(PHPC_OBJ_STRUCT_NAME(_name))); +#define PHPC_OBJ_HANDLER_INIT_CREATE_EX_PROPS(_intern) \ + do { \ + if (_phpc_objptr) { \ + *_phpc_objptr = _intern; \ + } \ + zend_object_std_init(&_intern->std, PHPC_CLASS_TYPE TSRMLS_CC); \ + PHPC_OBJ_PROPERTIES_INIT(&_intern->std, PHPC_CLASS_TYPE); \ + } while(0) +#define PHPC_OBJ_HANDLER_CREATE_EX_RETURN_EX(_name, _intern) \ + do { \ + _phpc_retval.handle = zend_objects_store_put((_intern), \ + (zend_objects_store_dtor_t) zend_objects_destroy_object, \ + (zend_objects_free_object_storage_t) PHPC_OBJ_GET_HANDLER_FCE(_name, free), \ + NULL TSRMLS_CC); \ + _phpc_retval.handlers = &PHPC_OBJ_GET_HANDLER_VAR_NAME(_name); \ + return _phpc_retval; \ + } while(0) + +/* create object handler */ +#define PHPC_OBJ_HANDLER_CREATE(_name) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(zend_object_value, _name, create) \ + (zend_class_entry *PHPC_CLASS_TYPE TSRMLS_DC) +#define PHPC_OBJ_HANDLER_CREATE_RETURN(_name) \ + return PHPC_OBJ_GET_HANDLER_FCE(_name, create_ex)(PHPC_CLASS_TYPE, NULL TSRMLS_CC) + +/* clone object handler */ +#define PHPC_OBJ_HANDLER_CLONE(_name) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(zend_object_value, _name, clone)(phpc_obj_t *PHPC_SELF TSRMLS_DC) +#define PHPC_OBJ_HANDLER_CLONE_DECLARE() zend_object_value _phpc_retval +#define PHPC_OBJ_HANDLER_CLONE_MEMBERS(_name, _new_obj, _old_obj) \ + do { \ + _phpc_retval = PHPC_OBJ_GET_HANDLER_FCE(_name, create_ex)(_old_obj->std.ce, &_new_obj TSRMLS_CC); \ + zend_objects_clone_members(&_new_obj->std, _phpc_retval, &_old_obj->std, Z_OBJ_HANDLE_P(PHPC_SELF) TSRMLS_CC); \ + } while(0) +#define PHPC_OBJ_HANDLER_CLONE_RETURN_EX(_new_obj) return _phpc_retval + +/* free object handler */ +#define PHPC_OBJ_HANDLER_FREE(_name) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(void, _name, free)(void *_phpc_object TSRMLS_DC) +#define PHPC_OBJ_HANDLER_FREE_DTOR(_intern) \ + do { \ + zend_object_std_dtor(&(_intern)->std TSRMLS_CC); \ + efree(_intern); \ + } while(0) + +/* compare object handler */ +#define PHPC_OBJ_HANDLER_COMPARE(_name) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(int, _name, compare)(zval *_phpc_obj1, zval *_phpc_obj2 TSRMLS_DC) +#define PHPC_OBJ_HANDLER_COMPARE_FETCH(_name, _id, _obj) \ + PHPC_OBJ_STRUCT_DECLARE(_name, _obj) = PHPC_OBJ_FROM_ZVAL(_name, _phpc_obj ## _id) + +/* handler setters */ +#define PHPC_OBJ_SET_SPECIFIC_HANDLER_OFFSET(_handlers, _name) PHPC_NOOP +#define PHPC_OBJ_SET_SPECIFIC_HANDLER_FREE(_handlers, _name) PHPC_NOOP + +/* read propery */ +#define PHPC_READ_PROPERTY_RV_NAME +#define PHPC_READ_PROPERTY_RV_DECLARE PHPC_NOOP +#define PHPC_READ_PROPERTY(_scope, _object, _name, _name_len, _silent) \ + zend_read_property(_scope, _object, _name, _name_len, _silent TSRMLS_CC) + +/* HASH */ + +/* apply count */ +#define PHPC_HASH_HAS_APPLY_COUNT(_ht) (_ht->nApplyCount > 0) +#define PHPC_HASH_GET_APPLY_COUNT(_ht) _ht->nApplyCount +#define PHPC_HASH_INC_APPLY_COUNT(_ht) _ht->nApplyCount++ +#define PHPC_HASH_DEC_APPLY_COUNT(_ht) _ht->nApplyCount-- +#define PHPC_HASH_APPLY_PROTECTION(_ht) 1 + +/* add ptr */ +#define PHPC_HASH_INDEX_ADD_PTR(_ht, _idx, _ptr, _ptr_size) \ + zend_hash_index_update(_ht, _idx, _ptr, _ptr_size, NULL) +#define PHPC_HASH_STR_ADD_PTR(_ht, _str, _ptr, _ptr_size) \ + zend_hash_add(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, _ptr, _ptr_size, NULL) +#define PHPC_HASH_CSTRL_ADD_PTR(_ht, _cstr_value, _cstr_len, _ptr, _ptr_size) \ + zend_hash_add(_ht, _cstr_value, (_cstr_len) + 1, _ptr, _ptr_size, NULL) +#define PHPC_HASH_CSTR_ADD_PTR(_ht, _cstr_value, _ptr, _ptr_size) \ + zend_hash_add(_ht, _cstr_value, strlen(_cstr_value) + 1, _ptr, _ptr_size, NULL) +/* add */ +#define PHPC_HASH_INDEX_ADD(_ht, _idx, _pzv) \ + zend_hash_index_update(_ht, _idx, &_pzv, sizeof(_pzv), NULL) +#define PHPC_HASH_STR_ADD(_ht, _str, _pzv) \ + zend_hash_add(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, &_pzv, sizeof(_pzv), NULL) +#define PHPC_HASH_CSTRL_ADD(_ht, _cstr_value, _cstr_len, _pzv) \ + zend_hash_add(_ht, _cstr_value, (_cstr_len) + 1, &_pzv, sizeof(_pzv), NULL) +#define PHPC_HASH_CSTR_ADD(_ht, _cstr_value, _pzv) \ + zend_hash_add(_ht, _cstr_value, strlen(_cstr_value) + 1, &_pzv, sizeof(_pzv), NULL) + +/* next insert */ +#define PHPC_HASH_NEXT_INDEX_INSERT_PTR(_ht, _ptr, _ptr_size) \ + zend_hash_next_index_insert(_ht, _ptr, _ptr_size, NULL) +#define PHPC_HASH_NEXT_INDEX_INSERT(_ht, _pzv) \ + zend_hash_next_index_insert(_ht, _pzv, sizeof(_pzv), NULL) + +/* update ptr */ +#define PHPC_HASH_INDEX_UPDATE_PTR(_ht, _idx, _ptr, _ptr_size) \ + zend_hash_index_update(_ht, _idx, _ptr, _ptr_size, NULL) +#define PHPC_HASH_STR_UPDATE_PTR(_ht, _str, _ptr, _ptr_size) \ + zend_hash_update(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, _ptr, _ptr_size, NULL) +#define PHPC_HASH_CSTRL_UPDATE_PTR(_ht, _cstr_value, _cstr_len, _ptr, _ptr_size) \ + zend_hash_update(_ht, _cstr_value, (_cstr_len) + 1, _ptr, _ptr_size, NULL) +#define PHPC_HASH_CSTR_UPDATE_PTR(_ht, _cstr_value, _ptr, _ptr_size) \ + zend_hash_update(_ht, _cstr_value, strlen(_cstr_value) + 1, _ptr, _ptr_size, NULL) +/* update */ +#define PHPC_HASH_INDEX_UPDATE(_ht, _idx, _pzv) \ + zend_hash_index_update(_ht, _idx, &_pzv, sizeof(_pzv), NULL) +#define PHPC_HASH_STR_UPDATE(_ht, _str, _pzv) \ + zend_hash_update(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, &_pzv, sizeof(_pzv), NULL) +#define PHPC_HASH_CSTRL_UPDATE(_ht, _cstr_value, _cstr_len, _pzv) \ + zend_hash_update(_ht, _cstr_value, (_cstr_len) + 1, &_pzv, sizeof(_pzv), NULL) +#define PHPC_HASH_CSTR_UPDATE(_ht, _cstr_value, _pzv) \ + zend_hash_update(_ht, _cstr_value, strlen(_cstr_value) + 1, &_pzv, sizeof(_pzv), NULL) + +/* delete */ +#define PHPC_HASH_INDEX_DELETE(_ht, _idx) \ + zend_hash_index_del(_ht, _idx) +#define PHPC_HASH_STR_DELETE(_ht, _str) \ + zend_hash_del(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1) +#define PHPC_HASH_CSTRL_DELETE(_ht, _cstr_value, _cstr_len) \ + zend_hash_del(_ht, _cstr_value, (_cstr_len) + 1) +#define PHPC_HASH_CSTR_DELETE(_ht, _cstr_value) \ + zend_hash_del(_ht, _cstr_value, strlen(_cstr_value) + 1) + +/* exists */ +#define PHPC_HASH_INDEX_EXISTS(_ht, _idx) \ + zend_hash_index_exists(_ht, _idx) +#define PHPC_HASH_STR_EXISTS(_ht, _str) \ + zend_hash_exists(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1) +#define PHPC_HASH_CSTRL_EXISTS(_ht, _cstr_value, _cstr_len) \ + zend_hash_exists(_ht, _cstr_value, (_cstr_len) + 1) +#define PHPC_HASH_CSTR_EXISTS(_ht, _cstr_value) \ + zend_hash_exists(_ht, _cstr_value, strlen(_cstr_value) + 1) + +/* find */ +#define PHPC_HASH_INDEX_FIND(_ht, _idx, _ppv) \ + zend_hash_index_find(_ht, _idx, (void **) &_ppv) +#define PHPC_HASH_STR_FIND(_ht, _str, _ppv) \ + zend_hash_find(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, (void **) &_ppv) +#define PHPC_HASH_CSTRL_FIND(_ht, _cstr_value, _cstr_len, _ppv) \ + zend_hash_find(_ht, _cstr_value, (_cstr_len) + 1, (void **) &_ppv) +#define PHPC_HASH_CSTR_FIND(_ht, _cstr_value, _ppv) \ + zend_hash_find(_ht, _cstr_value, strlen(_cstr_value) + 1, (void **) &_ppv) +/* find ptr */ +#define PHPC_HASH_STR_FIND_PTR PHPC_HASH_STR_FIND +#define PHPC_HASH_INDEX_FIND_PTR PHPC_HASH_INDEX_FIND +#define PHPC_HASH_CSTRL_FIND_PTR PHPC_HASH_CSTRL_FIND +#define PHPC_HASH_CSTR_FIND_PTR PHPC_HASH_CSTR_FIND +/* not found value */ +#define PHPC_HASH_NOT_FOUND FAILURE + +/* key and data getter */ +#define PHPC_HASH_GET_CURRENT_KEY_EX(_ht, _str, _num_index, _pos) \ + do { \ + unsigned int _phpc_current_key_len; \ + zend_hash_get_current_key_ex(_ht, &PHPC_STR_VAL(_str), \ + &_phpc_current_key_len, &_num_index, 0, _pos); \ + PHPC_STR_LEN(_str) = _phpc_current_key_len - 1; \ + } while(0) +#define PHPC_HASH_GET_CURRENT_DATA_EX(_ht, _val, _pos) \ + zend_hash_get_current_data_ex(_ht, (void **) &(_val), _pos) + +#define PHPC_HASH_GET_CURRENT_KEY(_ht, _str, _num_index) \ + zend_hash_get_current_key(_ht, &PHPC_STR_VAL(_str), &_num_index, 0) +#define PHPC_HASH_GET_CURRENT_DATA(_ht, _val) \ + zend_hash_get_current_data(_ht, (void **) &(_val)) + +/* copy */ +#define PHPC_HASH_COPY_EX(_target, _source, _copy_ctr) \ + zend_hash_copy(_target, _source, NULL, NULL, sizeof(zval *)) + +/* key result constant has been renamed in 5.4 */ +#if PHP_VERSION_ID < 50399 +#define _PHPC_HASH_KEY_NON_EXISTENT HASH_KEY_NON_EXISTANT +#else +#define _PHPC_HASH_KEY_NON_EXISTENT HASH_KEY_NON_EXISTENT +#endif + +/* iteration for each element */ +#define PHPC_HASH_FOREACH_KEY(_ht, _h, _key) do { \ + HashPosition _pos; \ + uint _str_length; \ + int _key_type; \ + for (zend_hash_internal_pointer_reset_ex((_ht), &_pos); \ + (_key_type = zend_hash_get_current_key_ex( \ + (_ht), &PHPC_STR_VAL(_key), &_str_length, &_h, 0, &_pos)) != _PHPC_HASH_KEY_NON_EXISTENT; \ + zend_hash_move_forward_ex((_ht), &_pos) ) { \ + if (_key_type == HASH_KEY_IS_STRING) { \ + PHPC_STR_LEN(_key) = (int) _str_length - 1; \ + } else { \ + PHPC_STR_VAL(_key) = NULL; \ + PHPC_STR_LEN(_key) = 0; \ + } + +#define PHPC_HASH_FOREACH_VAL(_ht, _ppv) do { \ + HashPosition _pos; \ + for (zend_hash_internal_pointer_reset_ex((_ht), &_pos); \ + zend_hash_get_current_data_ex((_ht), (void **) &(_ppv), &_pos) == SUCCESS; \ + zend_hash_move_forward_ex((_ht), &_pos) ) { + +#define PHPC_HASH_FOREACH_VAL_IND PHPC_HASH_FOREACH_VAL + +#define _PHPC_HASH_FOREACH_KEY_VAL(_ht, _ph, _key, _ppv, _use_h) \ + PHPC_HASH_FOREACH_VAL(_ht, _ppv) \ + int _key_type; \ + uint _str_length; \ + ulong _num_index, *_pnum_index; \ + if (_use_h) { \ + _pnum_index = _ph; \ + } else { \ + _pnum_index = &_num_index; \ + } \ + _key_type = zend_hash_get_current_key_ex(_ht, &PHPC_STR_VAL(_key), &_str_length, _pnum_index, 0, &_pos); \ + if (_key_type == HASH_KEY_IS_STRING) { \ + PHPC_STR_LEN(_key) = (int) _str_length - 1; \ + } else { \ + PHPC_STR_VAL(_key) = NULL; \ + PHPC_STR_LEN(_key) = 0; \ + } + +#define PHPC_HASH_FOREACH_KEY_VAL(_ht, _h, _key, _ppv) \ + _PHPC_HASH_FOREACH_KEY_VAL(_ht, &_h, _key, _ppv, 1) + + +#define PHPC_HASH_FOREACH_KEY_VAL_IND PHPC_HASH_FOREACH_KEY_VAL + +#define PHPC_HASH_FOREACH_STR_KEY_VAL(_ht, _key, _ppv) \ + _PHPC_HASH_FOREACH_KEY_VAL(_ht, NULL, _key, _ppv, 0) + +#define PHPC_HASH_FOREACH_STR_KEY_VAL_IND PHPC_HASH_FOREACH_STR_KEY_VAL + +#define PHPC_HASH_FOREACH_END() } } while (0) + +/* hash to zval */ +#define PHPC_HASH_PZVAL(_ht, _pzv) \ + do { \ + Z_ARRVAL_P(_pzv) = _ht; \ + Z_TYPE_P(_pzv) = IS_ARRAY; \ + } while(0) +#define PHPC_HASH_RETVAL(_ht) \ + PHPC_HASH_PZVAL(_ht, return_value) +#define PHPC_HASH_RETURN(_ht) \ + do { \ + PHPC_HASH_RETVAL(_ht); \ + return; \ + } while(0) + + +/* SYMTABLE */ + +/* update*/ +#define PHPC_SYMTABLE_UPDATE(_ht, _str, _pzv) \ + zend_symtable_update(_ht, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str) + 1, &_pzv, sizeof(_pzv), NULL) + + +/* ARRAY */ + +#define PHPC_ARRAY_ADD_ASSOC_NULL_EX(_arr, _key, _key_len) \ + add_assoc_null_ex(_arr, _key, (_key_len) + 1) +#define PHPC_ARRAY_ADD_ASSOC_BOOL_EX(_arr, _key, _key_len, _b) \ + add_assoc_bool_ex(_arr, _key, (_key_len) + 1, _b) +#define PHPC_ARRAY_ADD_ASSOC_LONG_EX(_arr, _key, _key_len, _n) \ + add_assoc_long_ex(_arr, _key, (_key_len) + 1, _n) +#define PHPC_ARRAY_ADD_ASSOC_RESOURCE_EX(_arr, _key, _key_len, _r) \ +add_assoc_resource_ex(_arr, _key, (_key_len) + 1, _r) +#define PHPC_ARRAY_ADD_ASSOC_DOUBLE_EX(_arr, _key, _key_len, _d) \ + add_assoc_double_ex(_arr, _key, (_key_len) + 1, _d) +#define PHPC_ARRAY_ADD_ASSOC_STR_EX(_arr, _key, _key_len, _str) \ + add_assoc_stringl_ex(_arr, _key, (_key_len) + 1, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str), 0) +#define PHPC_ARRAY_ADD_ASSOC_CSTR_EX(_arr, _key, _key_len, _cstr) \ + add_assoc_string_ex(_arr, _key, (_key_len) + 1, _cstr, 1) +#define PHPC_ARRAY_ADD_ASSOC_CSTRL_EX(_arr, _key, _key_len, _cstr, _cstr_len) \ + add_assoc_stringl_ex(_arr, _key, (_key_len) + 1, _cstr, _cstr_len, 1) +#define PHPC_ARRAY_ADD_ASSOC_ZVAL_EX(_arr, _key, _key_len, _zv) \ + add_assoc_zval_ex(_arr, _key, (_key_len) + 1, _zv) +#define PHPC_ARRAY_ADD_ASSOC_VAL_EX(_arr, _key, _key_len, _pv) \ + add_assoc_zval_ex(_arr, _key, (_key_len) + 1, _pv) + +#define PHPC_ARRAY_ADD_ASSOC_STR(_arr, _key, _str) \ + add_assoc_stringl(_arr, _key, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str), 0) +#define PHPC_ARRAY_ADD_ASSOC_CSTR(_arr, _key, _cstr) \ + add_assoc_string(_arr, _key, _cstr, 1) +#define PHPC_ARRAY_ADD_ASSOC_CSTRL(_arr, _key, _cstr, _cstr_len) \ + add_assoc_stringl(_arr, _key, _cstr, _cstr_len, 1) +#define PHPC_ARRAY_ADD_ASSOC_VAL add_assoc_zval + +#define PHPC_ARRAY_ADD_INDEX_STR(_arr, _idx, _str) \ + add_index_stringl(_arr, _idx, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str), 0) +#define PHPC_ARRAY_ADD_INDEX_CSTR(_arr, _idx, _cstr) \ + add_index_string(_arr, _idx, _cstr, 1) +#define PHPC_ARRAY_ADD_INDEX_CSTRL(_arr, _idx, _cstr, _cstr_len) \ + add_index_stringl(_arr, _idx, _cstr, _cstr_len, 1) +#define PHPC_ARRAY_ADD_INDEX_VAL add_index_zval + +#define PHPC_ARRAY_ADD_NEXT_INDEX_STR(_arr, _str) \ + add_next_index_stringl(_arr, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str), 0) +#define PHPC_ARRAY_ADD_NEXT_INDEX_CSTR(_arr, _cstr) \ + add_next_index_string(_arr, _cstr, 1) +#define PHPC_ARRAY_ADD_NEXT_INDEX_CSTRL(_arr, _cstr, _cstr_len) \ + add_next_index_stringl(_arr, _cstr, _cstr_len, 1) +#define PHPC_ARRAY_ADD_NEXT_INDEX_VAL add_next_index_zval + + +/* FCALL */ +#define _PHPC_FCALL_VARS_NAME(_pname) _phpc_fcall_vars__ ## _pname + +#define PHPC_FCALL_PARAMS_DECLARE(_pname, _count) \ + int _phpc_fcall_params_count = _count; \ + zval *_PHPC_FCALL_VARS_NAME(_pname)[_count]; \ + zval **PHPC_FCALL_PARAMS_NAME(_pname)[_count] + +#define PHPC_FCALL_PARAMS_INIT(_pname) \ + do { \ + int _idx; \ + for (_idx = 0; _idx < _phpc_fcall_params_count; _idx++) \ + PHPC_FCALL_PARAMS_NAME(_pname)[_idx] = &_PHPC_FCALL_VARS_NAME(_pname)[_idx]; \ + } while(0) + +#define PHPC_FCALL_PARAM_PZVAL(_pname, _idx) \ + _PHPC_FCALL_VARS_NAME(_pname)[_idx] + +#define PHPC_FCALL_PARAM_VAL(_pname, _idx) \ + _PHPC_FCALL_VARS_NAME(_pname)[_idx] + +#define PHPC_FCALL_PARAM_UNDEF(_pname, _idx) \ + ZVAL_NULL(PHPC_FCALL_PARAM_PZVAL(_pname, _idx)) + +#define PHPC_FCALL_RETVAL(_fci, _pv) \ + (_fci).retval_ptr_ptr = &(_pv) + +/* ZVAL */ +typedef zval * phpc_val; + +#define PHPC_TYPE Z_TYPE_P +#define PHPC_TYPE_P Z_TYPE_PP + +#define PHPC_LVAL Z_LVAL_P +#define PHPC_LVAL_P Z_LVAL_PP + +#define PHPC_DVAL Z_DVAL_P +#define PHPC_DVAL_P Z_DVAL_PP + +#define PHPC_STRVAL Z_STRVAL_P +#define PHPC_STRVAL_P Z_STRVAL_PP + +#define PHPC_STRLEN Z_STRLEN_P +#define PHPC_STRLEN_P Z_STRLEN_PP + +#define PHPC_ARRVAL Z_ARRVAL_P +#define PHPC_ARRVAL_P Z_ARRVAL_PP + +#define PHPC_OBJ_HT Z_OBJ_HT_P +#define PHPC_OBJ_HT_P Z_OBJ_HT_PP + +#define PHPC_OBJ_HANDLER Z_OBJ_HANDLER_P +#define PHPC_OBJ_HANDLER_P Z_OBJ_HANDLER_PP + +#define PHPC_OBJ_HANDLE Z_OBJ_HANDLE_P +#define PHPC_OBJ_HANDLE_P Z_OBJ_HANDLE_PP + +#define PHPC_OBJCE Z_OBJCE_P +#define PHPC_OBJCE_P Z_OBJCE_PP + +#define PHPC_OBJPROP Z_OBJPROP_P +#define PHPC_OBJPROP_P Z_OBJPROP_PP + +#define PHPC_OBJDEBUG Z_OBJDEBUG_P +#define PHPC_OBJDEBUG_P Z_OBJDEBUG_PP + +#define PHPC_REFCOUNTED(_zv) 1 +#define PHPC_REFCOUNTED_P(_pzv) 1 + +#define PHPC_PZVAL_CAST_TO_PVAL(_pzv) &_pzv + +#define PHPC_VAL_CAST_TO_ZVAL(_pv) *(_pv) +#define PHPC_VAL_CAST_TO_PZVAL(_pv) _pv +#define PHPC_PVAL_CAST_TO_PZVAL(_ppv) *(_ppv) + +#define PHPC_VAL_TO_ZVAL(_pv, _zv) _zv = *(_pv) +#define PHPC_VAL_TO_PZVAL(_pv, _zv) _zv = _pv +#define PHPC_PVAL_TO_PZVAL(_ppv, _zv) _zv = *(_ppv) + +#define PHPC_VAL_MAKE MAKE_STD_ZVAL +#define PHPC_VAL_FREE FREE_ZVAL +#define PHPC_VAL_UNDEF(_pv) _pv = NULL +#define PHPC_VAL_ISUNDEF(_pv) _pv == NULL +#define PHPC_VAL_COPY(_pv, _zv) ZVAL_ZVAL(_pv, _zv, 1, 0) +#define PHPC_VAL_ASSIGN(_pv, _zv) _pv = _zv + +#define PHPC_PZVAL_MAKE MAKE_STD_ZVAL +#define PHPC_PZVAL_FREE FREE_ZVAL +#define PHPC_PZVAL_SET(_pv, _zv) ZVAL_ZVAL(_pv, _zv, 0, 0) +#define PHPC_PVAL_DEREF(_pv) PHPC_NOOP +#define PHPC_PZVAL_DEREF(_pv) PHPC_NOOP + +#define PHPC_PZVAL_COPY_INIT INIT_PZVAL_COPY +#define PHPC_PZVAL_COPY(_pzv_dst, _pzv_src) \ + *_pzv_dst = *_pzv_src + +#define PHPC_VAL_NEW_STR(_pv, _str) \ + ZVAL_STRINGL(_pv, PHPC_STR_VAL(_str), PHPC_STR_LEN(_str), 0) +#define PHPC_VAL_STR PHPC_VAL_NEW_STR +#define PHPC_VAL_CSTR(_pv, _cstr) \ + ZVAL_STRING(_pv, _cstr, 1) +#define PHPC_VAL_CSTRL(_pv, _cstr, _cstr_len) \ + ZVAL_STRINGL(_pv, _cstr, _cstr_len, 1) + +#define PHPC_PZVAL_NEW_STR PHPC_VAL_NEW_STR +#define PHPC_PZVAL_STR PHPC_VAL_STR +#define PHPC_PZVAL_CSTR PHPC_VAL_CSTR +#define PHPC_PZVAL_CSTRL PHPC_VAL_CSTRL + +#define PHPC_ZVAL_COPY(_zv_dst, _zv_src) \ + _zv_dst = _zv_src + +#define PHPC_ZVAL_NEW_STR(_zv, _str) \ + PHPC_VAL_STR(&_zv, _str) +#define PHPC_ZVAL_STR PHPC_ZVAL_NEW_STR +#define PHPC_ZVAL_CSTR(_zv, _cstr) \ + PHPC_VAL_CSTR(&_zv, _cstr) +#define PHPC_ZVAL_CSTRL(_zv, _cstr, _cstr_len) \ + PHPC_VAL_CSTRL(&_zv, _cstr, _cstr_len) + +#define PHPC_ZVAL_IS_TRUE(_zv) \ + (Z_TYPE(_zv) == IS_BOOL && Z_BVAL(_zv)) +#define PHPC_ZVAL_IS_FALSE(_zv) \ + (Z_TYPE(_zv) == IS_BOOL && !Z_BVAL(_zv)) + +#define PHPC_VAL_IS_TRUE(_pv) PHPC_ZVAL_IS_TRUE(*_pv) +#define PHPC_VAL_IS_FALSE(_pv) PHPC_ZVAL_IS_FALSE(*_pv) + +/* Function end */ +#if (PHP_MINOR_VERSION == 3 && PHP_RELEASE_VERSION >= 7) || (PHP_MINOR_VERSION >= 4) +#define PHPC_FE_END PHP_FE_END +#else +#define PHPC_FE_END {NULL,NULL,NULL} +#endif + + +/* ZPP */ + +/* path flag */ +#if PHP_VERSION_ID < 50399 +#define PHPC_ZPP_PATH_FLAG "s" +#else +#define PHPC_ZPP_PATH_FLAG "p" +#endif + +/* args */ +#define PHPC_ZPP_ARGS_DECLARE() \ + int _phpc_zpp_args_count = 0; \ + zval ***_phpc_zpp_args_array + +#if PHP_API_VERSION < 20090626 +#define PHPC_ZPP_ARGS_LOAD_EX(_flag, _num_args, _return) \ + do { \ + const char *_phpc_zpp_args_type_str = #_flag; \ + _phpc_zpp_args_count = _num_args; \ + _phpc_zpp_args_array = (zval ***) safe_emalloc(_num_args, sizeof (zval **), 0); \ + if ((_phpc_zpp_args_type_str[0] == '+' && _num_args == 0) || \ + zend_get_parameters_array_ex(_phpc_zpp_args_count, _phpc_zpp_args_array) == FAILURE) { \ + efree(_phpc_zpp_args_array); \ + zend_wrong_param_count(TSRMLS_C); \ + _return; \ + } \ + } while (0) +#else +#define PHPC_ZPP_ARGS_LOAD_EX(_flag, _num_args, _return) \ + do { \ + if (zend_parse_parameters(_num_args TSRMLS_CC, #_flag, \ + &_phpc_zpp_args_array, &_phpc_zpp_args_count) == FAILURE) { \ + _return; \ + } \ + } while(0) +#endif + +#define PHPC_ZPP_ARGS_GET_PVAL(_arg_pos) \ + _phpc_zpp_args_array[_arg_pos] + +#define PHPC_ZPP_ARGS_FREE() \ + if (_phpc_zpp_args_count > 0) \ + efree(_phpc_zpp_args_array) + + +/* STREAM */ +#if PHP_VERSION_ID < 50600 +typedef char phpc_stream_opener_char_t; +#else +typedef const char phpc_stream_opener_char_t; +#endif +#define PHPC_STREAM_WRAPPERDATA_ALLOC(stream) MAKE_STD_ZVAL(stream->wrapperdata) +#define PHPC_STREAM_WRAPPERDATA_ISSET(stream) stream->wrapperdata +#define PHPC_STREAM_WRAPPERDATA_UNSET(stream) \ + do { \ + zval_ptr_dtor(&stream->wrapperdata); \ + stream->wrapperdata = NULL; \ + } while(0) +#define PHPC_STREAM_CONTEXT_GET_OPTION(_ctx, _wrappername, _optionname, _ppv) \ + php_stream_context_get_option(_ctx, _wrappername, _optionname, &_ppv) +#define PHPC_STREAM_CONTEXT_OPTION_NOT_FOUND FAILURE + + +#else /* PHP 7 */ + +/* MODULE */ + +#define PHPC_MODULE_GLOBALS_ACCESSOR ZEND_MODULE_GLOBALS_ACCESSOR + +#define PHPC_MODULE_HAS_THREAD_CACHE defined(ZTS) && defined(COMPILE_DL_JSON) + + +/* INTEGER */ + +/* long type */ +typedef zend_long phpc_long_t; +/* unsigned long type */ +typedef zend_ulong phpc_ulong_t; +/* offset type */ +typedef zend_off_t phpc_off_t; +/* string length type */ +typedef size_t phpc_str_size_t; + +#define PHPC_LONG_TO_LONG_EX2(_plv, _lv, _exc_over, _exc_under) \ + PHPC_CONVERT_NUMBER(_plv, _lv, _exc_over, _exc_under, phpc_long_t, long, LONG_MAX, LONG_MIN) +#define PHPC_LONG_TO_LONG_EX(_plv, _lv, _exc) \ + PHPC_LONG_TO_LONG_EX2(_plv, _lv, _exc, _exc) +#define PHPC_LONG_TO_LONG(_plv, _lv) \ + PHPC_LONG_TO_LONG_EX2(_plv, _lv, _lv = LONG_MAX, _lv = LONG_MIN) + +#define PHPC_SIZE_TO_LONG_EX(_plv, _lv, _exc_over) \ + PHPC_CONVERT_NUMBER_SIGNED(_plv, _lv, _exc_over, size_t, long, LONG_MAX) +#define PHPC_SIZE_TO_LONG(_plv, _lv) \ + PHPC_SIZE_TO_LONG_EX(_plv, _lv, _lv = LONG_MAX) + +#define PHPC_SIZE_TO_INT_EX(_plv, _lv, _exc_over) \ + PHPC_CONVERT_NUMBER_SIGNED(_plv, _lv, _exc_over, size_t, int, INT_MAX) +#define PHPC_SIZE_TO_INT(_plv, _lv) \ + PHPC_SIZE_TO_LONG_EX(_plv, _lv, _lv = INT_MAX) + + +/* STRING */ + +/* accessor and convertor macros */ +#define PHPC_STR_VAL ZSTR_VAL +#define PHPC_STR_LEN ZSTR_LEN +#define PHPC_STR_LEN_FMT "zu" +#define PHPC_STR_LEN_UNUSED(_name) PHPC_NOOP +#define PHPC_STR_LEN_FROM_VAL PHPC_STR_LEN +#define PHPC_STR_LEN_DECLARE(_name) PHPC_NOOP +#define PHPC_STR_LEN_FETCH(_name) PHPC_NOOP +#define PHPC_STR_LEN_DECLARE_AND_FETCH(_name) PHPC_NOOP +#define PHPC_STR_EXISTS(_name) (_name) +#define PHPC_STR_DECLARE(_name) zend_string *_name +#define PHPC_STR_ARG(_name) zend_string *_name +#define PHPC_STR_ARG_VAL PHPC_STR_ARG +#define PHPC_STR_ARG_PTR(_name) zend_string **_name +#define PHPC_STR_ARG_PTR_VAL PHPC_STR_ARG_PTR +#define PHPC_STR_PASS(_name) _name +#define PHPC_STR_PASS_VAL PHPC_STR_PASS +#define PHPC_STR_PASS_PTR(_name) &_name +#define PHPC_STR_PASS_PTR_VAL PHPC_STR_PASS_PTR +#define PHPC_STR_DEREF_VAL(_name) *_name +#define PHPC_STR_FROM_PTR_STR(_str, _strp) _str = *_strp +#define PHPC_STR_FROM_PTR_VAL(_str, _strpv) _str = *_strpv +#define PHPC_STR_RETURN RETURN_STR +#define PHPC_STR_FROM_ZVAL(_str, _zv) _str = Z_STR(_zv) +#define PHPC_STR_FROM_PZVAL(_str, _pzv) _str = Z_STR_P(_pzv) +/* wrapper macros */ +#define PHPC_STR_INIT(_name, _cstr, _len) \ + _name = zend_string_init(_cstr, _len, 0) +#define PHPC_STR_ALLOC(_name, _len) \ + _name = zend_string_alloc(_len, 0) +#define PHPC_STR_REALLOC(_name, _len) \ + _name = zend_string_realloc(_name, _len, 0) +#define PHPC_STR_RELEASE(_name) \ + zend_string_release(_name) + +/* C string */ +#define PHPC_CSTRL_RETURN RETURN_STRINGL +#define PHPC_CSTR_RETURN RETURN_STRING +#define PHPC_CSTRL_RETVAL RETVAL_STRINGL +#define PHPC_CSTR_RETVAL RETVAL_STRING + +/* ZSTR */ +#define PHPC_ZSTR_VAL ZSTR_VAL + +/* Smart string */ +#ifdef PHPC_SMART_STR_INCLUDE +#include "zend_smart_str.h" +#endif /* PHPC_SMART_STR_INCLUDE */ + +#ifdef PHPC_SMART_CSTR_INCLUDE +#include "ext/standard/php_smart_string.h" +/* smart_str for C string has been renamed in PHP 7 so we have to wrap it */ +#define phpc_smart_cstr smart_string +#define phpc_smart_cstr_alloc smart_string_alloc +#define phpc_smart_cstr_free smart_string_free +#define phpc_smart_cstr_append smart_string_append +#define phpc_smart_cstr_appends smart_string_appends +#define phpc_smart_cstr_appendl smart_string_appendl +#define phpc_smart_cstr_appendc smart_string_appendc +#define phpc_smart_cstr_append_long smart_string_append_long +#define phpc_smart_cstr_append_unsigned smart_string_append_unsigned +#define phpc_smart_cstr_0 smart_string_0 +#endif /* PHPC_SMART_CSTR_INCLUDE */ + + +/* RESOURCE */ +typedef zend_resource phpc_res_entry_t; +typedef zend_resource * phpc_res_value_t; + +#define PHPC_RES_REGISTER zend_register_resource +#define PHPC_RES_FETCH(_pz_res, _res_type_name, _res_type) \ + zend_fetch_resource(Z_RES_P(_pz_res), _res_type_name, _res_type) +#define PHPC_RES_FETCH2(_pz_res, _res_type_name, _res_type_1, _res_type_2) \ + zend_fetch_resource2(Z_RES_P(_pz_res), _res_type_name, _res_type_1, _res_type_2) +#define PHPC_RES_DELETE(_pz_res) \ + zend_list_delete(Z_RES_P(_pz_res)) +#define PHPC_RES_CLOSE(_pz_res) \ + zend_list_close(Z_RES_P(_pz_res)) + +/* resource to zval */ +#define PHPC_RES_PZVAL(_res, _pzv) \ + ZVAL_RES(_pzv, _res) +#define PHPC_RES_RETVAL RETVAL_RES +#define PHPC_RES_RETURN RETURN_RES + + +/* OBJECT */ +#define PHPC_CLASS_REGISTER_EX(_orig_class_entry, _parent_ce, _parent_name) \ + zend_register_internal_class_ex(&_orig_class_entry, _parent_ce) +#define PHPC_CLASS_REGISTER(_orig_class_entry) \ + zend_register_internal_class(&_orig_class_entry) + +/* struct spec */ +#define PHPC_OBJ_STRUCT_MEMBER_FIRST +#define PHPC_OBJ_STRUCT_MEMBER_LAST zend_object std; +#define PHPC_OBJ_STRUCT_BEGIN(_name) \ + PHPC_OBJ_STRUCT_NAME(_name) { PHPC_OBJ_STRUCT_MEMBER_FIRST +#define PHPC_OBJ_STRUCT_END() \ + PHPC_OBJ_STRUCT_MEMBER_LAST }; + +#define PHPC_OBJ_FROM_ZOBJ(_name, _object) \ + (PHPC_OBJ_STRUCT_NAME(_name) *)((char*)(_object) - XtOffsetOf(PHPC_OBJ_STRUCT_NAME(_name), std)) +#define PHPC_OBJ_FROM_ZVAL(_name, _zv) \ + PHPC_OBJ_FROM_ZOBJ(_name, Z_OBJ_P(_zv)) +#if PHP_MAJOR_VERSION < 8 +#define PHPC_OBJ_FROM_POBJ PHPC_OBJ_FROM_ZVAL +#else +#define PHPC_OBJ_FROM_POBJ PHPC_OBJ_FROM_ZOBJ +#endif + +/* create_ex object handler helper */ +#define PHPC_OBJ_HANDLER_CREATE_EX(_name) \ + PHPC_OBJ_GET_HANDLER_FCE_INLINE_DEF(zend_object *, _name, create_ex) \ + (zend_class_entry *PHPC_CLASS_TYPE, int _phpc_init_props) +#define PHPC_OBJ_HANDLER_CREATE_EX_IS_NEW() _phpc_init_props +#define PHPC_OBJ_HANDLER_CREATE_EX_DECLARE() PHPC_NOOP +#define PHPC_OBJ_HANDLER_CREATE_EX_ALLOC(_name) \ + ecalloc(1, sizeof(PHPC_OBJ_STRUCT_NAME(_name)) + sizeof(zval) * (PHPC_CLASS_TYPE->default_properties_count - 1)); +#define PHPC_OBJ_HANDLER_INIT_CREATE_EX_PROPS(_intern) \ + do { \ + zend_object_std_init(&_intern->std, PHPC_CLASS_TYPE); \ + if (_phpc_init_props) { \ + PHPC_OBJ_PROPERTIES_INIT(&_intern->std, PHPC_CLASS_TYPE); \ + } \ + } while(0) +#define PHPC_OBJ_HANDLER_CREATE_EX_RETURN_EX(_name, _intern) \ + do { \ + _intern->std.handlers = &PHPC_OBJ_GET_HANDLER_VAR_NAME(_name); \ + return &_intern->std; \ + } while(0) + +/* create object handler */ +#define PHPC_OBJ_HANDLER_CREATE(_name) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(zend_object *, _name, create) \ + (zend_class_entry *PHPC_CLASS_TYPE) +#define PHPC_OBJ_HANDLER_CREATE_RETURN(_name) \ + return PHPC_OBJ_GET_HANDLER_FCE(_name, create_ex)(PHPC_CLASS_TYPE, 1) + +/* clone object handler */ +#define PHPC_OBJ_HANDLER_CLONE(_name) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(zend_object *, _name, clone)(phpc_obj_t *PHPC_SELF) +#define PHPC_OBJ_HANDLER_CLONE_DECLARE() PHPC_NOOP +#define PHPC_OBJ_HANDLER_CLONE_MEMBERS(_name, _new_obj, _old_obj) \ + do { \ + _new_obj = PHPC_OBJ_FROM_ZOBJ(_name, PHPC_OBJ_GET_HANDLER_FCE(_name, create_ex)(_old_obj->std.ce, 0)); \ + zend_objects_clone_members(&_new_obj->std, &_old_obj->std); \ + } while(0) +#define PHPC_OBJ_HANDLER_CLONE_RETURN_EX(_new_obj) return &_new_obj->std; + +/* free object handler */ +#define PHPC_OBJ_HANDLER_FREE(_name) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(void, _name, free)(zend_object *_phpc_object) +#define PHPC_OBJ_HANDLER_FREE_DTOR(_intern) \ + zend_object_std_dtor(&(_intern)->std) + +/* compare object handler */ +#define PHPC_OBJ_HANDLER_COMPARE(_name) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(int, _name, compare)(zval *_phpc_obj1, zval *_phpc_obj2) +#define PHPC_OBJ_HANDLER_COMPARE_FETCH(_name, _id, _obj) \ + PHPC_OBJ_STRUCT_DECLARE(_name, _obj) = PHPC_OBJ_FROM_ZVAL(_name, _phpc_obj ## _id) + +/* handler setters */ +#define PHPC_OBJ_SET_SPECIFIC_HANDLER_OFFSET(_handlers, _name) \ + (_handlers).offset = XtOffsetOf(PHPC_OBJ_STRUCT_NAME(_name), std) +#define PHPC_OBJ_SET_SPECIFIC_HANDLER_FREE(_handlers, _name) \ + (_handlers).free_obj = PHPC_OBJ_GET_HANDLER_FCE(_name, free) + +/* read propery */ +#define PHPC_READ_PROPERTY_RV_NAME _phpc_read_property_rv +#define PHPC_READ_PROPERTY_RV_DECLARE zval PHPC_READ_PROPERTY_RV_NAME +#define PHPC_READ_PROPERTY(_scope, _object, _name, _name_len, _silent) \ + zend_read_property(_scope, PHPC_OBJ_FOR_PROP(_object), _name, _name_len, _silent, &PHPC_READ_PROPERTY_RV_NAME) + + +/* HASH */ + +/* recursion protection */ +#if PHP_VERSION_ID < 70299 +#define PHPC_HASH_HAS_APPLY_COUNT(_tht) (ZEND_HASH_GET_APPLY_COUNT(_tht) > 0) +#define PHPC_HASH_GET_APPLY_COUNT ZEND_HASH_GET_APPLY_COUNT +#define PHPC_HASH_INC_APPLY_COUNT ZEND_HASH_INC_APPLY_COUNT +#define PHPC_HASH_DEC_APPLY_COUNT ZEND_HASH_DEC_APPLY_COUNT +#define PHPC_HASH_APPLY_PROTECTION ZEND_HASH_APPLY_PROTECTION +#else +#define PHPC_HASH_HAS_APPLY_COUNT GC_IS_RECURSIVE +#define PHPC_HASH_GET_APPLY_COUNT GC_IS_RECURSIVE +#define PHPC_HASH_INC_APPLY_COUNT GC_PROTECT_RECURSION +#define PHPC_HASH_DEC_APPLY_COUNT GC_UNPROTECT_RECURSION +#define PHPC_HASH_APPLY_PROTECTION(_tht) (!(GC_FLAGS(_tht) & GC_IMMUTABLE)) +#endif +/* add ptr */ +#define PHPC_HASH_INDEX_ADD_PTR(_ht, _idx, _ptr, _ptr_size) \ + zend_hash_index_add_ptr(_ht, _idx, _ptr) +#define PHPC_HASH_STR_ADD_PTR(_ht, _str, _ptr, _ptr_size) \ + zend_hash_add_ptr(_ht, _str, _ptr) +#define PHPC_HASH_CSTRL_ADD_PTR(_ht, _cstr_value, _cstr_len, _ptr, _ptr_size) \ + zend_hash_str_add_ptr(_ht, _cstr_value, _cstr_len, _ptr) +#define PHPC_HASH_CSTR_ADD_PTR(_ht, _cstr_value, _ptr, _ptr_size) \ + zend_hash_str_add_ptr(_ht, _cstr_value, strlen(_cstr_value), _ptr) +/* add */ +#define PHPC_HASH_INDEX_ADD zend_hash_index_add +#define PHPC_HASH_STR_ADD zend_hash_add +#define PHPC_HASH_CSTRL_ADD zend_hash_str_add +#define PHPC_HASH_CSTR_ADD(_ht, _cstr_value, _pzv) \ + zend_hash_str_add(_ht, _cstr_value, strlen(_cstr_value), _pzv) + +/* next insert */ +#define PHPC_HASH_NEXT_INDEX_INSERT_PTR(_ht, _ptr, _ptr_size) \ + zend_hash_next_index_insert_ptr(_ht, _ptr) +#define PHPC_HASH_NEXT_INDEX_INSERT zend_hash_next_index_insert + +/* update ptr */ +#define PHPC_HASH_INDEX_UPDATE_PTR(_ht, _idx, _ptr, _ptr_size) \ + zend_hash_index_update_ptr(_ht, _idx, _ptr) +#define PHPC_HASH_STR_UPDATE_PTR(_ht, _str, _ptr, _ptr_size) \ + zend_hash_update_ptr(_ht, _str, _ptr) +#define PHPC_HASH_CSTRL_UPDATE_PTR(_ht, _cstr_value, _cstr_len, _ptr, _ptr_size) \ + zend_hash_str_update_ptr(_ht, _cstr_value, _cstr_len, _ptr) +#define PHPC_HASH_CSTR_UPDATE_PTR(_ht, _cstr_value, _ptr, _ptr_size) \ + zend_hash_str_update_ptr(_ht, _cstr_value, strlen(_cstr_value), _ptr) +/* update */ +#define PHPC_HASH_INDEX_UPDATE zend_hash_index_update +#define PHPC_HASH_STR_UPDATE zend_hash_update +#define PHPC_HASH_CSTRL_UPDATE zend_hash_str_update +#define PHPC_HASH_CSTR_UPDATE(_ht, _cstr_value, _pzv) \ + zend_hash_str_update(_ht, _cstr_value, strlen(_cstr_value), _pzv) + +/* delete */ +#define PHPC_HASH_INDEX_DELETE zend_hash_index_del +#define PHPC_HASH_STR_DELETE zend_hash_del +#define PHPC_HASH_CSTRL_DELETE zend_hash_str_del +#define PHPC_HASH_CSTR_DELETE(_ht, _cstr_value) \ + zend_hash_str_del(_ht, _cstr_value, strlen(_cstr_value)) + +/* exists */ +#define PHPC_HASH_INDEX_EXISTS zend_hash_index_exists +#define PHPC_HASH_STR_EXISTS zend_hash_exists +#define PHPC_HASH_CSTRL_EXISTS zend_hash_str_exists +#define PHPC_HASH_CSTR_EXISTS(_ht, _cstr_value) \ + zend_hash_str_exists(_ht, _cstr_value, strlen(_cstr_value)) + +/* find */ +#define PHPC_HASH_STR_FIND(_ht, _str, _ppv) \ + _ppv = zend_hash_find(_ht, _str) +#define PHPC_HASH_CSTRL_FIND(_ht, _cstr_value, _cstr_len, _ppv) \ + _ppv = zend_hash_str_find(_ht, _cstr_value, _cstr_len) +#define PHPC_HASH_CSTR_FIND(_ht, _cstr_value, _ppv) \ + _ppv = zend_hash_str_find(_ht, _cstr_value, strlen(_cstr_value)) +#define PHPC_HASH_INDEX_FIND(_ht, _idx, _ppv) \ + _ppv = zend_hash_index_find(_ht, _idx) +/* find ptr */ +#define PHPC_HASH_STR_FIND_PTR(_ht, _str, _ptr) \ + _ptr = zend_hash_find_ptr(_ht, _str) +#define PHPC_HASH_CSTRL_FIND_PTR(_ht, _cstr_value, _cstr_len, _ptr) \ + _ptr = zend_hash_str_find_ptr(_ht, _cstr_value, _cstr_len) +#define PHPC_HASH_CSTR_FIND_PTR(_ht, _cstr_value, _ptr) \ + _ptr = zend_hash_str_find_ptr(_ht, _cstr_value, strlen(_cstr_value)) +#define PHPC_HASH_INDEX_FIND_PTR(_ht, _idx, _ptr) \ + _ptr = zend_hash_index_find_ptr(_ht, _idx) +/* not found value */ +#define PHPC_HASH_NOT_FOUND NULL + +/* iteration for each element */ +#define PHPC_HASH_FOREACH_KEY ZEND_HASH_FOREACH_KEY +#define PHPC_HASH_FOREACH_VAL ZEND_HASH_FOREACH_VAL +#define PHPC_HASH_FOREACH_VAL_IND ZEND_HASH_FOREACH_VAL_IND +#define PHPC_HASH_FOREACH_KEY_VAL ZEND_HASH_FOREACH_KEY_VAL +#define PHPC_HASH_FOREACH_KEY_VAL_IND ZEND_HASH_FOREACH_KEY_VAL_IND +#define PHPC_HASH_FOREACH_STR_KEY_VAL ZEND_HASH_FOREACH_STR_KEY_VAL +#define PHPC_HASH_FOREACH_STR_KEY_VAL_IND ZEND_HASH_FOREACH_STR_KEY_VAL_IND +#define PHPC_HASH_FOREACH_END ZEND_HASH_FOREACH_END + +/* key and data getter */ +#define PHPC_HASH_GET_CURRENT_KEY_EX(_ht, _str, _num_index, _pos) \ + zend_hash_get_current_key_ex(_ht, &_str, &_num_index, _pos) +#define PHPC_HASH_GET_CURRENT_DATA_EX(_ht, _val, _pos) \ + _val = zend_hash_get_current_data_ex(_ht, _pos) + +#define PHPC_HASH_GET_CURRENT_KEY(_ht, _str, _num_index) \ + zend_hash_get_current_key(_ht, &_str, &_num_index) +#define PHPC_HASH_GET_CURRENT_DATA(_ht, _val) \ + _val = zend_hash_get_current_data(_ht) + +/* copy */ +#define PHPC_HASH_COPY_EX(_target, _source, _copy_ctr) \ + zend_hash_copy(_target, _source, NULL) + +/* hash to zval */ +#define PHPC_HASH_PZVAL(_ht, _pzv) \ + ZVAL_ARR(_pzv, _ht) +#define PHPC_HASH_RETVAL RETVAL_ARR +#define PHPC_HASH_RETURN RETURN_ARR + + +/* SYMTABLE */ + +/* update*/ +#define PHPC_SYMTABLE_UPDATE zend_symtable_update + + +/* ARRAY */ + +#define PHPC_ARRAY_ADD_ASSOC_NULL_EX add_assoc_null_ex +#define PHPC_ARRAY_ADD_ASSOC_BOOL_EX add_assoc_bool_ex +#define PHPC_ARRAY_ADD_ASSOC_LONG_EX add_assoc_long_ex +#define PHPC_ARRAY_ADD_ASSOC_RESOURCE_EX add_assoc_resource_ex +#define PHPC_ARRAY_ADD_ASSOC_DOUBLE_EX add_assoc_double_ex +#define PHPC_ARRAY_ADD_ASSOC_STR_EX add_assoc_str_ex +#define PHPC_ARRAY_ADD_ASSOC_CSTR_EX add_assoc_string_ex +#define PHPC_ARRAY_ADD_ASSOC_CSTRL_EX add_assoc_stringl_ex +#define PHPC_ARRAY_ADD_ASSOC_ZVAL_EX add_assoc_zval_ex +#define PHPC_ARRAY_ADD_ASSOC_VAL_EX(_arr, _key, _key_len, _pv) \ + add_assoc_zval_ex(_arr, _key, _key_len, &_pv) + +#define PHPC_ARRAY_ADD_ASSOC_STR add_assoc_str +#define PHPC_ARRAY_ADD_ASSOC_CSTR add_assoc_string +#define PHPC_ARRAY_ADD_ASSOC_CSTRL add_assoc_stringl +#define PHPC_ARRAY_ADD_ASSOC_VAL(_arr, _key, _pv) \ + add_assoc_zval(_arr, _key, &_pv) + +#define PHPC_ARRAY_ADD_INDEX_STR add_index_str +#define PHPC_ARRAY_ADD_INDEX_CSTR add_index_string +#define PHPC_ARRAY_ADD_INDEX_CSTRL add_index_stringl +#define PHPC_ARRAY_ADD_INDEX_VAL(_arr, _idx, _pv) \ + add_index_zval(_arr, _idx, &_pv) + +#define PHPC_ARRAY_ADD_NEXT_INDEX_STR add_next_index_str +#define PHPC_ARRAY_ADD_NEXT_INDEX_CSTR add_next_index_string +#define PHPC_ARRAY_ADD_NEXT_INDEX_CSTRL add_next_index_stringl +#define PHPC_ARRAY_ADD_NEXT_INDEX_VAL(_arr, _pv) \ + add_next_index_zval(_arr, &_pv) + +/* FCALL */ +#define PHPC_FCALL_PARAMS_DECLARE(_pname, _count) \ + zval PHPC_FCALL_PARAMS_NAME(_pname)[_count] + +#define PHPC_FCALL_PARAMS_INIT(_pname) PHPC_NOOP + +#define PHPC_FCALL_PARAM_PZVAL(_pname, _idx) \ + &PHPC_FCALL_PARAMS_NAME(_pname)[_idx] + +#define PHPC_FCALL_PARAM_VAL(_pname, _idx) \ + PHPC_FCALL_PARAMS_NAME(_pname)[_idx] + +#define PHPC_FCALL_PARAM_UNDEF(_pname, _idx) \ + ZVAL_UNDEF(PHPC_FCALL_PARAM_PZVAL(_pname, _idx)) + +#define PHPC_FCALL_RETVAL(_fci, _pv) \ + (_fci).retval = (&_pv) + + +/* ZVAL */ +typedef zval phpc_val; + +#define PHPC_TYPE Z_TYPE +#define PHPC_TYPE_P Z_TYPE_P + +#define PHPC_LVAL Z_LVAL +#define PHPC_LVAL_P Z_LVAL_P + +#define PHPC_DVAL Z_DVAL +#define PHPC_DVAL_P Z_DVAL_P + +#define PHPC_STRVAL Z_STRVAL +#define PHPC_STRVAL_P Z_STRVAL_P + +#define PHPC_STRLEN Z_STRLEN +#define PHPC_STRLEN_P Z_STRLEN_P + +#define PHPC_ARRVAL Z_ARRVAL +#define PHPC_ARRVAL_P Z_ARRVAL_P + +#define PHPC_OBJ_HT Z_OBJ_HT +#define PHPC_OBJ_HT_P Z_OBJ_HT_P + +#define PHPC_OBJ_HANDLER Z_OBJ_HANDLER +#define PHPC_OBJ_HANDLER_P Z_OBJ_HANDLER_P + +#define PHPC_OBJ_HANDLE Z_OBJ_HANDLE +#define PHPC_OBJ_HANDLE_P Z_OBJ_HANDLE_P + +#define PHPC_OBJCE Z_OBJCE +#define PHPC_OBJCE_P Z_OBJCE_P + +#define PHPC_OBJPROP Z_OBJPROP +#define PHPC_OBJPROP_P Z_OBJPROP_P + +#define PHPC_OBJDEBUG Z_OBJDEBUG +#define PHPC_OBJDEBUG_P Z_OBJDEBUG_P + +#define PHPC_REFCOUNTED Z_REFCOUNTED +#define PHPC_REFCOUNTED_P Z_REFCOUNTED_P + +#define PHPC_PZVAL_CAST_TO_PVAL(_pzv) _pzv + +#define PHPC_VAL_CAST_TO_ZVAL(_pv) _pv +#define PHPC_VAL_CAST_TO_PZVAL(_pv) &(_pv) +#define PHPC_PVAL_CAST_TO_PZVAL(_ppv) _ppv + +#define PHPC_VAL_TO_ZVAL(_pv, _zv) _zv = _pv +#define PHPC_VAL_TO_PZVAL(_pv, _zv) _zv = &(_pv) +#define PHPC_PVAL_TO_PZVAL(_ppv, _zv) _zv = _ppv + +#define PHPC_VAL_MAKE(_pv) PHPC_NOOP +#define PHPC_VAL_FREE(_pv) PHPC_NOOP +#define PHPC_VAL_UNDEF(_pv) ZVAL_UNDEF(&(_pv)) +#define PHPC_VAL_ISUNDEF(_pv) Z_ISUNDEF(_pv) +#define PHPC_VAL_COPY(_pv, _zv) ZVAL_COPY(&(_pv), _zv) +#define PHPC_VAL_ASSIGN PHPC_VAL_COPY + +#define PHPC_PZVAL_MAKE(_pzv) PHPC_NOOP +#define PHPC_PZVAL_FREE(_pzv) PHPC_NOOP +#define PHPC_PZVAL_SET(_pv, _zv) _pv = _zv +#define PHPC_PVAL_DEREF ZVAL_DEREF +#define PHPC_PZVAL_DEREF ZVAL_DEREF + +#define PHPC_PZVAL_COPY_INIT ZVAL_COPY_VALUE +#define PHPC_PZVAL_COPY ZVAL_COPY_VALUE + +#define PHPC_VAL_NEW_STR(_pv, _str) \ + ZVAL_NEW_STR(&_pv, _str) +#define PHPC_VAL_STR(_pv, _str) \ + ZVAL_STR(&_pv, _str) +#define PHPC_VAL_CSTR(_pv, _cstr) \ + ZVAL_STRING(&_pv, _cstr) +#define PHPC_VAL_CSTRL(_pv, _cstr, _cstr_len) \ + ZVAL_STRINGL(&_pv, _cstr, _cstr_len) + +#define PHPC_PZVAL_NEW_STR ZVAL_NEW_STR +#define PHPC_PZVAL_STR ZVAL_STR +#define PHPC_PZVAL_CSTR ZVAL_STRING +#define PHPC_PZVAL_CSTRL ZVAL_STRINGL + +#define PHPC_ZVAL_COPY(_zv_dst, _zv_src) \ + ZVAL_COPY_VALUE(&_zv_dst, &_zv_src) + +#define PHPC_ZVAL_NEW_STR PHPC_VAL_NEW_STR +#define PHPC_ZVAL_STR PHPC_VAL_STR +#define PHPC_ZVAL_CSTR PHPC_VAL_CSTR +#define PHPC_ZVAL_CSTRL PHPC_VAL_CSTRL + +#define PHPC_ZVAL_IS_TRUE(_zv) \ + (Z_TYPE(_zv) == IS_TRUE) +#define PHPC_ZVAL_IS_FALSE(_zv) \ + (Z_TYPE(_zv) == IS_FALSE) + +#define PHPC_VAL_IS_TRUE PHPC_ZVAL_IS_TRUE +#define PHPC_VAL_IS_FALSE PHPC_ZVAL_IS_FALSE + +#define PHPC_FE_END PHP_FE_END + + +/* ZPP */ + +/* path flag */ +#define PHPC_ZPP_PATH_FLAG "p" + +/* args */ +#define PHPC_ZPP_ARGS_DECLARE() \ + int _phpc_zpp_args_count = 0; \ + zval *_phpc_zpp_args_array + +#define PHPC_ZPP_ARGS_LOAD_EX(_flag, _num_args, _return) \ + do { \ + if (zend_parse_parameters(_num_args, #_flag, \ + &_phpc_zpp_args_array, &_phpc_zpp_args_count) == FAILURE) { \ + _return; \ + } \ + } while(0) + +#define PHPC_ZPP_ARGS_GET_PVAL(_arg_pos) \ + &_phpc_zpp_args_array[_arg_pos] + +#define PHPC_ZPP_ARGS_FREE() PHPC_NOOP + + +/* STREAM */ +typedef const char phpc_stream_opener_char_t; +#define PHPC_STREAM_WRAPPERDATA_ALLOC(stream) PHPC_NOOP +#define PHPC_STREAM_WRAPPERDATA_ISSET(stream) (Z_TYPE(stream->wrapperdata) != IS_UNDEF) +#define PHPC_STREAM_WRAPPERDATA_UNSET(stream) \ + do { \ + zval_ptr_dtor(&stream->wrapperdata); \ + ZVAL_UNDEF(&stream->wrapperdata); \ + } while(0) +#define PHPC_STREAM_CONTEXT_GET_OPTION(_ctx, _wrappername, _optionname, _ppv) \ + _ppv = php_stream_context_get_option(_ctx, _wrappername, _optionname) +#define PHPC_STREAM_CONTEXT_OPTION_NOT_FOUND NULL + +#endif /* PHP_MAJOR_VERSION */ + + +/* COMMON (dependent definitions) */ + +/* object structure */ +#define PHP_OBJ_GET_HANDLER_OBJ_FROM_ZOBJ(_name) \ + PHPC_OBJ_FROM_ZOBJ(_name, _phpc_object) +#define PHPC_OBJ_STRUCT_DECLARE_AND_FETCH_FROM_ZOBJ(_name, _ptr) \ + PHPC_OBJ_STRUCT_DECLARE(_name, _ptr) = PHP_OBJ_GET_HANDLER_OBJ_FROM_ZOBJ(_name) +#define PHPC_OBJ_FROM_SELF(_name) \ + PHPC_OBJ_FROM_POBJ(_name, PHPC_SELF) + + +/* this object */ +#define PHPC_THIS _phpc_this +#define PHPC_THIS_DECLARE(_name) PHPC_OBJ_STRUCT_DECLARE(_name, PHPC_THIS) +#define PHPC_THIS_FETCH_FROM_ZVAL(_name, _zv) \ + PHPC_THIS = PHPC_OBJ_FROM_ZVAL(_name, _zv) +#define PHPC_THIS_FETCH(_name) \ + PHPC_THIS_FETCH_FROM_ZVAL(_name, getThis()) +#define PHPC_THIS_DECLARE_AND_FETCH_FROM_ZVAL(_name, _zv) \ + PHPC_THIS_DECLARE(_name) = PHPC_THIS_FETCH_FROM_ZVAL(_name, _zv) +#define PHPC_THIS_FETCH_FROM_SELF(_name) \ + PHPC_THIS = PHPC_OBJ_FROM_SELF(_name) +#define PHPC_THIS_DECLARE_AND_FETCH_FROM_SELF(_name) \ + PHPC_THIS_DECLARE(_name) = PHPC_OBJ_FROM_SELF(_name) +#define PHPC_THIS_DECLARE_AND_FETCH(_name) \ + PHPC_THIS_DECLARE_AND_FETCH_FROM_ZVAL(_name, getThis()) + +/* that object */ +#define PHPC_THAT _phpc_that +#define PHPC_THAT_DECLARE(_name) PHPC_OBJ_STRUCT_DECLARE(_name, PHPC_THAT) + +/* object helper create_ex */ +#define PHPC_OBJ_HANDLER_CREATE_EX_INIT(_name) \ + PHPC_OBJ_HANDLER_CREATE_EX_DECLARE(); \ + PHPC_THIS_DECLARE(_name); \ + PHPC_THIS = PHPC_OBJ_HANDLER_CREATE_EX_ALLOC(_name); \ + PHPC_OBJ_HANDLER_INIT_CREATE_EX_PROPS(PHPC_THIS) +#define PHPC_OBJ_HANDLER_CREATE_EX_RETURN(_name) \ + PHPC_OBJ_HANDLER_CREATE_EX_RETURN_EX(_name, PHPC_THIS) + +/* object handler clone */ +#define PHPC_OBJ_HANDLER_CLONE_INIT(_name) \ + PHPC_OBJ_HANDLER_CLONE_DECLARE(); \ + PHPC_THIS_DECLARE(_name); \ + PHPC_THAT_DECLARE(_name); \ + PHPC_THIS = PHPC_OBJ_FROM_SELF(_name); \ + PHPC_OBJ_HANDLER_CLONE_MEMBERS(_name, PHPC_THAT, PHPC_THIS) +#define PHPC_OBJ_HANDLER_CLONE_RETURN() \ + PHPC_OBJ_HANDLER_CLONE_RETURN_EX(PHPC_THAT) + +/* object handler free */ +#define PHPC_OBJ_HANDLER_FREE_INIT(_name) \ + PHPC_OBJ_STRUCT_DECLARE_AND_FETCH_FROM_ZOBJ(_name, PHPC_THIS); +#define PHPC_OBJ_HANDLER_FREE_DESTROY() \ + PHPC_OBJ_HANDLER_FREE_DTOR(PHPC_THIS) + +/* object handler compare */ +#define PHPC_OBJ_HANDLER_COMPARE_INIT(_name) \ + PHPC_OBJ_HANDLER_COMPARE_FETCH(_name, 1, PHPC_THIS); \ + PHPC_OBJ_HANDLER_COMPARE_FETCH(_name, 2, PHPC_THAT) + +/* object handler get_gc */ +#define PHPC_GC_TABLE _phpc_gc_table +#define PHPC_GC_N _phpc_gc_n +#define PHPC_OBJ_HANDLER_GET_GC(_name) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(HashTable *, _name, get_gc)\ + (phpc_obj_t *PHPC_SELF, phpc_val **PHPC_GC_TABLE, int *PHPC_GC_N TSRMLS_DC) + +/* object handler get_debug_info */ +#define PHPC_DEBUG_INFO_IS_TEMP _phpc_debug_info_is_temp +#define PHPC_OBJ_HANDLER_GET_DEBUG_INFO(_name) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(HashTable *, _name, get_debug_info)\ + (phpc_obj_t *PHPC_SELF, int *PHPC_DEBUG_INFO_IS_TEMP TSRMLS_DC) + +/* object handler get_properties */ +#define PHPC_OBJ_HANDLER_GET_PROPERTIES(_name) \ + PHPC_OBJ_DEFINE_HANDLER_FCE(HashTable *, _name, get_properties)\ + (phpc_obj_t *PHPC_SELF TSRMLS_DC) + +/* object handler setters */ +#define PHPC_CLASS_SET_HANDLER_CREATE(_class_entry, _name) \ + _class_entry.create_object = PHPC_OBJ_GET_HANDLER_FCE(_name, create) +#define PHPC_OBJ_SET_SPECIFIC_HANDLER_CLONE(_handlers, _name) \ + (_handlers).clone_obj = PHPC_OBJ_GET_HANDLER_FCE(_name, clone) +#define PHPC_OBJ_SET_HANDLER_CLONE(_name) \ + PHPC_OBJ_SET_SPECIFIC_HANDLER_CLONE(PHPC_OBJ_GET_HANDLER_VAR_NAME(_name), _name) +#define PHPC_OBJ_SET_HANDLER_COMPARE(_name) \ + PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).PHPC_OBJ_HANDLER_COMPARE_NAME \ + = PHPC_OBJ_GET_HANDLER_FCE(_name, compare) +#define PHPC_OBJ_HAS_HANDLER_GET_GC (PHP_VERSION_ID > 50399) +#if PHPC_OBJ_HAS_HANDLER_GET_GC +#define PHPC_OBJ_SET_HANDLER_GET_GC(_name) \ + PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).get_gc = PHPC_OBJ_GET_HANDLER_FCE(_name, get_gc) +#else +#define PHPC_OBJ_SET_HANDLER_GET_GC(_name) PHPC_NOOP +#endif +#define PHPC_OBJ_HAS_HANDLER_GET_DEBUG_INFO (PHP_VERSION_ID > 50299) +#if PHPC_OBJ_HAS_HANDLER_GET_DEBUG_INFO +#define PHPC_OBJ_SET_HANDLER_GET_DEBUG_INFO(_name) \ + PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).get_debug_info = PHPC_OBJ_GET_HANDLER_FCE(_name, get_debug_info) +#else +#define PHPC_OBJ_SET_HANDLER_GET_DEBUG_INFO(_name) PHPC_NOOP +#endif +/* there is such handler in 5.2 but we would have to re-implement zend_std_get_properties */ +#define PHPC_OBJ_HAS_HANDLER_GET_PROPERTIES (PHP_VERSION_ID > 50299) +#if PHPC_OBJ_HAS_HANDLER_GET_PROPERTIES +#define PHPC_OBJ_SET_HANDLER_GET_PROPERTIES(_name) \ + PHPC_OBJ_GET_HANDLER_VAR_NAME(_name).get_properties = PHPC_OBJ_GET_HANDLER_FCE(_name, get_properties) +#else +#define PHPC_OBJ_SET_HANDLER_GET_PROPERTIES(_name) PHPC_NOOP +#endif +#define PHPC_OBJ_SET_HANDLER_OFFSET(_name) \ + PHPC_OBJ_SET_SPECIFIC_HANDLER_OFFSET(PHPC_OBJ_GET_HANDLER_VAR_NAME(_name), _name) +#define PHPC_OBJ_SET_HANDLER_FREE(_name) \ + PHPC_OBJ_SET_SPECIFIC_HANDLER_FREE(PHPC_OBJ_GET_HANDLER_VAR_NAME(_name), _name) + +/* hash */ +#define PHPC_HASH_ALLOC ALLOC_HASHTABLE +#define PHPC_HASH_INIT zend_hash_init +#define PHPC_HASH_NUM_ELEMENTS zend_hash_num_elements + +#define PHPC_HASH_HAS_MORE_ELEMENTS_EX zend_hash_has_more_elements_ex +#define PHPC_HASH_MOVE_FORWARD_EX zend_hash_move_forward_ex +#define PHPC_HASH_MOVE_BACKWARDS_EX zend_hash_move_backwards_ex +#define PHPC_HASH_GET_CURRENT_KEY_ZVAL_EX zend_hash_get_current_key_zval_ex +#define PHPC_HASH_GET_CURRENT_KEY_TYPE_EX zend_hash_get_current_key_type_ex +#define PHPC_HASH_INTERNAL_POINTER_RESET_EX zend_hash_internal_pointer_reset_ex +#define PHPC_HASH_INTERNAL_POINTER_END_EX zend_hash_internal_pointer_end_ex + +#define PHPC_HASH_HAS_MORE_ELEMENTS zend_hash_has_more_elements +#define PHPC_HASH_MOVE_FORWARD zend_hash_move_forward +#define PHPC_HASH_MOVE_BACKWARDS zend_hash_move_backwards +#define PHPC_HASH_GET_CURRENT_KEY_ZVAL zend_hash_get_current_key_zval +#define PHPC_HASH_GET_CURRENT_KEY_TYPE zend_hash_get_current_key_type +#define PHPC_HASH_INTERNAL_POINTER_RESET zend_hash_internal_pointer_reset +#define PHPC_HASH_INTERNAL_POINTER_END zend_hash_internal_pointer_end + +/* find */ +#define PHPC_HASH_IS_FOUND(_found) ((_found) != PHPC_HASH_NOT_FOUND) +/* find in cond */ +#define PHPC_HASH_STR_FIND_IN_COND(_ht, _str, _ppv) \ + PHPC_HASH_IS_FOUND(PHPC_HASH_STR_FIND(_ht, _str, _ppv)) +#define PHPC_HASH_CSTRL_FIND_IN_COND(_ht, _cstr_value, _cstr_len, _ppv) \ + PHPC_HASH_IS_FOUND(PHPC_HASH_CSTRL_FIND(_ht, _cstr_value, _cstr_len, _ppv)) +#define PHPC_HASH_CSTR_FIND_IN_COND(_ht, _cstr_value, _ppv) \ + PHPC_HASH_IS_FOUND(PHPC_HASH_CSTR_FIND(_ht, _cstr_value, _ppv)) +#define PHPC_HASH_INDEX_FIND_IN_COND(_ht, _idx, _ppv) \ + PHPC_HASH_IS_FOUND(PHPC_HASH_INDEX_FIND(_ht, _idx, _ppv)) +/* find ptr in cond */ +#define PHPC_HASH_STR_FIND_PTR_IN_COND(_ht, _str, _ptr) \ + PHPC_HASH_IS_FOUND(PHPC_HASH_STR_FIND_PTR(_ht, _str, _ptr)) +#define PHPC_HASH_CSTRL_FIND_PTR_IN_COND(_ht, _cstr_value, _cstr_len, _ptr) \ + PHPC_HASH_IS_FOUND(PHPC_HASH_CSTRL_FIND_PTR(_ht, _cstr_value, _cstr_len, _ptr)) +#define PHPC_HASH_CSTR_FIND_PTR_IN_COND(_ht, _cstr_value, _ptr) \ + PHPC_HASH_IS_FOUND(PHPC_HASH_CSTR_FIND_PTR(_ht, _cstr_value, _ptr)) +#define PHPC_HASH_INDEX_FIND_PTR_IN_COND(_ht, _idx, _ptr) \ + PHPC_HASH_IS_FOUND(PHPC_HASH_INDEX_FIND_PTR(_ht, _idx, _ptr)) + +/* copy */ +#define PHPC_HASH_COPY(_target, _source) \ + PHPC_HASH_COPY_EX(_target, _source, NULL) + +/* array */ +#define PHPC_ARRAY_INIT array_init +#if PHP_VERSION_ID < 50299 +#define PHPC_ARRAY_INIT_SIZE(_arr, _size) array_init(_arr) +#else +#define PHPC_ARRAY_INIT_SIZE array_init_size +#endif + +#define PHPC_ARRAY_ADD_ASSOC_NULL add_assoc_null +#define PHPC_ARRAY_ADD_ASSOC_BOOL add_assoc_bool +#define PHPC_ARRAY_ADD_ASSOC_LONG add_assoc_long +#define PHPC_ARRAY_ADD_ASSOC_RESOURCE add_assoc_resource +#define PHPC_ARRAY_ADD_ASSOC_DOUBLE add_assoc_double +#define PHPC_ARRAY_ADD_ASSOC_ZVAL add_assoc_zval + +#define PHPC_ARRAY_ADD_INDEX_NULL add_index_null +#define PHPC_ARRAY_ADD_INDEX_BOOL add_index_bool +#define PHPC_ARRAY_ADD_INDEX_LONG add_index_long +#define PHPC_ARRAY_ADD_INDEX_RESOURCE add_index_resource +#define PHPC_ARRAY_ADD_INDEX_DOUBLE add_index_double +#define PHPC_ARRAY_ADD_INDEX_ZVAL add_index_zval + +#define PHPC_ARRAY_ADD_NEXT_INDEX_NULL add_next_index_null +#define PHPC_ARRAY_ADD_NEXT_INDEX_BOOL add_next_index_bool +#define PHPC_ARRAY_ADD_NEXT_INDEX_LONG add_next_index_long +#define PHPC_ARRAY_ADD_NEXT_INDEX_RESOURCE add_next_index_resource +#define PHPC_ARRAY_ADD_NEXT_INDEX_DOUBLE add_next_index_double +#define PHPC_ARRAY_ADD_NEXT_INDEX_ZVAL add_next_index_zval + +/* ZPP */ +/* alias for path flag */ +#define PHPC_PATH_ZPP_FLAG PHPC_ZPP_PATH_FLAG + +/* args loading */ +#define PHPC_ZPP_ARGS_LOAD(_flag) PHPC_ZPP_ARGS_LOAD_EX(_flag, ZEND_NUM_ARGS(), return) + +#define PHPC_ZPP_ARGS_LOOP_START_EX(_start) \ + do { \ + int _phpc_zpp_args_i; \ + for (_phpc_zpp_args_i = _start; _phpc_zpp_args_i < _phpc_zpp_args_count; _phpc_zpp_args_i++) + +#define PHPC_ZPP_ARGS_LOOP_START() PHPC_ZPP_ARGS_LOOP_START_EX(0) + +#define PHPC_ZPP_ARGS_LOOP_END() \ + } while(0) + +#define PHPC_ZPP_ARGS_GET_CURRENT_PVAL() PHPC_ZPP_ARGS_GET_PVAL(_phpc_zpp_args_i) + +#define PHPC_ZPP_ARGS_COUNT _phpc_zpp_args_count + +/* FCALL */ +#if PHP_API_VERSION < 20090626 +#define PHPC_FCALL_INFO_INIT(_callable, _check_flags, _fci, _fci_cache, _callable_name, _error) \ + zend_fcall_info_init(_callable, &fci, &fci_cache TSRMLS_CC) +#else +#define PHPC_FCALL_INFO_INIT(_callable, _check_flags, _fci, _fci_cache, _callable_name, _error) \ + zend_fcall_info_init(_callable, _check_flags, _fci, _fci_cache, _callable_name, _error TSRMLS_CC) +#endif + +/* stream */ +#define PHPC_STREAM_CONTEXT_GET_OPTION_IN_COND(_ctx, _wrappername, _optionname, _ppv) \ + ((PHPC_STREAM_CONTEXT_GET_OPTION(_ctx, _wrappername, _optionname, _ppv)) != \ + PHPC_STREAM_CONTEXT_OPTION_NOT_FOUND) + +#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 6) || (PHP_MAJOR_VERSION > 5) +#define PHPC_STREAM_LOCATE_URL_WRAPPER(_path, _path_for_open, _options) \ + php_stream_locate_url_wrapper(_path, (const char **) _path_for_open, _options TSRMLS_CC) +#else +#define PHPC_STREAM_LOCATE_URL_WRAPPER(_path, _path_for_open, _options) \ + php_stream_locate_url_wrapper(_path, (char **) _path_for_open, _options TSRMLS_CC) +#endif + +#if (PHP_MAJOR_VERSION == 8 && PHP_MINOR_VERSION >= 1) || (PHP_MAJOR_VERSION > 8) +#define PHPC_PHP_STAT(_filename, _filename_length, _type, _return_value) do { \ + zend_string *_phpc_stat_str = zend_string_init(_filename, _filename_length, 0); \ + php_stat(_phpc_stat_str, _type, _return_value); \ + zend_string_release(_phpc_stat_str); \ + } while (0) + +#else +#define PHPC_PHP_STAT php_stat +#endif + +#endif /* PHPC_H */ + -- cgit