Back to index

php5  5.3.10
zend_API.h
Go to the documentation of this file.
00001 /*
00002    +----------------------------------------------------------------------+
00003    | Zend Engine                                                          |
00004    +----------------------------------------------------------------------+
00005    | Copyright (c) 1998-2012 Zend Technologies Ltd. (http://www.zend.com) |
00006    +----------------------------------------------------------------------+
00007    | This source file is subject to version 2.00 of the Zend license,     |
00008    | that is bundled with this package in the file LICENSE, and is        |
00009    | available through the world-wide-web at the following url:           |
00010    | http://www.zend.com/license/2_00.txt.                                |
00011    | If you did not receive a copy of the Zend license and are unable to  |
00012    | obtain it through the world-wide-web, please send a note to          |
00013    | license@zend.com so we can mail you a copy immediately.              |
00014    +----------------------------------------------------------------------+
00015    | Authors: Andi Gutmans <andi@zend.com>                                |
00016    |          Zeev Suraski <zeev@zend.com>                                |
00017    |          Andrei Zmievski <andrei@php.net>                            |
00018    +----------------------------------------------------------------------+
00019 */
00020 
00021 /* $Id: zend_API.h 321634 2012-01-01 13:15:04Z felipe $ */
00022 
00023 #ifndef ZEND_API_H
00024 #define ZEND_API_H
00025 
00026 #include "zend_modules.h"
00027 #include "zend_list.h"
00028 #include "zend_operators.h"
00029 #include "zend_variables.h"
00030 #include "zend_execute.h"
00031 
00032 
00033 BEGIN_EXTERN_C()
00034 
00035 typedef struct _zend_function_entry {
00036        const char *fname;
00037        void (*handler)(INTERNAL_FUNCTION_PARAMETERS);
00038        const struct _zend_arg_info *arg_info;
00039        zend_uint num_args;
00040        zend_uint flags;
00041 } zend_function_entry;
00042 
00043 typedef struct _zend_fcall_info {
00044        size_t size;
00045        HashTable *function_table;
00046        zval *function_name;
00047        HashTable *symbol_table;
00048        zval **retval_ptr_ptr;
00049        zend_uint param_count;
00050        zval ***params;
00051        zval *object_ptr;
00052        zend_bool no_separation;
00053 } zend_fcall_info;
00054 
00055 typedef struct _zend_fcall_info_cache {
00056        zend_bool initialized;
00057        zend_function *function_handler;
00058        zend_class_entry *calling_scope;
00059        zend_class_entry *called_scope;
00060        zval *object_ptr;
00061 } zend_fcall_info_cache;
00062 
00063 #define ZEND_NS_NAME(ns, name)                   ns"\\"name
00064 
00065 #define ZEND_FN(name) zif_##name
00066 #define ZEND_MN(name) zim_##name
00067 #define ZEND_NAMED_FUNCTION(name)         void name(INTERNAL_FUNCTION_PARAMETERS)
00068 #define ZEND_FUNCTION(name)                      ZEND_NAMED_FUNCTION(ZEND_FN(name))
00069 #define ZEND_METHOD(classname, name)      ZEND_NAMED_FUNCTION(ZEND_MN(classname##_##name))
00070 
00071 #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 },
00072 
00073 #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 },
00074 #define ZEND_RAW_NAMED_FE(zend_name, name, arg_info) ZEND_RAW_FENTRY(#zend_name, name, arg_info, 0)
00075 
00076 #define ZEND_NAMED_FE(zend_name, name, arg_info) ZEND_FENTRY(zend_name, name, arg_info, 0)
00077 #define ZEND_FE(name, arg_info)                                       ZEND_FENTRY(name, ZEND_FN(name), arg_info, 0)
00078 #define ZEND_DEP_FE(name, arg_info)                 ZEND_FENTRY(name, ZEND_FN(name), arg_info, ZEND_ACC_DEPRECATED)
00079 #define ZEND_FALIAS(name, alias, arg_info)                     ZEND_FENTRY(name, ZEND_FN(alias), arg_info, 0)
00080 #define ZEND_DEP_FALIAS(name, alias, arg_info)          ZEND_FENTRY(name, ZEND_FN(alias), arg_info, ZEND_ACC_DEPRECATED)
00081 #define ZEND_NAMED_ME(zend_name, name, arg_info, flags) ZEND_FENTRY(zend_name, name, arg_info, flags)
00082 #define ZEND_ME(classname, name, arg_info, flags)       ZEND_FENTRY(name, ZEND_MN(classname##_##name), arg_info, flags)
00083 #define ZEND_ABSTRACT_ME(classname, name, arg_info)     ZEND_FENTRY(name, NULL, arg_info, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT)
00084 #define ZEND_MALIAS(classname, name, alias, arg_info, flags) \
00085                                                     ZEND_FENTRY(name, ZEND_MN(classname##_##alias), arg_info, flags)
00086 #define ZEND_ME_MAPPING(name, func_name, arg_types, flags) ZEND_NAMED_ME(name, ZEND_FN(func_name), arg_types, flags)
00087 
00088 #define ZEND_NS_FENTRY(ns, zend_name, name, arg_info, flags)          ZEND_RAW_FENTRY(ZEND_NS_NAME(ns, #zend_name), name, arg_info, flags)
00089 
00090 #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)
00091 #define ZEND_NS_RAW_NAMED_FE(ns, zend_name, name, arg_info)                  ZEND_NS_RAW_FENTRY(ns, #zend_name, name, arg_info, 0)
00092 
00093 #define ZEND_NS_NAMED_FE(ns, zend_name, name, arg_info) ZEND_NS_FENTRY(ns, #zend_name, name, arg_info, 0)
00094 #define ZEND_NS_FE(ns, name, arg_info)                                ZEND_NS_FENTRY(ns, name, ZEND_FN(name), arg_info, 0)
00095 #define ZEND_NS_DEP_FE(ns, name, arg_info)                            ZEND_NS_FENTRY(ns, name, ZEND_FN(name), arg_info, ZEND_ACC_DEPRECATED)
00096 #define ZEND_NS_FALIAS(ns, name, alias, arg_info)              ZEND_NS_FENTRY(ns, name, ZEND_FN(alias), arg_info, 0)
00097 #define ZEND_NS_DEP_FALIAS(ns, name, alias, arg_info)   ZEND_NS_FENTRY(ns, name, ZEND_FN(alias), arg_info, ZEND_ACC_DEPRECATED)
00098 
00099 #define ZEND_FE_END            { NULL, NULL, NULL, 0, 0 }
00100 
00101 #define ZEND_ARG_INFO(pass_by_ref, name)                                            { #name, sizeof(#name)-1, NULL, 0, 0, 0, pass_by_ref, 0, 0 },
00102 #define ZEND_ARG_PASS_INFO(pass_by_ref)                                                    { NULL, 0, NULL, 0, 0, 0, pass_by_ref, 0, 0 },
00103 #define ZEND_ARG_OBJ_INFO(pass_by_ref, name, classname, allow_null) { #name, sizeof(#name)-1, #classname, sizeof(#classname)-1, 0, allow_null, pass_by_ref, 0, 0 },
00104 #define ZEND_ARG_ARRAY_INFO(pass_by_ref, name, allow_null) { #name, sizeof(#name)-1, NULL, 0, 1, allow_null, pass_by_ref, 0, 0 },
00105 #define ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, return_reference, required_num_args) \
00106        static const zend_arg_info name[] = {                                                                                                                            \
00107               { NULL, 0, NULL, 0, 0, 0, pass_rest_by_reference, return_reference, required_num_args },
00108 #define ZEND_BEGIN_ARG_INFO(name, pass_rest_by_reference)      \
00109        ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, ZEND_RETURN_VALUE, -1)
00110 #define ZEND_END_ARG_INFO()        };
00111 
00112 /* Name macros */
00113 #define ZEND_MODULE_STARTUP_N(module)       zm_startup_##module
00114 #define ZEND_MODULE_SHUTDOWN_N(module)           zm_shutdown_##module
00115 #define ZEND_MODULE_ACTIVATE_N(module)           zm_activate_##module
00116 #define ZEND_MODULE_DEACTIVATE_N(module)  zm_deactivate_##module
00117 #define ZEND_MODULE_POST_ZEND_DEACTIVATE_N(module)      zm_post_zend_deactivate_##module
00118 #define ZEND_MODULE_INFO_N(module)               zm_info_##module
00119 #define ZEND_MODULE_GLOBALS_CTOR_N(module)  zm_globals_ctor_##module
00120 #define ZEND_MODULE_GLOBALS_DTOR_N(module)  zm_globals_dtor_##module
00121 
00122 /* Declaration macros */
00123 #define ZEND_MODULE_STARTUP_D(module)            int ZEND_MODULE_STARTUP_N(module)(INIT_FUNC_ARGS)
00124 #define ZEND_MODULE_SHUTDOWN_D(module)           int ZEND_MODULE_SHUTDOWN_N(module)(SHUTDOWN_FUNC_ARGS)
00125 #define ZEND_MODULE_ACTIVATE_D(module)           int ZEND_MODULE_ACTIVATE_N(module)(INIT_FUNC_ARGS)
00126 #define ZEND_MODULE_DEACTIVATE_D(module)  int ZEND_MODULE_DEACTIVATE_N(module)(SHUTDOWN_FUNC_ARGS)
00127 #define ZEND_MODULE_POST_ZEND_DEACTIVATE_D(module)      int ZEND_MODULE_POST_ZEND_DEACTIVATE_N(module)(void)
00128 #define ZEND_MODULE_INFO_D(module)               void ZEND_MODULE_INFO_N(module)(ZEND_MODULE_INFO_FUNC_ARGS)
00129 #define ZEND_MODULE_GLOBALS_CTOR_D(module)  void ZEND_MODULE_GLOBALS_CTOR_N(module)(zend_##module##_globals *module##_globals TSRMLS_DC)
00130 #define ZEND_MODULE_GLOBALS_DTOR_D(module)  void ZEND_MODULE_GLOBALS_DTOR_N(module)(zend_##module##_globals *module##_globals TSRMLS_DC)
00131 
00132 #define ZEND_GET_MODULE(name) \
00133     BEGIN_EXTERN_C()\
00134        ZEND_DLEXPORT zend_module_entry *get_module(void) { return &name##_module_entry; }\
00135     END_EXTERN_C()
00136 
00137 #define ZEND_BEGIN_MODULE_GLOBALS(module_name)          \
00138        typedef struct _zend_##module_name##_globals {
00139 #define ZEND_END_MODULE_GLOBALS(module_name)            \
00140        } zend_##module_name##_globals;
00141 
00142 #ifdef ZTS
00143 
00144 #define ZEND_DECLARE_MODULE_GLOBALS(module_name)                                           \
00145        ts_rsrc_id module_name##_globals_id;
00146 #define ZEND_EXTERN_MODULE_GLOBALS(module_name)                                                   \
00147        extern ts_rsrc_id module_name##_globals_id;
00148 #define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)    \
00149        ts_allocate_id(&module_name##_globals_id, sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);
00150 
00151 #else
00152 
00153 #define ZEND_DECLARE_MODULE_GLOBALS(module_name)                                           \
00154        zend_##module_name##_globals module_name##_globals;
00155 #define ZEND_EXTERN_MODULE_GLOBALS(module_name)                                                   \
00156        extern zend_##module_name##_globals module_name##_globals;
00157 #define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)    \
00158        globals_ctor(&module_name##_globals);
00159 
00160 #endif
00161 
00162 #define INIT_CLASS_ENTRY(class_container, class_name, functions) \
00163        INIT_OVERLOADED_CLASS_ENTRY(class_container, class_name, functions, NULL, NULL, NULL)
00164 
00165 #define INIT_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions) \
00166        INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions, NULL, NULL, NULL, NULL, NULL)
00167 
00168 #define INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
00169        {                                                                                                        \
00170               int _len = class_name_len;                                                   \
00171               class_container.name = zend_strndup(class_name, _len);  \
00172               class_container.name_length = _len;                                          \
00173               class_container.builtin_functions = functions;                 \
00174               class_container.constructor = NULL;                                          \
00175               class_container.destructor = NULL;                                    \
00176               class_container.clone = NULL;                                                \
00177               class_container.serialize = NULL;                                     \
00178               class_container.unserialize = NULL;                                          \
00179               class_container.create_object = NULL;                                 \
00180               class_container.interface_gets_implemented = NULL;             \
00181               class_container.get_static_method = NULL;                      \
00182               class_container.__call = handle_fcall;                                \
00183               class_container.__callstatic = NULL;                                  \
00184               class_container.__tostring = NULL;                                    \
00185               class_container.__get = handle_propget;                               \
00186               class_container.__set = handle_propset;                               \
00187               class_container.__unset = handle_propunset;                           \
00188               class_container.__isset = handle_propisset;                           \
00189               class_container.serialize_func = NULL;                                \
00190               class_container.unserialize_func = NULL;                       \
00191               class_container.serialize = NULL;                                     \
00192               class_container.unserialize = NULL;                                          \
00193               class_container.parent = NULL;                                               \
00194               class_container.num_interfaces = 0;                                          \
00195               class_container.interfaces = NULL;                                    \
00196               class_container.get_iterator = NULL;                                  \
00197               class_container.iterator_funcs.funcs = NULL;                   \
00198               class_container.module = NULL;                                               \
00199        }
00200 
00201 #define INIT_OVERLOADED_CLASS_ENTRY(class_container, class_name, functions, handle_fcall, handle_propget, handle_propset) \
00202        INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, class_name, sizeof(class_name)-1, functions, handle_fcall, handle_propget, handle_propset, NULL, NULL)
00203 
00204 #define INIT_NS_CLASS_ENTRY(class_container, ns, class_name, functions) \
00205        INIT_CLASS_ENTRY(class_container, ZEND_NS_NAME(ns, class_name), functions)
00206 #define INIT_OVERLOADED_NS_CLASS_ENTRY_EX(class_container, ns, class_name, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
00207        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)
00208 #define INIT_OVERLOADED_NS_CLASS_ENTRY(class_container, ns, class_name, functions, handle_fcall, handle_propget, handle_propset) \
00209        INIT_OVERLOADED_CLASS_ENTRY(class_container, ZEND_NS_NAME(ns, class_name), functions, handle_fcall, handle_propget, handle_propset)
00210 
00211 #ifdef ZTS
00212 #      define CE_STATIC_MEMBERS(ce) (((ce)->type==ZEND_USER_CLASS)?(ce)->static_members:CG(static_members)[(zend_intptr_t)(ce)->static_members])
00213 #else
00214 #      define CE_STATIC_MEMBERS(ce) ((ce)->static_members)
00215 #endif
00216 
00217 #define ZEND_FCI_INITIALIZED(fci) ((fci).size != 0)
00218 
00219 int zend_next_free_module(void);
00220 
00221 BEGIN_EXTERN_C()
00222 ZEND_API int zend_get_parameters(int ht, int param_count, ...);
00223 ZEND_API int _zend_get_parameters_array(int ht, int param_count, zval **argument_array TSRMLS_DC);
00224 ZEND_API ZEND_ATTRIBUTE_DEPRECATED int zend_get_parameters_ex(int param_count, ...);
00225 ZEND_API int _zend_get_parameters_array_ex(int param_count, zval ***argument_array TSRMLS_DC);
00226 
00227 /* internal function to efficiently copy parameters when executing __call() */
00228 ZEND_API int zend_copy_parameters_array(int param_count, zval *argument_array TSRMLS_DC);
00229 
00230 #define zend_get_parameters_array(ht, param_count, argument_array)                  \
00231        _zend_get_parameters_array(ht, param_count, argument_array TSRMLS_CC)
00232 #define zend_get_parameters_array_ex(param_count, argument_array)                   \
00233        _zend_get_parameters_array_ex(param_count, argument_array TSRMLS_CC)
00234 #define zend_parse_parameters_none()                                                                     \
00235        zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "")
00236 
00237 /* Parameter parsing API -- andrei */
00238 
00239 #define ZEND_PARSE_PARAMS_QUIET 1<<1
00240 ZEND_API int zend_parse_parameters(int num_args TSRMLS_DC, char *type_spec, ...);
00241 ZEND_API int zend_parse_parameters_ex(int flags, int num_args TSRMLS_DC, char *type_spec, ...);
00242 ZEND_API char *zend_zval_type_name(const zval *arg);
00243 
00244 ZEND_API int zend_parse_method_parameters(int num_args TSRMLS_DC, zval *this_ptr, char *type_spec, ...);
00245 ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC, zval *this_ptr, char *type_spec, ...);
00246 
00247 /* End of parameter parsing API -- andrei */
00248 
00249 ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_function_entry *functions, HashTable *function_table, int type TSRMLS_DC);
00250 ZEND_API void zend_unregister_functions(const zend_function_entry *functions, int count, HashTable *function_table TSRMLS_DC);
00251 ZEND_API int zend_startup_module(zend_module_entry *module_entry);
00252 ZEND_API zend_module_entry* zend_register_internal_module(zend_module_entry *module_entry TSRMLS_DC);
00253 ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module TSRMLS_DC);
00254 ZEND_API int zend_startup_module_ex(zend_module_entry *module TSRMLS_DC);
00255 ZEND_API int zend_startup_modules(TSRMLS_D);
00256 ZEND_API void zend_check_magic_method_implementation(const zend_class_entry *ce, const zend_function *fptr, int error_type TSRMLS_DC);
00257 
00258 ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry TSRMLS_DC);
00259 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);
00260 ZEND_API zend_class_entry *zend_register_internal_interface(zend_class_entry *orig_class_entry TSRMLS_DC);
00261 ZEND_API void zend_class_implements(zend_class_entry *class_entry TSRMLS_DC, int num_interfaces, ...);
00262 
00263 ZEND_API int zend_register_class_alias_ex(const char *name, int name_len, zend_class_entry *ce TSRMLS_DC);
00264 
00265 #define zend_register_class_alias(name, ce) \
00266        zend_register_class_alias_ex(name, sizeof(name)-1, ce TSRMLS_DC)
00267 #define zend_register_ns_class_alias(ns, name, ce) \
00268        zend_register_class_alias_ex(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name))-1, ce TSRMLS_DC)
00269 
00270 ZEND_API int zend_disable_function(char *function_name, uint function_name_length TSRMLS_DC);
00271 ZEND_API int zend_disable_class(char *class_name, uint class_name_length TSRMLS_DC);
00272 
00273 ZEND_API void zend_wrong_param_count(TSRMLS_D);
00274 
00275 #define IS_CALLABLE_CHECK_SYNTAX_ONLY (1<<0)
00276 #define IS_CALLABLE_CHECK_NO_ACCESS   (1<<1)
00277 #define IS_CALLABLE_CHECK_IS_STATIC   (1<<2)
00278 #define IS_CALLABLE_CHECK_SILENT      (1<<3)
00279 
00280 #define IS_CALLABLE_STRICT  (IS_CALLABLE_CHECK_IS_STATIC)
00281 
00282 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);
00283 ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, char **callable_name TSRMLS_DC);
00284 ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRMLS_DC);
00285 ZEND_API const char *zend_get_module_version(const char *module_name);
00286 ZEND_API int zend_get_module_started(const char *module_name);
00287 ZEND_API int zend_declare_property(zend_class_entry *ce, char *name, int name_length, zval *property, int access_type TSRMLS_DC);
00288 ZEND_API int zend_declare_property_ex(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type, char *doc_comment, int doc_comment_len TSRMLS_DC);
00289 ZEND_API int zend_declare_property_null(zend_class_entry *ce, char *name, int name_length, int access_type TSRMLS_DC);
00290 ZEND_API int zend_declare_property_bool(zend_class_entry *ce, char *name, int name_length, long value, int access_type TSRMLS_DC);
00291 ZEND_API int zend_declare_property_long(zend_class_entry *ce, char *name, int name_length, long value, int access_type TSRMLS_DC);
00292 ZEND_API int zend_declare_property_double(zend_class_entry *ce, char *name, int name_length, double value, int access_type TSRMLS_DC);
00293 ZEND_API int zend_declare_property_string(zend_class_entry *ce, char *name, int name_length, char *value, int access_type TSRMLS_DC);
00294 ZEND_API int zend_declare_property_stringl(zend_class_entry *ce, char *name, int name_length, char *value, int value_len, int access_type TSRMLS_DC);
00295 
00296 ZEND_API int zend_declare_class_constant(zend_class_entry *ce, const char *name, size_t name_length, zval *value TSRMLS_DC);
00297 ZEND_API int zend_declare_class_constant_null(zend_class_entry *ce, const char *name, size_t name_length TSRMLS_DC);
00298 ZEND_API int zend_declare_class_constant_long(zend_class_entry *ce, const char *name, size_t name_length, long value TSRMLS_DC);
00299 ZEND_API int zend_declare_class_constant_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_bool value TSRMLS_DC);
00300 ZEND_API int zend_declare_class_constant_double(zend_class_entry *ce, const char *name, size_t name_length, double value TSRMLS_DC);
00301 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);
00302 ZEND_API int zend_declare_class_constant_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value TSRMLS_DC);
00303 
00304 ZEND_API void zend_update_class_constants(zend_class_entry *class_type TSRMLS_DC);
00305 ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, char *name, int name_length, zval *value TSRMLS_DC);
00306 ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, char *name, int name_length TSRMLS_DC);
00307 ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, char *name, int name_length, long value TSRMLS_DC);
00308 ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, char *name, int name_length, long value TSRMLS_DC);
00309 ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object, char *name, int name_length, double value TSRMLS_DC);
00310 ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, char *name, int name_length, const char *value TSRMLS_DC);
00311 ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object, char *name, int name_length, const char *value, int value_length TSRMLS_DC);
00312 
00313 ZEND_API int zend_update_static_property(zend_class_entry *scope, char *name, int name_length, zval *value TSRMLS_DC);
00314 ZEND_API int zend_update_static_property_null(zend_class_entry *scope, char *name, int name_length TSRMLS_DC);
00315 ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, char *name, int name_length, long value TSRMLS_DC);
00316 ZEND_API int zend_update_static_property_long(zend_class_entry *scope, char *name, int name_length, long value TSRMLS_DC);
00317 ZEND_API int zend_update_static_property_double(zend_class_entry *scope, char *name, int name_length, double value TSRMLS_DC);
00318 ZEND_API int zend_update_static_property_string(zend_class_entry *scope, char *name, int name_length, const char *value TSRMLS_DC);
00319 ZEND_API int zend_update_static_property_stringl(zend_class_entry *scope, char *name, int name_length, const char *value, int value_length TSRMLS_DC);
00320 
00321 ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, char *name, int name_length, zend_bool silent TSRMLS_DC);
00322 
00323 ZEND_API zval *zend_read_static_property(zend_class_entry *scope, char *name, int name_length, zend_bool silent TSRMLS_DC);
00324 
00325 ZEND_API zend_class_entry *zend_get_class_entry(const zval *zobject TSRMLS_DC);
00326 ZEND_API int zend_get_object_classname(const zval *object, char **class_name, zend_uint *class_name_len TSRMLS_DC);
00327 ZEND_API char *zend_get_type_by_const(int type);
00328 
00329 #define getThis() (this_ptr)
00330 
00331 #define WRONG_PARAM_COUNT                               ZEND_WRONG_PARAM_COUNT()
00332 #define WRONG_PARAM_COUNT_WITH_RETVAL(ret)       ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)
00333 #define ARG_COUNT(dummy)    (ht)
00334 #define ZEND_NUM_ARGS()            (ht)
00335 #define ZEND_WRONG_PARAM_COUNT()                               { zend_wrong_param_count(TSRMLS_C); return; }
00336 #define ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)         { zend_wrong_param_count(TSRMLS_C); return ret; }
00337 
00338 #ifndef ZEND_WIN32
00339 #define DLEXPORT
00340 #endif
00341 
00342 #define array_init(arg)                   _array_init((arg), 0 ZEND_FILE_LINE_CC)
00343 #define array_init_size(arg, size) _array_init((arg), (size) ZEND_FILE_LINE_CC)
00344 #define object_init(arg)           _object_init((arg) ZEND_FILE_LINE_CC TSRMLS_CC)
00345 #define object_init_ex(arg, ce)    _object_init_ex((arg), (ce) ZEND_FILE_LINE_CC TSRMLS_CC)
00346 #define object_and_properties_init(arg, ce, properties) _object_and_properties_init((arg), (ce), (properties) ZEND_FILE_LINE_CC TSRMLS_CC)
00347 ZEND_API int _array_init(zval *arg, uint size ZEND_FILE_LINE_DC);
00348 ZEND_API int _object_init(zval *arg ZEND_FILE_LINE_DC TSRMLS_DC);
00349 ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC TSRMLS_DC);
00350 ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties ZEND_FILE_LINE_DC TSRMLS_DC);
00351 
00352 ZEND_API void zend_merge_properties(zval *obj, HashTable *properties, int destroy_ht TSRMLS_DC);
00353 
00354 /* no longer supported */
00355 ZEND_API int add_assoc_function(zval *arg, const char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS));
00356 
00357 ZEND_API int add_assoc_long_ex(zval *arg, const char *key, uint key_len, long n);
00358 ZEND_API int add_assoc_null_ex(zval *arg, const char *key, uint key_len);
00359 ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, uint key_len, int b);
00360 ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, int r);
00361 ZEND_API int add_assoc_double_ex(zval *arg, const char *key, uint key_len, double d);
00362 ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate);
00363 ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length, int duplicate);
00364 ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value);
00365 
00366 #define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key)+1, __n)
00367 #define add_assoc_null(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1)
00368 #define add_assoc_bool(__arg, __key, __b) add_assoc_bool_ex(__arg, __key, strlen(__key)+1, __b)
00369 #define add_assoc_resource(__arg, __key, __r) add_assoc_resource_ex(__arg, __key, strlen(__key)+1, __r)
00370 #define add_assoc_double(__arg, __key, __d) add_assoc_double_ex(__arg, __key, strlen(__key)+1, __d)
00371 #define add_assoc_string(__arg, __key, __str, __duplicate) add_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate)
00372 #define add_assoc_stringl(__arg, __key, __str, __length, __duplicate) add_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate)
00373 #define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key)+1, __value)
00374 
00375 /* unset() functions are only suported for legacy modules and null() functions should be used */
00376 #define add_assoc_unset(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1)
00377 #define add_index_unset(__arg, __key) add_index_null(__arg, __key)
00378 #define add_next_index_unset(__arg) add_next_index_null(__arg)
00379 #define add_property_unset(__arg, __key) add_property_null(__arg, __key)
00380 
00381 ZEND_API int add_index_long(zval *arg, ulong idx, long n);
00382 ZEND_API int add_index_null(zval *arg, ulong idx);
00383 ZEND_API int add_index_bool(zval *arg, ulong idx, int b);
00384 ZEND_API int add_index_resource(zval *arg, ulong idx, int r);
00385 ZEND_API int add_index_double(zval *arg, ulong idx, double d);
00386 ZEND_API int add_index_string(zval *arg, ulong idx, const char *str, int duplicate);
00387 ZEND_API int add_index_stringl(zval *arg, ulong idx, const char *str, uint length, int duplicate);
00388 ZEND_API int add_index_zval(zval *arg, ulong index, zval *value);
00389 
00390 ZEND_API int add_next_index_long(zval *arg, long n);
00391 ZEND_API int add_next_index_null(zval *arg);
00392 ZEND_API int add_next_index_bool(zval *arg, int b);
00393 ZEND_API int add_next_index_resource(zval *arg, int r);
00394 ZEND_API int add_next_index_double(zval *arg, double d);
00395 ZEND_API int add_next_index_string(zval *arg, const char *str, int duplicate);
00396 ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length, int duplicate);
00397 ZEND_API int add_next_index_zval(zval *arg, zval *value);
00398 
00399 ZEND_API int add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, void **dest, int duplicate);
00400 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);
00401 
00402 #define add_get_assoc_string(__arg, __key, __str, __dest, __duplicate) add_get_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __dest, __duplicate)
00403 #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)
00404 
00405 ZEND_API int add_get_index_long(zval *arg, ulong idx, long l, void **dest);
00406 ZEND_API int add_get_index_double(zval *arg, ulong idx, double d, void **dest);
00407 ZEND_API int add_get_index_string(zval *arg, ulong idx, const char *str, void **dest, int duplicate);
00408 ZEND_API int add_get_index_stringl(zval *arg, ulong idx, const char *str, uint length, void **dest, int duplicate);
00409 
00410 ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long l TSRMLS_DC);
00411 ZEND_API int add_property_null_ex(zval *arg, const char *key, uint key_len TSRMLS_DC);
00412 ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC);
00413 ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, long r TSRMLS_DC);
00414 ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC);
00415 ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate TSRMLS_DC);
00416 ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len,  char *str, uint length, int duplicate TSRMLS_DC);
00417 ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC);
00418 
00419 #define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key)+1, __n TSRMLS_CC)
00420 #define add_property_null(__arg, __key) add_property_null_ex(__arg, __key, strlen(__key) + 1 TSRMLS_CC)
00421 #define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key)+1, __b TSRMLS_CC)
00422 #define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key)+1, __r TSRMLS_CC)
00423 #define add_property_double(__arg, __key, __d) add_property_double_ex(__arg, __key, strlen(__key)+1, __d TSRMLS_CC)
00424 #define add_property_string(__arg, __key, __str, __duplicate) add_property_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate TSRMLS_CC)
00425 #define add_property_stringl(__arg, __key, __str, __length, __duplicate) add_property_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate TSRMLS_CC)
00426 #define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key)+1, __value TSRMLS_CC)       
00427 
00428 
00429 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);
00430 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);
00431 
00432 ZEND_API extern const zend_fcall_info empty_fcall_info;
00433 ZEND_API extern const zend_fcall_info_cache empty_fcall_info_cache;
00434 
00445 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);
00446 
00450 ZEND_API void zend_fcall_info_args_clear(zend_fcall_info *fci, int free_mem);
00451 
00455 ZEND_API void zend_fcall_info_args_save(zend_fcall_info *fci, int *param_count, zval ****params);
00456 
00459 ZEND_API void zend_fcall_info_args_restore(zend_fcall_info *fci, int param_count, zval ***params);
00460 
00464 ZEND_API int zend_fcall_info_args(zend_fcall_info *fci, zval *args TSRMLS_DC);
00465 
00470 ZEND_API int zend_fcall_info_argp(zend_fcall_info *fci TSRMLS_DC, int argc, zval ***argv);
00471 
00476 ZEND_API int zend_fcall_info_argv(zend_fcall_info *fci TSRMLS_DC, int argc, va_list *argv);
00477 
00482 ZEND_API int zend_fcall_info_argn(zend_fcall_info *fci TSRMLS_DC, int argc, ...);
00483 
00487 ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *fcc, zval **retval, zval *args TSRMLS_DC);
00488 
00489 ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TSRMLS_DC);
00490 
00491 ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, int name_length, zend_bool is_ref, int num_symbol_tables, ...);
00492 
00493 ZEND_API int zend_delete_global_variable(char *name, int name_len TSRMLS_DC);
00494 
00495 ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC);
00496 
00497 ZEND_API void zend_rebuild_symbol_table(TSRMLS_D);
00498 
00499 #define add_method(arg, key, method)      add_assoc_function((arg), (key), (method))
00500 
00501 ZEND_API ZEND_FUNCTION(display_disabled_function);
00502 ZEND_API ZEND_FUNCTION(display_disabled_class);
00503 END_EXTERN_C()
00504 
00505 #if ZEND_DEBUG
00506 #define CHECK_ZVAL_STRING(z) \
00507        if (Z_STRVAL_P(z)[ Z_STRLEN_P(z) ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", Z_STRVAL_P(z)); }
00508 #define CHECK_ZVAL_STRING_REL(z) \
00509        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); }
00510 #else
00511 #define CHECK_ZVAL_STRING(z)
00512 #define CHECK_ZVAL_STRING_REL(z)
00513 #endif
00514 
00515 #define ZVAL_RESOURCE(z, l) {             \
00516               Z_TYPE_P(z) = IS_RESOURCE;  \
00517               Z_LVAL_P(z) = l;                   \
00518        }
00519 
00520 #define ZVAL_BOOL(z, b) {                 \
00521               Z_TYPE_P(z) = IS_BOOL;             \
00522               Z_LVAL_P(z) = ((b) != 0);   \
00523        }
00524 
00525 #define ZVAL_NULL(z) {                           \
00526               Z_TYPE_P(z) = IS_NULL;             \
00527        }
00528 
00529 #define ZVAL_LONG(z, l) {                 \
00530               Z_TYPE_P(z) = IS_LONG;             \
00531               Z_LVAL_P(z) = l;                   \
00532        }
00533 
00534 #define ZVAL_DOUBLE(z, d) {               \
00535               Z_TYPE_P(z) = IS_DOUBLE;    \
00536               Z_DVAL_P(z) = d;                   \
00537        }
00538 
00539 #define ZVAL_STRING(z, s, duplicate) {    \
00540               const char *__s=(s);               \
00541               Z_STRLEN_P(z) = strlen(__s);       \
00542               Z_STRVAL_P(z) = (duplicate?estrndup(__s, Z_STRLEN_P(z)):(char*)__s);\
00543               Z_TYPE_P(z) = IS_STRING;           \
00544        }
00545 
00546 #define ZVAL_STRINGL(z, s, l, duplicate) {       \
00547               const char *__s=(s); int __l=l;           \
00548               Z_STRLEN_P(z) = __l;                      \
00549               Z_STRVAL_P(z) = (duplicate?estrndup(__s, __l):(char*)__s);\
00550               Z_TYPE_P(z) = IS_STRING;                  \
00551        }
00552 
00553 #define ZVAL_EMPTY_STRING(z) {            \
00554               Z_STRLEN_P(z) = 0;                 \
00555               Z_STRVAL_P(z) = STR_EMPTY_ALLOC();\
00556               Z_TYPE_P(z) = IS_STRING;    \
00557        }
00558 
00559 #define ZVAL_ZVAL(z, zv, copy, dtor) {                  \
00560               zend_uchar is_ref = Z_ISREF_P(z);         \
00561               zend_uint refcount = Z_REFCOUNT_P(z);     \
00562               *(z) = *(zv);                                           \
00563               if (copy) {                                                    \
00564                      zval_copy_ctor(z);                               \
00565            }                                                                 \
00566               if (dtor) {                                                    \
00567                      if (!copy) {                                     \
00568                             ZVAL_NULL(zv);                                   \
00569                      }                                                              \
00570                      zval_ptr_dtor(&zv);                              \
00571            }                                                                 \
00572               Z_SET_ISREF_TO_P(z, is_ref);                     \
00573               Z_SET_REFCOUNT_P(z, refcount);                   \
00574        }
00575 
00576 #define ZVAL_FALSE(z)                                   ZVAL_BOOL(z, 0)
00577 #define ZVAL_TRUE(z)                                    ZVAL_BOOL(z, 1)
00578 
00579 #define RETVAL_RESOURCE(l)                       ZVAL_RESOURCE(return_value, l)
00580 #define RETVAL_BOOL(b)                                  ZVAL_BOOL(return_value, b)
00581 #define RETVAL_NULL()                                   ZVAL_NULL(return_value)
00582 #define RETVAL_LONG(l)                                  ZVAL_LONG(return_value, l)
00583 #define RETVAL_DOUBLE(d)                         ZVAL_DOUBLE(return_value, d)
00584 #define RETVAL_STRING(s, duplicate)              ZVAL_STRING(return_value, s, duplicate)
00585 #define RETVAL_STRINGL(s, l, duplicate)   ZVAL_STRINGL(return_value, s, l, duplicate)
00586 #define RETVAL_EMPTY_STRING()                    ZVAL_EMPTY_STRING(return_value)
00587 #define RETVAL_ZVAL(zv, copy, dtor)              ZVAL_ZVAL(return_value, zv, copy, dtor)
00588 #define RETVAL_FALSE                                    ZVAL_BOOL(return_value, 0)
00589 #define RETVAL_TRUE                                     ZVAL_BOOL(return_value, 1)
00590 
00591 #define RETURN_RESOURCE(l)                       { RETVAL_RESOURCE(l); return; }
00592 #define RETURN_BOOL(b)                                  { RETVAL_BOOL(b); return; }
00593 #define RETURN_NULL()                                   { RETVAL_NULL(); return;}
00594 #define RETURN_LONG(l)                                  { RETVAL_LONG(l); return; }
00595 #define RETURN_DOUBLE(d)                         { RETVAL_DOUBLE(d); return; }
00596 #define RETURN_STRING(s, duplicate)       { RETVAL_STRING(s, duplicate); return; }
00597 #define RETURN_STRINGL(s, l, duplicate) { RETVAL_STRINGL(s, l, duplicate); return; }
00598 #define RETURN_EMPTY_STRING()                    { RETVAL_EMPTY_STRING(); return; }
00599 #define RETURN_ZVAL(zv, copy, dtor)              { RETVAL_ZVAL(zv, copy, dtor); return; }
00600 #define RETURN_FALSE                                    { RETVAL_FALSE; return; }
00601 #define RETURN_TRUE                                     { RETVAL_TRUE; return; }
00602 
00603 #define SET_VAR_STRING(n, v) {                                                                                                                                          \
00604                                                         {                                                                                                                                    \
00605                                                                zval *var;                                                                                                             \
00606                                                                ALLOC_ZVAL(var);                                                                                                \
00607                                                                ZVAL_STRING(var, v, 0);                                                                                         \
00608                                                                ZEND_SET_GLOBAL_VAR(n, var);                                                                             \
00609                                                         }                                                                                                                                    \
00610                                                  }
00611 
00612 #define SET_VAR_STRINGL(n, v, l) {                                                                                            \
00613                                                                {                                                                                          \
00614                                                                       zval *var;                                                                   \
00615                                                                       ALLOC_ZVAL(var);                                                      \
00616                                                                       ZVAL_STRINGL(var, v, l, 0);                                    \
00617                                                                       ZEND_SET_GLOBAL_VAR(n, var);                                   \
00618                                                                }                                                                                          \
00619                                                         }
00620 
00621 #define SET_VAR_LONG(n, v)  {                                                                                                        \
00622                                                         {                                                                                                 \
00623                                                                zval *var;                                                                          \
00624                                                                ALLOC_ZVAL(var);                                                             \
00625                                                                ZVAL_LONG(var, v);                                                           \
00626                                                                ZEND_SET_GLOBAL_VAR(n, var);                                          \
00627                                                         }                                                                                                 \
00628                                                  }
00629 
00630 #define SET_VAR_DOUBLE(n, v) {                                                                                                       \
00631                                                         {                                                                                                 \
00632                                                                zval *var;                                                                          \
00633                                                                ALLOC_ZVAL(var);                                                             \
00634                                                                ZVAL_DOUBLE(var, v);                                                  \
00635                                                                ZEND_SET_GLOBAL_VAR(n, var);                                          \
00636                                                         }                                                                                                 \
00637                                                  }
00638 
00639 
00640 #define ZEND_SET_SYMBOL(symtable, name, var)                                                                    \
00641        {                                                                                                                                           \
00642               char *_name = (name);                                                                                                  \
00643                                                                                                                                                    \
00644               ZEND_SET_SYMBOL_WITH_LENGTH(symtable, _name, strlen(_name)+1, var, 1, 0);    \
00645        }
00646 
00647 #define ZEND_SET_SYMBOL_WITH_LENGTH(symtable, name, name_length, var, _refcount, _is_ref)                       \
00648        {                                                                                                                                                                              \
00649               zval **orig_var;                                                                                                                                          \
00650                                                                                                                                                                                       \
00651               if (zend_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS                        \
00652                      && PZVAL_IS_REF(*orig_var)) {                                                                                                               \
00653                      Z_SET_REFCOUNT_P(var, Z_REFCOUNT_PP(orig_var));                                                                               \
00654                      Z_SET_ISREF_P(var);                                                                                                                                \
00655                                                                                                                                                                                       \
00656                      if (_refcount) {                                                                                                                                   \
00657                             Z_SET_REFCOUNT_P(var, Z_REFCOUNT_P(var) + _refcount - 1);                                                       \
00658                      }                                                                                                                                                                \
00659                      zval_dtor(*orig_var);                                                                                                                              \
00660                      **orig_var = *(var);                                                                                                                        \
00661                      FREE_ZVAL(var);                                                                                                                                           \
00662               } else {                                                                                                                                                         \
00663                      Z_SET_ISREF_TO_P(var, _is_ref);                                                                                                             \
00664                      if (_refcount) {                                                                                                                                   \
00665                             Z_SET_REFCOUNT_P(var, _refcount);                                                                                             \
00666                      }                                                                                                                                                                \
00667                      zend_hash_update(symtable, (name), (name_length), &(var), sizeof(zval *), NULL);                  \
00668               }                                                                                                                                                                       \
00669        }
00670 
00671 
00672 #define ZEND_SET_GLOBAL_VAR(name, var)                         \
00673        ZEND_SET_SYMBOL(&EG(symbol_table), name, var)
00674 
00675 #define ZEND_SET_GLOBAL_VAR_WITH_LENGTH(name, name_length, var, _refcount, _is_ref) \
00676        ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), name, name_length, var, _refcount, _is_ref)
00677 
00678 #define ZEND_DEFINE_PROPERTY(class_ptr, name, value, mask)                                               \
00679 {                                                                                                                                                  \
00680        char *_name = (name);                                                                                                         \
00681        int namelen = strlen(_name);                                                                                           \
00682        zend_declare_property(class_ptr, _name, namelen, value, mask TSRMLS_CC);            \
00683 }
00684 
00685 #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)))
00686 #define ZVAL_IS_NULL(z) (Z_TYPE_P(z)==IS_NULL)
00687 
00688 /* For compatibility */
00689 #define ZEND_MINIT                 ZEND_MODULE_STARTUP_N
00690 #define ZEND_MSHUTDOWN             ZEND_MODULE_SHUTDOWN_N
00691 #define ZEND_RINIT                 ZEND_MODULE_ACTIVATE_N
00692 #define ZEND_RSHUTDOWN             ZEND_MODULE_DEACTIVATE_N
00693 #define ZEND_MINFO                 ZEND_MODULE_INFO_N
00694 #define ZEND_GINIT(module)         ((void (*)(void* TSRMLS_DC))(ZEND_MODULE_GLOBALS_CTOR_N(module)))
00695 #define ZEND_GSHUTDOWN(module)     ((void (*)(void* TSRMLS_DC))(ZEND_MODULE_GLOBALS_DTOR_N(module)))
00696 
00697 #define ZEND_MINIT_FUNCTION               ZEND_MODULE_STARTUP_D
00698 #define ZEND_MSHUTDOWN_FUNCTION           ZEND_MODULE_SHUTDOWN_D
00699 #define ZEND_RINIT_FUNCTION               ZEND_MODULE_ACTIVATE_D
00700 #define ZEND_RSHUTDOWN_FUNCTION           ZEND_MODULE_DEACTIVATE_D
00701 #define ZEND_MINFO_FUNCTION               ZEND_MODULE_INFO_D
00702 #define ZEND_GINIT_FUNCTION               ZEND_MODULE_GLOBALS_CTOR_D
00703 #define ZEND_GSHUTDOWN_FUNCTION           ZEND_MODULE_GLOBALS_DTOR_D
00704 
00705 END_EXTERN_C()
00706 
00707 #endif /* ZEND_API_H */
00708 
00709 
00710 /*
00711  * Local variables:
00712  * tab-width: 4
00713  * c-basic-offset: 4
00714  * indent-tabs-mode: t
00715  * End:
00716  */