Annotation of embedaddon/php/Zend/zend_API.h, revision 1.1.1.4

1.1       misho       1: /*
                      2:    +----------------------------------------------------------------------+
                      3:    | Zend Engine                                                          |
                      4:    +----------------------------------------------------------------------+
1.1.1.4 ! misho       5:    | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |
1.1       misho       6:    +----------------------------------------------------------------------+
                      7:    | This source file is subject to version 2.00 of the Zend license,     |
                      8:    | that is bundled with this package in the file LICENSE, and is        |
                      9:    | available through the world-wide-web at the following url:           |
                     10:    | http://www.zend.com/license/2_00.txt.                                |
                     11:    | If you did not receive a copy of the Zend license and are unable to  |
                     12:    | obtain it through the world-wide-web, please send a note to          |
                     13:    | license@zend.com so we can mail you a copy immediately.              |
                     14:    +----------------------------------------------------------------------+
                     15:    | Authors: Andi Gutmans <andi@zend.com>                                |
                     16:    |          Zeev Suraski <zeev@zend.com>                                |
                     17:    |          Andrei Zmievski <andrei@php.net>                            |
                     18:    +----------------------------------------------------------------------+
                     19: */
                     20: 
1.1.1.2   misho      21: /* $Id$ */
1.1       misho      22: 
                     23: #ifndef ZEND_API_H
                     24: #define ZEND_API_H
                     25: 
                     26: #include "zend_modules.h"
                     27: #include "zend_list.h"
                     28: #include "zend_operators.h"
                     29: #include "zend_variables.h"
                     30: #include "zend_execute.h"
                     31: 
                     32: 
                     33: BEGIN_EXTERN_C()
                     34: 
                     35: typedef struct _zend_function_entry {
                     36:        const char *fname;
                     37:        void (*handler)(INTERNAL_FUNCTION_PARAMETERS);
                     38:        const struct _zend_arg_info *arg_info;
                     39:        zend_uint num_args;
                     40:        zend_uint flags;
                     41: } zend_function_entry;
                     42: 
                     43: typedef struct _zend_fcall_info {
                     44:        size_t size;
                     45:        HashTable *function_table;
                     46:        zval *function_name;
                     47:        HashTable *symbol_table;
                     48:        zval **retval_ptr_ptr;
                     49:        zend_uint param_count;
                     50:        zval ***params;
                     51:        zval *object_ptr;
                     52:        zend_bool no_separation;
                     53: } zend_fcall_info;
                     54: 
                     55: typedef struct _zend_fcall_info_cache {
                     56:        zend_bool initialized;
                     57:        zend_function *function_handler;
                     58:        zend_class_entry *calling_scope;
                     59:        zend_class_entry *called_scope;
                     60:        zval *object_ptr;
                     61: } zend_fcall_info_cache;
                     62: 
1.1.1.3   misho      63: #define ZEND_NS_NAME(ns, name)                 ns "\\" name
1.1       misho      64: 
                     65: #define ZEND_FN(name) zif_##name
                     66: #define ZEND_MN(name) zim_##name
                     67: #define ZEND_NAMED_FUNCTION(name)              void name(INTERNAL_FUNCTION_PARAMETERS)
                     68: #define ZEND_FUNCTION(name)                            ZEND_NAMED_FUNCTION(ZEND_FN(name))
                     69: #define ZEND_METHOD(classname, name)   ZEND_NAMED_FUNCTION(ZEND_MN(classname##_##name))
                     70: 
                     71: #define ZEND_FENTRY(zend_name, name, arg_info, flags)  { #zend_name, name, arg_info, (zend_uint) (sizeof(arg_info)/sizeof(struct _zend_arg_info)-1), flags },
                     72: 
                     73: #define ZEND_RAW_FENTRY(zend_name, name, arg_info, flags)   { zend_name, name, arg_info, (zend_uint) (sizeof(arg_info)/sizeof(struct _zend_arg_info)-1), flags },
                     74: #define ZEND_RAW_NAMED_FE(zend_name, name, arg_info) ZEND_RAW_FENTRY(#zend_name, name, arg_info, 0)
                     75: 
                     76: #define ZEND_NAMED_FE(zend_name, name, arg_info)       ZEND_FENTRY(zend_name, name, arg_info, 0)
                     77: #define ZEND_FE(name, arg_info)                                                ZEND_FENTRY(name, ZEND_FN(name), arg_info, 0)
                     78: #define ZEND_DEP_FE(name, arg_info)                 ZEND_FENTRY(name, ZEND_FN(name), arg_info, ZEND_ACC_DEPRECATED)
                     79: #define ZEND_FALIAS(name, alias, arg_info)                     ZEND_FENTRY(name, ZEND_FN(alias), arg_info, 0)
                     80: #define ZEND_DEP_FALIAS(name, alias, arg_info)         ZEND_FENTRY(name, ZEND_FN(alias), arg_info, ZEND_ACC_DEPRECATED)
                     81: #define ZEND_NAMED_ME(zend_name, name, arg_info, flags)        ZEND_FENTRY(zend_name, name, arg_info, flags)
                     82: #define ZEND_ME(classname, name, arg_info, flags)      ZEND_FENTRY(name, ZEND_MN(classname##_##name), arg_info, flags)
                     83: #define ZEND_ABSTRACT_ME(classname, name, arg_info)    ZEND_FENTRY(name, NULL, arg_info, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
                     84: #define ZEND_MALIAS(classname, name, alias, arg_info, flags) \
                     85:                                                     ZEND_FENTRY(name, ZEND_MN(classname##_##alias), arg_info, flags)
                     86: #define ZEND_ME_MAPPING(name, func_name, arg_types, flags) ZEND_NAMED_ME(name, ZEND_FN(func_name), arg_types, flags)
                     87: 
                     88: #define ZEND_NS_FENTRY(ns, zend_name, name, arg_info, flags)           ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, #zend_name), name, arg_info, flags)
                     89: 
                     90: #define ZEND_NS_RAW_FENTRY(ns, zend_name, name, arg_info, flags)       ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, zend_name), name, arg_info, flags)
                     91: #define ZEND_NS_RAW_NAMED_FE(ns, zend_name, name, arg_info)                    ZEND_NS_RAW_FENTRY(ns, #zend_name, name, arg_info, 0)
                     92: 
1.1.1.3   misho      93: #define ZEND_NS_NAMED_FE(ns, zend_name, name, arg_info)        ZEND_NS_FENTRY(ns, zend_name, name, arg_info, 0)
1.1       misho      94: #define ZEND_NS_FE(ns, name, arg_info)                                 ZEND_NS_FENTRY(ns, name, ZEND_FN(name), arg_info, 0)
                     95: #define ZEND_NS_DEP_FE(ns, name, arg_info)                             ZEND_NS_FENTRY(ns, name, ZEND_FN(name), arg_info, ZEND_ACC_DEPRECATED)
                     96: #define ZEND_NS_FALIAS(ns, name, alias, arg_info)              ZEND_NS_FENTRY(ns, name, ZEND_FN(alias), arg_info, 0)
                     97: #define ZEND_NS_DEP_FALIAS(ns, name, alias, arg_info)  ZEND_NS_FENTRY(ns, name, ZEND_FN(alias), arg_info, ZEND_ACC_DEPRECATED)
                     98: 
                     99: #define ZEND_FE_END            { NULL, NULL, NULL, 0, 0 }
                    100: 
1.1.1.2   misho     101: #define ZEND_ARG_INFO(pass_by_ref, name)                                                       { #name, sizeof(#name)-1, NULL, 0, 0, 0, pass_by_ref},
                    102: #define ZEND_ARG_PASS_INFO(pass_by_ref)                                                                { NULL, 0, NULL, 0, 0, 0, pass_by_ref},
                    103: #define ZEND_ARG_OBJ_INFO(pass_by_ref, name, classname, allow_null) { #name, sizeof(#name)-1, #classname, sizeof(#classname)-1, IS_OBJECT, allow_null, pass_by_ref},
                    104: #define ZEND_ARG_ARRAY_INFO(pass_by_ref, name, allow_null) { #name, sizeof(#name)-1, NULL, 0, IS_ARRAY, allow_null, pass_by_ref},
                    105: #define ZEND_ARG_TYPE_INFO(pass_by_ref, name, type_hint, allow_null) { #name, sizeof(#name)-1, NULL, 0, type_hint, allow_null, pass_by_ref},
1.1       misho     106: #define ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, return_reference, required_num_args)      \
                    107:        static const zend_arg_info name[] = {                                                                                                                                           \
1.1.1.2   misho     108:                { NULL, 0, NULL, required_num_args, 0, return_reference, pass_rest_by_reference},
1.1       misho     109: #define ZEND_BEGIN_ARG_INFO(name, pass_rest_by_reference)      \
                    110:        ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, ZEND_RETURN_VALUE, -1)
                    111: #define ZEND_END_ARG_INFO()            };
                    112: 
                    113: /* Name macros */
                    114: #define ZEND_MODULE_STARTUP_N(module)       zm_startup_##module
                    115: #define ZEND_MODULE_SHUTDOWN_N(module)         zm_shutdown_##module
                    116: #define ZEND_MODULE_ACTIVATE_N(module)         zm_activate_##module
                    117: #define ZEND_MODULE_DEACTIVATE_N(module)       zm_deactivate_##module
                    118: #define ZEND_MODULE_POST_ZEND_DEACTIVATE_N(module)     zm_post_zend_deactivate_##module
                    119: #define ZEND_MODULE_INFO_N(module)                     zm_info_##module
                    120: #define ZEND_MODULE_GLOBALS_CTOR_N(module)  zm_globals_ctor_##module
                    121: #define ZEND_MODULE_GLOBALS_DTOR_N(module)  zm_globals_dtor_##module
                    122: 
                    123: /* Declaration macros */
                    124: #define ZEND_MODULE_STARTUP_D(module)          int ZEND_MODULE_STARTUP_N(module)(INIT_FUNC_ARGS)
                    125: #define ZEND_MODULE_SHUTDOWN_D(module)         int ZEND_MODULE_SHUTDOWN_N(module)(SHUTDOWN_FUNC_ARGS)
                    126: #define ZEND_MODULE_ACTIVATE_D(module)         int ZEND_MODULE_ACTIVATE_N(module)(INIT_FUNC_ARGS)
                    127: #define ZEND_MODULE_DEACTIVATE_D(module)       int ZEND_MODULE_DEACTIVATE_N(module)(SHUTDOWN_FUNC_ARGS)
                    128: #define ZEND_MODULE_POST_ZEND_DEACTIVATE_D(module)     int ZEND_MODULE_POST_ZEND_DEACTIVATE_N(module)(void)
                    129: #define ZEND_MODULE_INFO_D(module)                     void ZEND_MODULE_INFO_N(module)(ZEND_MODULE_INFO_FUNC_ARGS)
                    130: #define ZEND_MODULE_GLOBALS_CTOR_D(module)  void ZEND_MODULE_GLOBALS_CTOR_N(module)(zend_##module##_globals *module##_globals TSRMLS_DC)
                    131: #define ZEND_MODULE_GLOBALS_DTOR_D(module)  void ZEND_MODULE_GLOBALS_DTOR_N(module)(zend_##module##_globals *module##_globals TSRMLS_DC)
                    132: 
                    133: #define ZEND_GET_MODULE(name) \
                    134:     BEGIN_EXTERN_C()\
                    135:        ZEND_DLEXPORT zend_module_entry *get_module(void) { return &name##_module_entry; }\
                    136:     END_EXTERN_C()
                    137: 
                    138: #define ZEND_BEGIN_MODULE_GLOBALS(module_name)         \
                    139:        typedef struct _zend_##module_name##_globals {
                    140: #define ZEND_END_MODULE_GLOBALS(module_name)           \
                    141:        } zend_##module_name##_globals;
                    142: 
                    143: #ifdef ZTS
                    144: 
                    145: #define ZEND_DECLARE_MODULE_GLOBALS(module_name)                                                       \
                    146:        ts_rsrc_id module_name##_globals_id;
                    147: #define ZEND_EXTERN_MODULE_GLOBALS(module_name)                                                                \
                    148:        extern ts_rsrc_id module_name##_globals_id;
                    149: #define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)      \
                    150:        ts_allocate_id(&module_name##_globals_id, sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);
                    151: 
                    152: #else
                    153: 
                    154: #define ZEND_DECLARE_MODULE_GLOBALS(module_name)                                                       \
                    155:        zend_##module_name##_globals module_name##_globals;
                    156: #define ZEND_EXTERN_MODULE_GLOBALS(module_name)                                                                \
                    157:        extern zend_##module_name##_globals module_name##_globals;
                    158: #define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)      \
                    159:        globals_ctor(&module_name##_globals);
                    160: 
                    161: #endif
                    162: 
                    163: #define INIT_CLASS_ENTRY(class_container, class_name, functions) \
                    164:        INIT_OVERLOADED_CLASS_ENTRY(class_container, class_name, functions, NULL, NULL, NULL)
                    165: 
                    166: #define INIT_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions) \
                    167:        INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions, NULL, NULL, NULL, NULL, NULL)
                    168: 
                    169: #define INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
                    170:        {                                                                                                                       \
1.1.1.2   misho     171:                const char *cl_name = class_name;                                                               \
1.1       misho     172:                int _len = class_name_len;                                                              \
1.1.1.2   misho     173:                class_container.name = zend_new_interned_string(cl_name, _len+1, 0 TSRMLS_CC);  \
                    174:                if (class_container.name == cl_name) {                                  \
                    175:                        class_container.name = zend_strndup(cl_name, _len);     \
                    176:                }                                                                                                               \
1.1       misho     177:                class_container.name_length = _len;                                             \
1.1.1.3   misho     178:                INIT_CLASS_ENTRY_INIT_METHODS(class_container, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
                    179:        }
                    180: 
                    181: #define INIT_CLASS_ENTRY_INIT_METHODS(class_container, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
                    182:        {                                                                                                                       \
1.1       misho     183:                class_container.constructor = NULL;                                             \
                    184:                class_container.destructor = NULL;                                              \
                    185:                class_container.clone = NULL;                                                   \
                    186:                class_container.serialize = NULL;                                               \
                    187:                class_container.unserialize = NULL;                                             \
                    188:                class_container.create_object = NULL;                                   \
                    189:                class_container.interface_gets_implemented = NULL;              \
                    190:                class_container.get_static_method = NULL;                               \
                    191:                class_container.__call = handle_fcall;                                  \
                    192:                class_container.__callstatic = NULL;                                    \
                    193:                class_container.__tostring = NULL;                                              \
                    194:                class_container.__get = handle_propget;                                 \
                    195:                class_container.__set = handle_propset;                                 \
                    196:                class_container.__unset = handle_propunset;                             \
                    197:                class_container.__isset = handle_propisset;                             \
                    198:                class_container.serialize_func = NULL;                                  \
                    199:                class_container.unserialize_func = NULL;                                \
                    200:                class_container.serialize = NULL;                                               \
                    201:                class_container.unserialize = NULL;                                             \
                    202:                class_container.parent = NULL;                                                  \
                    203:                class_container.num_interfaces = 0;                                             \
1.1.1.2   misho     204:                class_container.traits = NULL;                                                  \
                    205:                class_container.num_traits = 0;                                                 \
                    206:                class_container.trait_aliases = NULL;                                   \
                    207:                class_container.trait_precedences = NULL;                               \
1.1       misho     208:                class_container.interfaces = NULL;                                              \
                    209:                class_container.get_iterator = NULL;                                    \
                    210:                class_container.iterator_funcs.funcs = NULL;                    \
1.1.1.2   misho     211:                class_container.info.internal.module = NULL;                    \
                    212:                class_container.info.internal.builtin_functions = functions;    \
1.1       misho     213:        }
                    214: 
                    215: #define INIT_OVERLOADED_CLASS_ENTRY(class_container, class_name, functions, handle_fcall, handle_propget, handle_propset) \
                    216:        INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, class_name, sizeof(class_name)-1, functions, handle_fcall, handle_propget, handle_propset, NULL, NULL)
                    217: 
                    218: #define INIT_NS_CLASS_ENTRY(class_container, ns, class_name, functions) \
                    219:        INIT_CLASS_ENTRY(class_container, ZEND_NS_NAME(ns, class_name), functions)
                    220: #define INIT_OVERLOADED_NS_CLASS_ENTRY_EX(class_container, ns, class_name, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
                    221:        INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, ZEND_NS_NAME(ns, class_name), sizeof(ZEND_NS_NAME(ns, class_name))-1, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset)
                    222: #define INIT_OVERLOADED_NS_CLASS_ENTRY(class_container, ns, class_name, functions, handle_fcall, handle_propget, handle_propset) \
                    223:        INIT_OVERLOADED_CLASS_ENTRY(class_container, ZEND_NS_NAME(ns, class_name), functions, handle_fcall, handle_propget, handle_propset)
                    224: 
                    225: #ifdef ZTS
1.1.1.2   misho     226: #      define CE_STATIC_MEMBERS(ce) (((ce)->type==ZEND_USER_CLASS)?(ce)->static_members_table:CG(static_members_table)[(zend_intptr_t)(ce)->static_members_table])
1.1       misho     227: #else
1.1.1.2   misho     228: #      define CE_STATIC_MEMBERS(ce) ((ce)->static_members_table)
1.1       misho     229: #endif
                    230: 
                    231: #define ZEND_FCI_INITIALIZED(fci) ((fci).size != 0)
                    232: 
                    233: int zend_next_free_module(void);
                    234: 
                    235: BEGIN_EXTERN_C()
                    236: ZEND_API int zend_get_parameters(int ht, int param_count, ...);
                    237: ZEND_API int _zend_get_parameters_array(int ht, int param_count, zval **argument_array TSRMLS_DC);
                    238: ZEND_API ZEND_ATTRIBUTE_DEPRECATED int zend_get_parameters_ex(int param_count, ...);
                    239: ZEND_API int _zend_get_parameters_array_ex(int param_count, zval ***argument_array TSRMLS_DC);
                    240: 
                    241: /* internal function to efficiently copy parameters when executing __call() */
                    242: ZEND_API int zend_copy_parameters_array(int param_count, zval *argument_array TSRMLS_DC);
                    243: 
                    244: #define zend_get_parameters_array(ht, param_count, argument_array)                     \
                    245:        _zend_get_parameters_array(ht, param_count, argument_array TSRMLS_CC)
                    246: #define zend_get_parameters_array_ex(param_count, argument_array)                      \
                    247:        _zend_get_parameters_array_ex(param_count, argument_array TSRMLS_CC)
                    248: #define zend_parse_parameters_none()                                                                           \
                    249:        zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "")
                    250: 
                    251: /* Parameter parsing API -- andrei */
                    252: 
                    253: #define ZEND_PARSE_PARAMS_QUIET 1<<1
1.1.1.2   misho     254: ZEND_API int zend_parse_parameters(int num_args TSRMLS_DC, const char *type_spec, ...);
                    255: ZEND_API int zend_parse_parameters_ex(int flags, int num_args TSRMLS_DC, const char *type_spec, ...);
1.1       misho     256: ZEND_API char *zend_zval_type_name(const zval *arg);
                    257: 
1.1.1.2   misho     258: ZEND_API int zend_parse_method_parameters(int num_args TSRMLS_DC, zval *this_ptr, const char *type_spec, ...);
                    259: ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC, zval *this_ptr, const char *type_spec, ...);
1.1       misho     260: 
                    261: /* End of parameter parsing API -- andrei */
                    262: 
                    263: ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_function_entry *functions, HashTable *function_table, int type TSRMLS_DC);
                    264: ZEND_API void zend_unregister_functions(const zend_function_entry *functions, int count, HashTable *function_table TSRMLS_DC);
                    265: ZEND_API int zend_startup_module(zend_module_entry *module_entry);
                    266: ZEND_API zend_module_entry* zend_register_internal_module(zend_module_entry *module_entry TSRMLS_DC);
                    267: ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module TSRMLS_DC);
                    268: ZEND_API int zend_startup_module_ex(zend_module_entry *module TSRMLS_DC);
                    269: ZEND_API int zend_startup_modules(TSRMLS_D);
1.1.1.2   misho     270: ZEND_API void zend_collect_module_handlers(TSRMLS_D);
                    271: ZEND_API void zend_destroy_modules(void);
1.1       misho     272: ZEND_API void zend_check_magic_method_implementation(const zend_class_entry *ce, const zend_function *fptr, int error_type TSRMLS_DC);
                    273: 
                    274: ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry TSRMLS_DC);
                    275: ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name TSRMLS_DC);
                    276: ZEND_API zend_class_entry *zend_register_internal_interface(zend_class_entry *orig_class_entry TSRMLS_DC);
                    277: ZEND_API void zend_class_implements(zend_class_entry *class_entry TSRMLS_DC, int num_interfaces, ...);
                    278: 
                    279: ZEND_API int zend_register_class_alias_ex(const char *name, int name_len, zend_class_entry *ce TSRMLS_DC);
                    280: 
                    281: #define zend_register_class_alias(name, ce) \
1.1.1.3   misho     282:        zend_register_class_alias_ex(name, sizeof(name)-1, ce TSRMLS_CC)
1.1       misho     283: #define zend_register_ns_class_alias(ns, name, ce) \
1.1.1.3   misho     284:        zend_register_class_alias_ex(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name))-1, ce TSRMLS_CC)
1.1       misho     285: 
                    286: ZEND_API int zend_disable_function(char *function_name, uint function_name_length TSRMLS_DC);
                    287: ZEND_API int zend_disable_class(char *class_name, uint class_name_length TSRMLS_DC);
                    288: 
                    289: ZEND_API void zend_wrong_param_count(TSRMLS_D);
                    290: 
                    291: #define IS_CALLABLE_CHECK_SYNTAX_ONLY (1<<0)
                    292: #define IS_CALLABLE_CHECK_NO_ACCESS   (1<<1)
                    293: #define IS_CALLABLE_CHECK_IS_STATIC   (1<<2)
                    294: #define IS_CALLABLE_CHECK_SILENT      (1<<3)
                    295: 
                    296: #define IS_CALLABLE_STRICT  (IS_CALLABLE_CHECK_IS_STATIC)
                    297: 
                    298: ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint check_flags, char **callable_name, int *callable_name_len, zend_fcall_info_cache *fcc, char **error TSRMLS_DC);
                    299: ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, char **callable_name TSRMLS_DC);
                    300: ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRMLS_DC);
                    301: ZEND_API const char *zend_get_module_version(const char *module_name);
                    302: ZEND_API int zend_get_module_started(const char *module_name);
1.1.1.2   misho     303: ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type TSRMLS_DC);
                    304: ZEND_API int zend_declare_property_ex(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type, const char *doc_comment, int doc_comment_len TSRMLS_DC);
                    305: ZEND_API int zend_declare_property_null(zend_class_entry *ce, const char *name, int name_length, int access_type TSRMLS_DC);
                    306: ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC);
                    307: ZEND_API int zend_declare_property_long(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC);
                    308: ZEND_API int zend_declare_property_double(zend_class_entry *ce, const char *name, int name_length, double value, int access_type TSRMLS_DC);
                    309: ZEND_API int zend_declare_property_string(zend_class_entry *ce, const char *name, int name_length, const char *value, int access_type TSRMLS_DC);
                    310: ZEND_API int zend_declare_property_stringl(zend_class_entry *ce, const char *name, int name_length, const char *value, int value_len, int access_type TSRMLS_DC);
1.1       misho     311: 
                    312: ZEND_API int zend_declare_class_constant(zend_class_entry *ce, const char *name, size_t name_length, zval *value TSRMLS_DC);
                    313: ZEND_API int zend_declare_class_constant_null(zend_class_entry *ce, const char *name, size_t name_length TSRMLS_DC);
                    314: ZEND_API int zend_declare_class_constant_long(zend_class_entry *ce, const char *name, size_t name_length, long value TSRMLS_DC);
                    315: ZEND_API int zend_declare_class_constant_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_bool value TSRMLS_DC);
                    316: ZEND_API int zend_declare_class_constant_double(zend_class_entry *ce, const char *name, size_t name_length, double value TSRMLS_DC);
                    317: ZEND_API int zend_declare_class_constant_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_length TSRMLS_DC);
                    318: ZEND_API int zend_declare_class_constant_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value TSRMLS_DC);
                    319: 
                    320: ZEND_API void zend_update_class_constants(zend_class_entry *class_type TSRMLS_DC);
1.1.1.2   misho     321: ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const char *name, int name_length, zval *value TSRMLS_DC);
                    322: ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, const char *name, int name_length TSRMLS_DC);
                    323: ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC);
                    324: ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC);
                    325: ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object, const char *name, int name_length, double value TSRMLS_DC);
                    326: ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, const char *name, int name_length, const char *value TSRMLS_DC);
                    327: ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object, const char *name, int name_length, const char *value, int value_length TSRMLS_DC);
                    328: 
                    329: ZEND_API int zend_update_static_property(zend_class_entry *scope, const char *name, int name_length, zval *value TSRMLS_DC);
                    330: ZEND_API int zend_update_static_property_null(zend_class_entry *scope, const char *name, int name_length TSRMLS_DC);
                    331: ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC);
                    332: ZEND_API int zend_update_static_property_long(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC);
                    333: ZEND_API int zend_update_static_property_double(zend_class_entry *scope, const char *name, int name_length, double value TSRMLS_DC);
                    334: ZEND_API int zend_update_static_property_string(zend_class_entry *scope, const char *name, int name_length, const char *value TSRMLS_DC);
                    335: ZEND_API int zend_update_static_property_stringl(zend_class_entry *scope, const char *name, int name_length, const char *value, int value_length TSRMLS_DC);
1.1       misho     336: 
1.1.1.2   misho     337: ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const char *name, int name_length, zend_bool silent TSRMLS_DC);
1.1       misho     338: 
1.1.1.2   misho     339: ZEND_API zval *zend_read_static_property(zend_class_entry *scope, const char *name, int name_length, zend_bool silent TSRMLS_DC);
1.1       misho     340: 
                    341: ZEND_API zend_class_entry *zend_get_class_entry(const zval *zobject TSRMLS_DC);
1.1.1.2   misho     342: ZEND_API int zend_get_object_classname(const zval *object, const char **class_name, zend_uint *class_name_len TSRMLS_DC);
1.1       misho     343: ZEND_API char *zend_get_type_by_const(int type);
                    344: 
                    345: #define getThis() (this_ptr)
                    346: 
                    347: #define WRONG_PARAM_COUNT                                      ZEND_WRONG_PARAM_COUNT()
                    348: #define WRONG_PARAM_COUNT_WITH_RETVAL(ret)     ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)
                    349: #define ARG_COUNT(dummy)       (ht)
                    350: #define ZEND_NUM_ARGS()                (ht)
                    351: #define ZEND_WRONG_PARAM_COUNT()                                       { zend_wrong_param_count(TSRMLS_C); return; }
                    352: #define ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)                { zend_wrong_param_count(TSRMLS_C); return ret; }
                    353: 
                    354: #ifndef ZEND_WIN32
                    355: #define DLEXPORT
                    356: #endif
                    357: 
                    358: #define array_init(arg)                        _array_init((arg), 0 ZEND_FILE_LINE_CC)
                    359: #define array_init_size(arg, size) _array_init((arg), (size) ZEND_FILE_LINE_CC)
                    360: #define object_init(arg)               _object_init((arg) ZEND_FILE_LINE_CC TSRMLS_CC)
                    361: #define object_init_ex(arg, ce)        _object_init_ex((arg), (ce) ZEND_FILE_LINE_CC TSRMLS_CC)
                    362: #define object_and_properties_init(arg, ce, properties)        _object_and_properties_init((arg), (ce), (properties) ZEND_FILE_LINE_CC TSRMLS_CC)
                    363: ZEND_API int _array_init(zval *arg, uint size ZEND_FILE_LINE_DC);
                    364: ZEND_API int _object_init(zval *arg ZEND_FILE_LINE_DC TSRMLS_DC);
                    365: ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC TSRMLS_DC);
                    366: ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties ZEND_FILE_LINE_DC TSRMLS_DC);
1.1.1.2   misho     367: ZEND_API void object_properties_init(zend_object *object, zend_class_entry *class_type);
1.1       misho     368: 
                    369: ZEND_API void zend_merge_properties(zval *obj, HashTable *properties, int destroy_ht TSRMLS_DC);
                    370: 
                    371: /* no longer supported */
                    372: ZEND_API int add_assoc_function(zval *arg, const char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS));
                    373: 
                    374: ZEND_API int add_assoc_long_ex(zval *arg, const char *key, uint key_len, long n);
                    375: ZEND_API int add_assoc_null_ex(zval *arg, const char *key, uint key_len);
                    376: ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, uint key_len, int b);
                    377: ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, int r);
                    378: ZEND_API int add_assoc_double_ex(zval *arg, const char *key, uint key_len, double d);
                    379: ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate);
                    380: ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length, int duplicate);
                    381: ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value);
                    382: 
                    383: #define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key)+1, __n)
                    384: #define add_assoc_null(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1)
                    385: #define add_assoc_bool(__arg, __key, __b) add_assoc_bool_ex(__arg, __key, strlen(__key)+1, __b)
                    386: #define add_assoc_resource(__arg, __key, __r) add_assoc_resource_ex(__arg, __key, strlen(__key)+1, __r)
                    387: #define add_assoc_double(__arg, __key, __d) add_assoc_double_ex(__arg, __key, strlen(__key)+1, __d)
                    388: #define add_assoc_string(__arg, __key, __str, __duplicate) add_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate)
                    389: #define add_assoc_stringl(__arg, __key, __str, __length, __duplicate) add_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate)
                    390: #define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key)+1, __value)
                    391: 
                    392: /* unset() functions are only suported for legacy modules and null() functions should be used */
                    393: #define add_assoc_unset(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1)
                    394: #define add_index_unset(__arg, __key) add_index_null(__arg, __key)
                    395: #define add_next_index_unset(__arg) add_next_index_null(__arg)
                    396: #define add_property_unset(__arg, __key) add_property_null(__arg, __key)
                    397: 
                    398: ZEND_API int add_index_long(zval *arg, ulong idx, long n);
                    399: ZEND_API int add_index_null(zval *arg, ulong idx);
                    400: ZEND_API int add_index_bool(zval *arg, ulong idx, int b);
                    401: ZEND_API int add_index_resource(zval *arg, ulong idx, int r);
                    402: ZEND_API int add_index_double(zval *arg, ulong idx, double d);
                    403: ZEND_API int add_index_string(zval *arg, ulong idx, const char *str, int duplicate);
                    404: ZEND_API int add_index_stringl(zval *arg, ulong idx, const char *str, uint length, int duplicate);
                    405: ZEND_API int add_index_zval(zval *arg, ulong index, zval *value);
                    406: 
                    407: ZEND_API int add_next_index_long(zval *arg, long n);
                    408: ZEND_API int add_next_index_null(zval *arg);
                    409: ZEND_API int add_next_index_bool(zval *arg, int b);
                    410: ZEND_API int add_next_index_resource(zval *arg, int r);
                    411: ZEND_API int add_next_index_double(zval *arg, double d);
                    412: ZEND_API int add_next_index_string(zval *arg, const char *str, int duplicate);
                    413: ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length, int duplicate);
                    414: ZEND_API int add_next_index_zval(zval *arg, zval *value);
                    415: 
                    416: ZEND_API int add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, void **dest, int duplicate);
                    417: ZEND_API int add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, void **dest, int duplicate);
                    418: 
                    419: #define add_get_assoc_string(__arg, __key, __str, __dest, __duplicate) add_get_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __dest, __duplicate)
                    420: #define add_get_assoc_stringl(__arg, __key, __str, __length, __dest, __duplicate) add_get_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __dest, __duplicate)
                    421: 
                    422: ZEND_API int add_get_index_long(zval *arg, ulong idx, long l, void **dest);
                    423: ZEND_API int add_get_index_double(zval *arg, ulong idx, double d, void **dest);
                    424: ZEND_API int add_get_index_string(zval *arg, ulong idx, const char *str, void **dest, int duplicate);
                    425: ZEND_API int add_get_index_stringl(zval *arg, ulong idx, const char *str, uint length, void **dest, int duplicate);
                    426: 
                    427: ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long l TSRMLS_DC);
                    428: ZEND_API int add_property_null_ex(zval *arg, const char *key, uint key_len TSRMLS_DC);
                    429: ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC);
                    430: ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, long r TSRMLS_DC);
                    431: ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC);
1.1.1.2   misho     432: ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate TSRMLS_DC);
                    433: ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len,  const char *str, uint length, int duplicate TSRMLS_DC);
1.1       misho     434: ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC);
                    435: 
                    436: #define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key)+1, __n TSRMLS_CC)
                    437: #define add_property_null(__arg, __key) add_property_null_ex(__arg, __key, strlen(__key) + 1 TSRMLS_CC)
                    438: #define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key)+1, __b TSRMLS_CC)
                    439: #define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key)+1, __r TSRMLS_CC)
                    440: #define add_property_double(__arg, __key, __d) add_property_double_ex(__arg, __key, strlen(__key)+1, __d TSRMLS_CC)
                    441: #define add_property_string(__arg, __key, __str, __duplicate) add_property_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate TSRMLS_CC)
                    442: #define add_property_stringl(__arg, __key, __str, __length, __duplicate) add_property_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate TSRMLS_CC)
                    443: #define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key)+1, __value TSRMLS_CC)       
                    444: 
                    445: 
                    446: ZEND_API int call_user_function(HashTable *function_table, zval **object_pp, zval *function_name, zval *retval_ptr, zend_uint param_count, zval *params[] TSRMLS_DC);
                    447: ZEND_API int call_user_function_ex(HashTable *function_table, zval **object_pp, zval *function_name, zval **retval_ptr_ptr, zend_uint param_count, zval **params[], int no_separation, HashTable *symbol_table TSRMLS_DC);
                    448: 
                    449: ZEND_API extern const zend_fcall_info empty_fcall_info;
                    450: ZEND_API extern const zend_fcall_info_cache empty_fcall_info_cache;
                    451: 
                    452: /** Build zend_call_info/cache from a zval*
                    453:  *
                    454:  * Caller is responsible to provide a return value, otherwise the we will crash. 
                    455:  * fci->retval_ptr_ptr = NULL;
                    456:  * In order to pass parameters the following members need to be set:
                    457:  * fci->param_count = 0;
                    458:  * fci->params = NULL;
                    459:  * The callable_name argument may be NULL.
                    460:  * Set check_flags to IS_CALLABLE_STRICT for every new usage!
                    461:  */
                    462: ZEND_API int zend_fcall_info_init(zval *callable, uint check_flags, zend_fcall_info *fci, zend_fcall_info_cache *fcc, char **callable_name, char **error TSRMLS_DC);
                    463: 
1.1.1.3   misho     464: /** Clear arguments connected with zend_fcall_info *fci
1.1       misho     465:  * If free_mem is not zero then the params array gets free'd as well
                    466:  */
                    467: ZEND_API void zend_fcall_info_args_clear(zend_fcall_info *fci, int free_mem);
                    468: 
                    469: /** Save current arguments from zend_fcall_info *fci
                    470:  * params array will be set to NULL
                    471:  */
                    472: ZEND_API void zend_fcall_info_args_save(zend_fcall_info *fci, int *param_count, zval ****params);
                    473: 
                    474: /** Free arguments connected with zend_fcall_info *fci andset back saved ones.
                    475:  */
                    476: ZEND_API void zend_fcall_info_args_restore(zend_fcall_info *fci, int param_count, zval ***params);
                    477: 
                    478: /** Set or clear the arguments in the zend_call_info struct taking care of
                    479:  * refcount. If args is NULL and arguments are set then those are cleared.
                    480:  */
                    481: ZEND_API int zend_fcall_info_args(zend_fcall_info *fci, zval *args TSRMLS_DC);
                    482: 
                    483: /** Set arguments in the zend_fcall_info struct taking care of refcount.
                    484:  * If argc is 0 the arguments which are set will be cleared, else pass
                    485:  * a variable amount of zval** arguments.
                    486:  */
                    487: ZEND_API int zend_fcall_info_argp(zend_fcall_info *fci TSRMLS_DC, int argc, zval ***argv);
                    488: 
                    489: /** Set arguments in the zend_fcall_info struct taking care of refcount.
                    490:  * If argc is 0 the arguments which are set will be cleared, else pass
                    491:  * a variable amount of zval** arguments.
                    492:  */
                    493: ZEND_API int zend_fcall_info_argv(zend_fcall_info *fci TSRMLS_DC, int argc, va_list *argv);
                    494: 
                    495: /** Set arguments in the zend_fcall_info struct taking care of refcount.
                    496:  * If argc is 0 the arguments which are set will be cleared, else pass
                    497:  * a variable amount of zval** arguments.
                    498:  */
                    499: ZEND_API int zend_fcall_info_argn(zend_fcall_info *fci TSRMLS_DC, int argc, ...);
                    500: 
                    501: /** Call a function using information created by zend_fcall_info_init()/args().
1.1.1.3   misho     502:  * If args is given then those replace the argument info in fci is temporarily.
1.1       misho     503:  */
                    504: ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *fcc, zval **retval, zval *args TSRMLS_DC);
                    505: 
                    506: ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TSRMLS_DC);
                    507: 
                    508: ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, int name_length, zend_bool is_ref, int num_symbol_tables, ...);
                    509: 
1.1.1.2   misho     510: ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, int name_len, ulong hash_value TSRMLS_DC);
                    511: 
                    512: ZEND_API int zend_delete_global_variable(const char *name, int name_len TSRMLS_DC);
                    513: 
                    514: ZEND_API int zend_delete_global_variable_ex(const char *name, int name_len, ulong hash_value TSRMLS_DC);
1.1       misho     515: 
                    516: ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC);
                    517: 
                    518: ZEND_API void zend_rebuild_symbol_table(TSRMLS_D);
                    519: 
1.1.1.3   misho     520: ZEND_API const char* zend_find_alias_name(zend_class_entry *ce, const char *name, zend_uint len);
                    521: ZEND_API const char* zend_resolve_method_name(zend_class_entry *ce, zend_function *f);
                    522: 
1.1       misho     523: #define add_method(arg, key, method)   add_assoc_function((arg), (key), (method))
                    524: 
                    525: ZEND_API ZEND_FUNCTION(display_disabled_function);
                    526: ZEND_API ZEND_FUNCTION(display_disabled_class);
                    527: END_EXTERN_C()
                    528: 
                    529: #if ZEND_DEBUG
                    530: #define CHECK_ZVAL_STRING(z) \
                    531:        if (Z_STRVAL_P(z)[ Z_STRLEN_P(z) ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", Z_STRVAL_P(z)); }
                    532: #define CHECK_ZVAL_STRING_REL(z) \
                    533:        if (Z_STRVAL_P(z)[ Z_STRLEN_P(z) ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s) (source: %s:%d)", Z_STRVAL_P(z) ZEND_FILE_LINE_RELAY_CC); }
                    534: #else
                    535: #define CHECK_ZVAL_STRING(z)
                    536: #define CHECK_ZVAL_STRING_REL(z)
                    537: #endif
                    538: 
1.1.1.2   misho     539: #define CHECK_ZVAL_NULL_PATH(p) (Z_STRLEN_P(p) != strlen(Z_STRVAL_P(p)))
                    540: #define CHECK_NULL_PATH(p, l) (strlen(p) != l)
1.1       misho     541: 
1.1.1.2   misho     542: #define ZVAL_RESOURCE(z, l) do {       \
                    543:                zval *__z = (z);                        \
                    544:                Z_LVAL_P(__z) = l;                      \
                    545:                Z_TYPE_P(__z) = IS_RESOURCE;\
                    546:        } while (0)
                    547: 
                    548: #define ZVAL_BOOL(z, b) do {           \
                    549:                zval *__z = (z);                        \
                    550:                Z_LVAL_P(__z) = ((b) != 0);     \
                    551:                Z_TYPE_P(__z) = IS_BOOL;        \
                    552:        } while (0)
1.1       misho     553: 
                    554: #define ZVAL_NULL(z) {                         \
                    555:                Z_TYPE_P(z) = IS_NULL;          \
                    556:        }
                    557: 
                    558: #define ZVAL_LONG(z, l) {                      \
1.1.1.2   misho     559:                zval *__z = (z);                        \
                    560:                Z_LVAL_P(__z) = l;                      \
                    561:                Z_TYPE_P(__z) = IS_LONG;        \
1.1       misho     562:        }
                    563: 
                    564: #define ZVAL_DOUBLE(z, d) {                    \
1.1.1.2   misho     565:                zval *__z = (z);                        \
                    566:                Z_DVAL_P(__z) = d;                      \
                    567:                Z_TYPE_P(__z) = IS_DOUBLE;      \
                    568:        }
                    569: 
                    570: #define ZVAL_STRING(z, s, duplicate) do {      \
                    571:                const char *__s=(s);                            \
                    572:                zval *__z = (z);                                        \
                    573:                Z_STRLEN_P(__z) = strlen(__s);          \
                    574:                Z_STRVAL_P(__z) = (duplicate?estrndup(__s, Z_STRLEN_P(__z)):(char*)__s);\
                    575:                Z_TYPE_P(__z) = IS_STRING;                      \
                    576:        } while (0)
                    577: 
                    578: #define ZVAL_STRINGL(z, s, l, duplicate) do {  \
                    579:                const char *__s=(s); int __l=l;                 \
                    580:                zval *__z = (z);                                                \
                    581:                Z_STRLEN_P(__z) = __l;                                  \
                    582:                Z_STRVAL_P(__z) = (duplicate?estrndup(__s, __l):(char*)__s);\
                    583:                Z_TYPE_P(__z) = IS_STRING;                              \
                    584:        } while (0)
                    585: 
                    586: #define ZVAL_EMPTY_STRING(z) do {      \
                    587:                zval *__z = (z);                        \
                    588:                Z_STRLEN_P(__z) = 0;            \
                    589:                Z_STRVAL_P(__z) = STR_EMPTY_ALLOC();\
                    590:                Z_TYPE_P(__z) = IS_STRING;      \
                    591:        } while (0)
1.1       misho     592: 
                    593: #define ZVAL_ZVAL(z, zv, copy, dtor) {                 \
                    594:                zend_uchar is_ref = Z_ISREF_P(z);               \
                    595:                zend_uint refcount = Z_REFCOUNT_P(z);   \
1.1.1.2   misho     596:                ZVAL_COPY_VALUE(z, zv);                                 \
1.1       misho     597:                if (copy) {                                                             \
                    598:                        zval_copy_ctor(z);                                      \
                    599:            }                                                                           \
                    600:                if (dtor) {                                                             \
                    601:                        if (!copy) {                                            \
                    602:                                ZVAL_NULL(zv);                                  \
                    603:                        }                                                                       \
                    604:                        zval_ptr_dtor(&zv);                                     \
                    605:            }                                                                           \
                    606:                Z_SET_ISREF_TO_P(z, is_ref);                    \
                    607:                Z_SET_REFCOUNT_P(z, refcount);                  \
                    608:        }
                    609: 
                    610: #define ZVAL_FALSE(z)                                          ZVAL_BOOL(z, 0)
                    611: #define ZVAL_TRUE(z)                                   ZVAL_BOOL(z, 1)
                    612: 
                    613: #define RETVAL_RESOURCE(l)                             ZVAL_RESOURCE(return_value, l)
                    614: #define RETVAL_BOOL(b)                                 ZVAL_BOOL(return_value, b)
                    615: #define RETVAL_NULL()                                  ZVAL_NULL(return_value)
                    616: #define RETVAL_LONG(l)                                         ZVAL_LONG(return_value, l)
                    617: #define RETVAL_DOUBLE(d)                               ZVAL_DOUBLE(return_value, d)
                    618: #define RETVAL_STRING(s, duplicate)            ZVAL_STRING(return_value, s, duplicate)
                    619: #define RETVAL_STRINGL(s, l, duplicate)        ZVAL_STRINGL(return_value, s, l, duplicate)
                    620: #define RETVAL_EMPTY_STRING()                  ZVAL_EMPTY_STRING(return_value)
                    621: #define RETVAL_ZVAL(zv, copy, dtor)            ZVAL_ZVAL(return_value, zv, copy, dtor)
                    622: #define RETVAL_FALSE                                   ZVAL_BOOL(return_value, 0)
                    623: #define RETVAL_TRUE                                    ZVAL_BOOL(return_value, 1)
                    624: 
                    625: #define RETURN_RESOURCE(l)                             { RETVAL_RESOURCE(l); return; }
                    626: #define RETURN_BOOL(b)                                         { RETVAL_BOOL(b); return; }
                    627: #define RETURN_NULL()                                  { RETVAL_NULL(); return;}
                    628: #define RETURN_LONG(l)                                         { RETVAL_LONG(l); return; }
                    629: #define RETURN_DOUBLE(d)                               { RETVAL_DOUBLE(d); return; }
                    630: #define RETURN_STRING(s, duplicate)    { RETVAL_STRING(s, duplicate); return; }
                    631: #define RETURN_STRINGL(s, l, duplicate) { RETVAL_STRINGL(s, l, duplicate); return; }
                    632: #define RETURN_EMPTY_STRING()                  { RETVAL_EMPTY_STRING(); return; }
                    633: #define RETURN_ZVAL(zv, copy, dtor)            { RETVAL_ZVAL(zv, copy, dtor); return; }
                    634: #define RETURN_FALSE                                   { RETVAL_FALSE; return; }
                    635: #define RETURN_TRUE                                    { RETVAL_TRUE; return; }
                    636: 
                    637: #define SET_VAR_STRING(n, v) {                                                                                                                                                         \
                    638:                                                                {                                                                                                                                                       \
                    639:                                                                        zval *var;                                                                                                                              \
                    640:                                                                        ALLOC_ZVAL(var);                                                                                                                \
                    641:                                                                        ZVAL_STRING(var, v, 0);                                                                                                 \
                    642:                                                                        ZEND_SET_GLOBAL_VAR(n, var);                                                                                    \
                    643:                                                                }                                                                                                                                                       \
                    644:                                                        }
                    645: 
                    646: #define SET_VAR_STRINGL(n, v, l) {                                                                                                             \
                    647:                                                                        {                                                                                                       \
                    648:                                                                                zval *var;                                                                              \
                    649:                                                                                ALLOC_ZVAL(var);                                                                \
                    650:                                                                                ZVAL_STRINGL(var, v, l, 0);                                             \
                    651:                                                                                ZEND_SET_GLOBAL_VAR(n, var);                                    \
                    652:                                                                        }                                                                                                       \
                    653:                                                                }
                    654: 
                    655: #define SET_VAR_LONG(n, v)     {                                                                                                                       \
                    656:                                                                {                                                                                                               \
                    657:                                                                        zval *var;                                                                                      \
                    658:                                                                        ALLOC_ZVAL(var);                                                                        \
                    659:                                                                        ZVAL_LONG(var, v);                                                                      \
                    660:                                                                        ZEND_SET_GLOBAL_VAR(n, var);                                            \
                    661:                                                                }                                                                                                               \
                    662:                                                        }
                    663: 
                    664: #define SET_VAR_DOUBLE(n, v) {                                                                                                                 \
                    665:                                                                {                                                                                                               \
                    666:                                                                        zval *var;                                                                                      \
                    667:                                                                        ALLOC_ZVAL(var);                                                                        \
                    668:                                                                        ZVAL_DOUBLE(var, v);                                                            \
                    669:                                                                        ZEND_SET_GLOBAL_VAR(n, var);                                            \
                    670:                                                                }                                                                                                               \
                    671:                                                        }
                    672: 
                    673: 
                    674: #define ZEND_SET_SYMBOL(symtable, name, var)                                                                           \
                    675:        {                                                                                                                                                               \
                    676:                char *_name = (name);                                                                                                           \
                    677:                                                                                                                                                                        \
                    678:                ZEND_SET_SYMBOL_WITH_LENGTH(symtable, _name, strlen(_name)+1, var, 1, 0);       \
                    679:        }
                    680: 
                    681: #define ZEND_SET_SYMBOL_WITH_LENGTH(symtable, name, name_length, var, _refcount, _is_ref)                              \
                    682:        {                                                                                                                                                                                                       \
                    683:                zval **orig_var;                                                                                                                                                                \
                    684:                                                                                                                                                                                                                \
                    685:                if (zend_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS                               \
                    686:                        && PZVAL_IS_REF(*orig_var)) {                                                                                                                           \
                    687:                        Z_SET_REFCOUNT_P(var, Z_REFCOUNT_PP(orig_var));                                                                                         \
                    688:                        Z_SET_ISREF_P(var);                                                                                                                                                     \
                    689:                                                                                                                                                                                                                \
                    690:                        if (_refcount) {                                                                                                                                                        \
                    691:                                Z_SET_REFCOUNT_P(var, Z_REFCOUNT_P(var) + _refcount - 1);                                                               \
                    692:                        }                                                                                                                                                                                       \
                    693:                        zval_dtor(*orig_var);                                                                                                                                           \
                    694:                        **orig_var = *(var);                                                                                                                                            \
                    695:                        FREE_ZVAL(var);                                                                                                                                                         \
                    696:                } else {                                                                                                                                                                                \
                    697:                        Z_SET_ISREF_TO_P(var, _is_ref);                                                                                                                         \
                    698:                        if (_refcount) {                                                                                                                                                        \
                    699:                                Z_SET_REFCOUNT_P(var, _refcount);                                                                                                               \
                    700:                        }                                                                                                                                                                                       \
                    701:                        zend_hash_update(symtable, (name), (name_length), &(var), sizeof(zval *), NULL);                        \
                    702:                }                                                                                                                                                                                               \
                    703:        }
                    704: 
                    705: 
                    706: #define ZEND_SET_GLOBAL_VAR(name, var)                         \
                    707:        ZEND_SET_SYMBOL(&EG(symbol_table), name, var)
                    708: 
                    709: #define ZEND_SET_GLOBAL_VAR_WITH_LENGTH(name, name_length, var, _refcount, _is_ref)    \
                    710:        ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), name, name_length, var, _refcount, _is_ref)
                    711: 
                    712: #define ZEND_DEFINE_PROPERTY(class_ptr, name, value, mask)                                                     \
                    713: {                                                                                                                                                                      \
                    714:        char *_name = (name);                                                                                                                   \
                    715:        int namelen = strlen(_name);                                                                                                    \
                    716:        zend_declare_property(class_ptr, _name, namelen, value, mask TSRMLS_CC);                \
                    717: }
                    718: 
                    719: #define HASH_OF(p) (Z_TYPE_P(p)==IS_ARRAY ? Z_ARRVAL_P(p) : ((Z_TYPE_P(p)==IS_OBJECT ? Z_OBJ_HT_P(p)->get_properties((p) TSRMLS_CC) : NULL)))
                    720: #define ZVAL_IS_NULL(z) (Z_TYPE_P(z)==IS_NULL)
                    721: 
                    722: /* For compatibility */
                    723: #define ZEND_MINIT                     ZEND_MODULE_STARTUP_N
                    724: #define ZEND_MSHUTDOWN         ZEND_MODULE_SHUTDOWN_N
                    725: #define ZEND_RINIT                     ZEND_MODULE_ACTIVATE_N
                    726: #define ZEND_RSHUTDOWN         ZEND_MODULE_DEACTIVATE_N
                    727: #define ZEND_MINFO                     ZEND_MODULE_INFO_N
                    728: #define ZEND_GINIT(module)             ((void (*)(void* TSRMLS_DC))(ZEND_MODULE_GLOBALS_CTOR_N(module)))
                    729: #define ZEND_GSHUTDOWN(module) ((void (*)(void* TSRMLS_DC))(ZEND_MODULE_GLOBALS_DTOR_N(module)))
                    730: 
                    731: #define ZEND_MINIT_FUNCTION                    ZEND_MODULE_STARTUP_D
                    732: #define ZEND_MSHUTDOWN_FUNCTION                ZEND_MODULE_SHUTDOWN_D
                    733: #define ZEND_RINIT_FUNCTION                    ZEND_MODULE_ACTIVATE_D
                    734: #define ZEND_RSHUTDOWN_FUNCTION                ZEND_MODULE_DEACTIVATE_D
                    735: #define ZEND_MINFO_FUNCTION                    ZEND_MODULE_INFO_D
                    736: #define ZEND_GINIT_FUNCTION                    ZEND_MODULE_GLOBALS_CTOR_D
                    737: #define ZEND_GSHUTDOWN_FUNCTION                ZEND_MODULE_GLOBALS_DTOR_D
                    738: 
                    739: END_EXTERN_C()
                    740: 
                    741: #endif /* ZEND_API_H */
                    742: 
                    743: 
                    744: /*
                    745:  * Local variables:
                    746:  * tab-width: 4
                    747:  * c-basic-offset: 4
                    748:  * indent-tabs-mode: t
                    749:  * End:
                    750:  */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>