[BACK]Return to zend_API.h CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / Zend

Diff for /embedaddon/php/Zend/zend_API.h between versions 1.1 and 1.1.1.4

version 1.1, 2012/02/21 23:47:52 version 1.1.1.4, 2014/06/15 20:04:03
Line 2 Line 2
    +----------------------------------------------------------------------+     +----------------------------------------------------------------------+
    | Zend Engine                                                          |     | Zend Engine                                                          |
    +----------------------------------------------------------------------+     +----------------------------------------------------------------------+
   | Copyright (c) 1998-2012 Zend Technologies Ltd. (http://www.zend.com) |   | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+     +----------------------------------------------------------------------+
    | This source file is subject to version 2.00 of the Zend license,     |     | This source file is subject to version 2.00 of the Zend license,     |
    | that is bundled with this package in the file LICENSE, and is        |     | that is bundled with this package in the file LICENSE, and is        |
Line 60  typedef struct _zend_fcall_info_cache { Line 60  typedef struct _zend_fcall_info_cache {
         zval *object_ptr;          zval *object_ptr;
 } zend_fcall_info_cache;  } zend_fcall_info_cache;
   
#define ZEND_NS_NAME(ns, name)                  ns"\\"name#define ZEND_NS_NAME(ns, name)                  ns "\\" name
   
 #define ZEND_FN(name) zif_##name  #define ZEND_FN(name) zif_##name
 #define ZEND_MN(name) zim_##name  #define ZEND_MN(name) zim_##name
Line 90  typedef struct _zend_fcall_info_cache { Line 90  typedef struct _zend_fcall_info_cache {
 #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)  #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)
 #define ZEND_NS_RAW_NAMED_FE(ns, zend_name, name, arg_info)                     ZEND_NS_RAW_FENTRY(ns, #zend_name, name, arg_info, 0)  #define ZEND_NS_RAW_NAMED_FE(ns, zend_name, name, arg_info)                     ZEND_NS_RAW_FENTRY(ns, #zend_name, name, arg_info, 0)
   
#define ZEND_NS_NAMED_FE(ns, zend_name, name, arg_info) ZEND_NS_FENTRY(ns, #zend_name, name, arg_info, 0)#define ZEND_NS_NAMED_FE(ns, zend_name, name, arg_info) ZEND_NS_FENTRY(ns, zend_name, name, arg_info, 0)
 #define ZEND_NS_FE(ns, name, arg_info)                                  ZEND_NS_FENTRY(ns, name, ZEND_FN(name), arg_info, 0)  #define ZEND_NS_FE(ns, name, arg_info)                                  ZEND_NS_FENTRY(ns, name, ZEND_FN(name), arg_info, 0)
 #define ZEND_NS_DEP_FE(ns, name, arg_info)                              ZEND_NS_FENTRY(ns, name, ZEND_FN(name), arg_info, ZEND_ACC_DEPRECATED)  #define ZEND_NS_DEP_FE(ns, name, arg_info)                              ZEND_NS_FENTRY(ns, name, ZEND_FN(name), arg_info, ZEND_ACC_DEPRECATED)
 #define ZEND_NS_FALIAS(ns, name, alias, arg_info)               ZEND_NS_FENTRY(ns, name, ZEND_FN(alias), arg_info, 0)  #define ZEND_NS_FALIAS(ns, name, alias, arg_info)               ZEND_NS_FENTRY(ns, name, ZEND_FN(alias), arg_info, 0)
Line 98  typedef struct _zend_fcall_info_cache { Line 98  typedef struct _zend_fcall_info_cache {
   
 #define ZEND_FE_END            { NULL, NULL, NULL, 0, 0 }  #define ZEND_FE_END            { NULL, NULL, NULL, 0, 0 }
   
#define ZEND_ARG_INFO(pass_by_ref, name)                                                        { #name, sizeof(#name)-1, NULL, 0, 0, 0, pass_by_ref, 0, 0 },#define ZEND_ARG_INFO(pass_by_ref, name)                                                        { #name, sizeof(#name)-1, NULL, 0, 0, 0, pass_by_ref},
#define ZEND_ARG_PASS_INFO(pass_by_ref)                                                         { NULL, 0, NULL, 0, 0, 0, pass_by_ref, 0, 0 },#define ZEND_ARG_PASS_INFO(pass_by_ref)                                                         { NULL, 0, NULL, 0, 0, 0, pass_by_ref},
#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 },#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},
#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 },#define ZEND_ARG_ARRAY_INFO(pass_by_ref, name, allow_null) { #name, sizeof(#name)-1, NULL, 0, IS_ARRAY, allow_null, pass_by_ref},
 #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},
 #define ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, return_reference, required_num_args)       \  #define ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, return_reference, required_num_args)       \
         static const zend_arg_info name[] = {                                                                                                                                           \          static const zend_arg_info name[] = {                                                                                                                                           \
                { NULL, 0, NULL, 0, 0, 0, pass_rest_by_reference, return_reference, required_num_args },                { NULL, 0, NULL, required_num_args, 0, return_reference, pass_rest_by_reference},
 #define ZEND_BEGIN_ARG_INFO(name, pass_rest_by_reference)       \  #define ZEND_BEGIN_ARG_INFO(name, pass_rest_by_reference)       \
         ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, ZEND_RETURN_VALUE, -1)          ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, ZEND_RETURN_VALUE, -1)
 #define ZEND_END_ARG_INFO()             };  #define ZEND_END_ARG_INFO()             };
Line 167  typedef struct _zend_fcall_info_cache { Line 168  typedef struct _zend_fcall_info_cache {
   
 #define INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \  #define INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
         {                                                                                                                       \          {                                                                                                                       \
                   const char *cl_name = class_name;                                                               \
                 int _len = class_name_len;                                                              \                  int _len = class_name_len;                                                              \
                class_container.name = zend_strndup(class_name, _len);   \                class_container.name = zend_new_interned_string(cl_name, _len+1, 0 TSRMLS_CC);  \
                 if (class_container.name == cl_name) {                                  \
                         class_container.name = zend_strndup(cl_name, _len);   \
                 }                                                                                                               \
                 class_container.name_length = _len;                                             \                  class_container.name_length = _len;                                             \
                class_container.builtin_functions = functions;                        \                INIT_CLASS_ENTRY_INIT_METHODS(class_container, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
         }
 
 #define INIT_CLASS_ENTRY_INIT_METHODS(class_container, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
         {                                                                                                                       \
                 class_container.constructor = NULL;                                             \                  class_container.constructor = NULL;                                             \
                 class_container.destructor = NULL;                                              \                  class_container.destructor = NULL;                                              \
                 class_container.clone = NULL;                                                   \                  class_container.clone = NULL;                                                   \
Line 192  typedef struct _zend_fcall_info_cache { Line 201  typedef struct _zend_fcall_info_cache {
                 class_container.unserialize = NULL;                                             \                  class_container.unserialize = NULL;                                             \
                 class_container.parent = NULL;                                                  \                  class_container.parent = NULL;                                                  \
                 class_container.num_interfaces = 0;                                             \                  class_container.num_interfaces = 0;                                             \
                   class_container.traits = NULL;                                                  \
                   class_container.num_traits = 0;                                                 \
                   class_container.trait_aliases = NULL;                                   \
                   class_container.trait_precedences = NULL;                               \
                 class_container.interfaces = NULL;                                              \                  class_container.interfaces = NULL;                                              \
                 class_container.get_iterator = NULL;                                    \                  class_container.get_iterator = NULL;                                    \
                 class_container.iterator_funcs.funcs = NULL;                    \                  class_container.iterator_funcs.funcs = NULL;                    \
                class_container.module = NULL;                                                 \                class_container.info.internal.module = NULL;                 \
                 class_container.info.internal.builtin_functions = functions;    \
         }          }
   
 #define INIT_OVERLOADED_CLASS_ENTRY(class_container, class_name, functions, handle_fcall, handle_propget, handle_propset) \  #define INIT_OVERLOADED_CLASS_ENTRY(class_container, class_name, functions, handle_fcall, handle_propget, handle_propset) \
Line 209  typedef struct _zend_fcall_info_cache { Line 223  typedef struct _zend_fcall_info_cache {
         INIT_OVERLOADED_CLASS_ENTRY(class_container, ZEND_NS_NAME(ns, class_name), functions, handle_fcall, handle_propget, handle_propset)          INIT_OVERLOADED_CLASS_ENTRY(class_container, ZEND_NS_NAME(ns, class_name), functions, handle_fcall, handle_propget, handle_propset)
   
 #ifdef ZTS  #ifdef ZTS
#       define CE_STATIC_MEMBERS(ce) (((ce)->type==ZEND_USER_CLASS)?(ce)->static_members:CG(static_members)[(zend_intptr_t)(ce)->static_members])#       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])
 #else  #else
#       define CE_STATIC_MEMBERS(ce) ((ce)->static_members)#       define CE_STATIC_MEMBERS(ce) ((ce)->static_members_table)
 #endif  #endif
   
 #define ZEND_FCI_INITIALIZED(fci) ((fci).size != 0)  #define ZEND_FCI_INITIALIZED(fci) ((fci).size != 0)
Line 237  ZEND_API int zend_copy_parameters_array(int param_coun Line 251  ZEND_API int zend_copy_parameters_array(int param_coun
 /* Parameter parsing API -- andrei */  /* Parameter parsing API -- andrei */
   
 #define ZEND_PARSE_PARAMS_QUIET 1<<1  #define ZEND_PARSE_PARAMS_QUIET 1<<1
ZEND_API int zend_parse_parameters(int num_args TSRMLS_DC, char *type_spec, ...);ZEND_API int zend_parse_parameters(int num_args TSRMLS_DC, const char *type_spec, ...);
ZEND_API int zend_parse_parameters_ex(int flags, int num_args TSRMLS_DC, char *type_spec, ...);ZEND_API int zend_parse_parameters_ex(int flags, int num_args TSRMLS_DC, const char *type_spec, ...);
 ZEND_API char *zend_zval_type_name(const zval *arg);  ZEND_API char *zend_zval_type_name(const zval *arg);
   
ZEND_API int zend_parse_method_parameters(int num_args TSRMLS_DC, zval *this_ptr, char *type_spec, ...);ZEND_API int zend_parse_method_parameters(int num_args TSRMLS_DC, zval *this_ptr, const char *type_spec, ...);
ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC, zval *this_ptr, char *type_spec, ...);ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC, zval *this_ptr, const char *type_spec, ...);
   
 /* End of parameter parsing API -- andrei */  /* End of parameter parsing API -- andrei */
   
Line 253  ZEND_API zend_module_entry* zend_register_internal_mod Line 267  ZEND_API zend_module_entry* zend_register_internal_mod
 ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module TSRMLS_DC);  ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module TSRMLS_DC);
 ZEND_API int zend_startup_module_ex(zend_module_entry *module TSRMLS_DC);  ZEND_API int zend_startup_module_ex(zend_module_entry *module TSRMLS_DC);
 ZEND_API int zend_startup_modules(TSRMLS_D);  ZEND_API int zend_startup_modules(TSRMLS_D);
   ZEND_API void zend_collect_module_handlers(TSRMLS_D);
   ZEND_API void zend_destroy_modules(void);
 ZEND_API void zend_check_magic_method_implementation(const zend_class_entry *ce, const zend_function *fptr, int error_type TSRMLS_DC);  ZEND_API void zend_check_magic_method_implementation(const zend_class_entry *ce, const zend_function *fptr, int error_type TSRMLS_DC);
   
 ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry TSRMLS_DC);  ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry TSRMLS_DC);
Line 263  ZEND_API void zend_class_implements(zend_class_entry * Line 279  ZEND_API void zend_class_implements(zend_class_entry *
 ZEND_API int zend_register_class_alias_ex(const char *name, int name_len, zend_class_entry *ce TSRMLS_DC);  ZEND_API int zend_register_class_alias_ex(const char *name, int name_len, zend_class_entry *ce TSRMLS_DC);
   
 #define zend_register_class_alias(name, ce) \  #define zend_register_class_alias(name, ce) \
        zend_register_class_alias_ex(name, sizeof(name)-1, ce TSRMLS_DC)        zend_register_class_alias_ex(name, sizeof(name)-1, ce TSRMLS_CC)
 #define zend_register_ns_class_alias(ns, name, ce) \  #define zend_register_ns_class_alias(ns, name, ce) \
        zend_register_class_alias_ex(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name))-1, ce TSRMLS_DC)        zend_register_class_alias_ex(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name))-1, ce TSRMLS_CC)
   
 ZEND_API int zend_disable_function(char *function_name, uint function_name_length TSRMLS_DC);  ZEND_API int zend_disable_function(char *function_name, uint function_name_length TSRMLS_DC);
 ZEND_API int zend_disable_class(char *class_name, uint class_name_length TSRMLS_DC);  ZEND_API int zend_disable_class(char *class_name, uint class_name_length TSRMLS_DC);
Line 284  ZEND_API zend_bool zend_is_callable(zval *callable, ui Line 300  ZEND_API zend_bool zend_is_callable(zval *callable, ui
 ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRMLS_DC);  ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRMLS_DC);
 ZEND_API const char *zend_get_module_version(const char *module_name);  ZEND_API const char *zend_get_module_version(const char *module_name);
 ZEND_API int zend_get_module_started(const char *module_name);  ZEND_API int zend_get_module_started(const char *module_name);
ZEND_API int zend_declare_property(zend_class_entry *ce, char *name, int name_length, zval *property, int access_type TSRMLS_DC);ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type TSRMLS_DC);
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);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);
ZEND_API int zend_declare_property_null(zend_class_entry *ce, char *name, int name_length, int access_type TSRMLS_DC);ZEND_API int zend_declare_property_null(zend_class_entry *ce, const char *name, int name_length, int access_type TSRMLS_DC);
ZEND_API int zend_declare_property_bool(zend_class_entry *ce, char *name, int name_length, long value, int access_type TSRMLS_DC);ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC);
ZEND_API int zend_declare_property_long(zend_class_entry *ce, char *name, int name_length, long value, int access_type TSRMLS_DC);ZEND_API int zend_declare_property_long(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC);
ZEND_API int zend_declare_property_double(zend_class_entry *ce, char *name, int name_length, double value, int access_type TSRMLS_DC);ZEND_API int zend_declare_property_double(zend_class_entry *ce, const char *name, int name_length, double value, int access_type TSRMLS_DC);
ZEND_API int zend_declare_property_string(zend_class_entry *ce, char *name, int name_length, char *value, int access_type TSRMLS_DC);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);
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);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);
   
 ZEND_API int zend_declare_class_constant(zend_class_entry *ce, const char *name, size_t name_length, zval *value TSRMLS_DC);  ZEND_API int zend_declare_class_constant(zend_class_entry *ce, const char *name, size_t name_length, zval *value TSRMLS_DC);
 ZEND_API int zend_declare_class_constant_null(zend_class_entry *ce, const char *name, size_t name_length TSRMLS_DC);  ZEND_API int zend_declare_class_constant_null(zend_class_entry *ce, const char *name, size_t name_length TSRMLS_DC);
Line 302  ZEND_API int zend_declare_class_constant_stringl(zend_ Line 318  ZEND_API int zend_declare_class_constant_stringl(zend_
 ZEND_API int zend_declare_class_constant_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value TSRMLS_DC);  ZEND_API int zend_declare_class_constant_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value TSRMLS_DC);
   
 ZEND_API void zend_update_class_constants(zend_class_entry *class_type TSRMLS_DC);  ZEND_API void zend_update_class_constants(zend_class_entry *class_type TSRMLS_DC);
ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, char *name, int name_length, zval *value TSRMLS_DC);ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const char *name, int name_length, zval *value TSRMLS_DC);
ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, char *name, int name_length TSRMLS_DC);ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, const char *name, int name_length TSRMLS_DC);
ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, char *name, int name_length, long value TSRMLS_DC);ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC);
ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, char *name, int name_length, long value TSRMLS_DC);ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC);
ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object, char *name, int name_length, double value TSRMLS_DC);ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object, const char *name, int name_length, double value TSRMLS_DC);
ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, char *name, int name_length, const char *value TSRMLS_DC);ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, const char *name, int name_length, const char *value TSRMLS_DC);
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);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);
   
ZEND_API int zend_update_static_property(zend_class_entry *scope, char *name, int name_length, zval *value TSRMLS_DC);ZEND_API int zend_update_static_property(zend_class_entry *scope, const char *name, int name_length, zval *value TSRMLS_DC);
ZEND_API int zend_update_static_property_null(zend_class_entry *scope, char *name, int name_length TSRMLS_DC);ZEND_API int zend_update_static_property_null(zend_class_entry *scope, const char *name, int name_length TSRMLS_DC);
ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, char *name, int name_length, long value TSRMLS_DC);ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC);
ZEND_API int zend_update_static_property_long(zend_class_entry *scope, char *name, int name_length, long value TSRMLS_DC);ZEND_API int zend_update_static_property_long(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC);
ZEND_API int zend_update_static_property_double(zend_class_entry *scope, char *name, int name_length, double value TSRMLS_DC);ZEND_API int zend_update_static_property_double(zend_class_entry *scope, const char *name, int name_length, double value TSRMLS_DC);
ZEND_API int zend_update_static_property_string(zend_class_entry *scope, char *name, int name_length, const char *value TSRMLS_DC);ZEND_API int zend_update_static_property_string(zend_class_entry *scope, const char *name, int name_length, const char *value TSRMLS_DC);
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);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);
   
ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, char *name, int name_length, zend_bool silent TSRMLS_DC);ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const char *name, int name_length, zend_bool silent TSRMLS_DC);
   
ZEND_API zval *zend_read_static_property(zend_class_entry *scope, char *name, int name_length, zend_bool silent TSRMLS_DC);ZEND_API zval *zend_read_static_property(zend_class_entry *scope, const char *name, int name_length, zend_bool silent TSRMLS_DC);
   
 ZEND_API zend_class_entry *zend_get_class_entry(const zval *zobject TSRMLS_DC);  ZEND_API zend_class_entry *zend_get_class_entry(const zval *zobject TSRMLS_DC);
ZEND_API int zend_get_object_classname(const zval *object, char **class_name, zend_uint *class_name_len TSRMLS_DC);ZEND_API int zend_get_object_classname(const zval *object, const char **class_name, zend_uint *class_name_len TSRMLS_DC);
 ZEND_API char *zend_get_type_by_const(int type);  ZEND_API char *zend_get_type_by_const(int type);
   
 #define getThis() (this_ptr)  #define getThis() (this_ptr)
Line 348  ZEND_API int _array_init(zval *arg, uint size ZEND_FIL Line 364  ZEND_API int _array_init(zval *arg, uint size ZEND_FIL
 ZEND_API int _object_init(zval *arg ZEND_FILE_LINE_DC TSRMLS_DC);  ZEND_API int _object_init(zval *arg ZEND_FILE_LINE_DC TSRMLS_DC);
 ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC TSRMLS_DC);  ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC TSRMLS_DC);
 ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties ZEND_FILE_LINE_DC TSRMLS_DC);  ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties ZEND_FILE_LINE_DC TSRMLS_DC);
   ZEND_API void object_properties_init(zend_object *object, zend_class_entry *class_type);
   
 ZEND_API void zend_merge_properties(zval *obj, HashTable *properties, int destroy_ht TSRMLS_DC);  ZEND_API void zend_merge_properties(zval *obj, HashTable *properties, int destroy_ht TSRMLS_DC);
   
Line 412  ZEND_API int add_property_null_ex(zval *arg, const cha Line 429  ZEND_API int add_property_null_ex(zval *arg, const cha
 ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC);  ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC);
 ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, long r TSRMLS_DC);  ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, long r TSRMLS_DC);
 ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC);  ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC);
ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate TSRMLS_DC);ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate TSRMLS_DC);
ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len,  char *str, uint length, int duplicate TSRMLS_DC);ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len,  const char *str, uint length, int duplicate TSRMLS_DC);
 ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC);  ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC);
   
 #define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key)+1, __n TSRMLS_CC)  #define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key)+1, __n TSRMLS_CC)
Line 444  ZEND_API extern const zend_fcall_info_cache empty_fcal Line 461  ZEND_API extern const zend_fcall_info_cache empty_fcal
  */   */
 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);  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);
   
/** Clear argumens connected with zend_fcall_info *fci/** Clear arguments connected with zend_fcall_info *fci
  * If free_mem is not zero then the params array gets free'd as well   * If free_mem is not zero then the params array gets free'd as well
  */   */
 ZEND_API void zend_fcall_info_args_clear(zend_fcall_info *fci, int free_mem);  ZEND_API void zend_fcall_info_args_clear(zend_fcall_info *fci, int free_mem);
Line 482  ZEND_API int zend_fcall_info_argv(zend_fcall_info *fci Line 499  ZEND_API int zend_fcall_info_argv(zend_fcall_info *fci
 ZEND_API int zend_fcall_info_argn(zend_fcall_info *fci TSRMLS_DC, int argc, ...);  ZEND_API int zend_fcall_info_argn(zend_fcall_info *fci TSRMLS_DC, int argc, ...);
   
 /** Call a function using information created by zend_fcall_info_init()/args().  /** Call a function using information created by zend_fcall_info_init()/args().
 * If args is given then those replace the arguement info in fci is temporarily. * If args is given then those replace the argument info in fci is temporarily.
  */   */
 ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *fcc, zval **retval, zval *args TSRMLS_DC);  ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *fcc, zval **retval, zval *args TSRMLS_DC);
   
Line 490  ZEND_API int zend_call_function(zend_fcall_info *fci,  Line 507  ZEND_API int zend_call_function(zend_fcall_info *fci, 
   
 ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, int name_length, zend_bool is_ref, int num_symbol_tables, ...);  ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, int name_length, zend_bool is_ref, int num_symbol_tables, ...);
   
ZEND_API int zend_delete_global_variable(char *name, int name_len TSRMLS_DC);ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, int name_len, ulong hash_value TSRMLS_DC);
   
   ZEND_API int zend_delete_global_variable(const char *name, int name_len TSRMLS_DC);
   
   ZEND_API int zend_delete_global_variable_ex(const char *name, int name_len, ulong hash_value TSRMLS_DC);
   
 ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC);  ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC);
   
 ZEND_API void zend_rebuild_symbol_table(TSRMLS_D);  ZEND_API void zend_rebuild_symbol_table(TSRMLS_D);
   
   ZEND_API const char* zend_find_alias_name(zend_class_entry *ce, const char *name, zend_uint len);
   ZEND_API const char* zend_resolve_method_name(zend_class_entry *ce, zend_function *f);
   
 #define add_method(arg, key, method)    add_assoc_function((arg), (key), (method))  #define add_method(arg, key, method)    add_assoc_function((arg), (key), (method))
   
 ZEND_API ZEND_FUNCTION(display_disabled_function);  ZEND_API ZEND_FUNCTION(display_disabled_function);
Line 512  END_EXTERN_C() Line 536  END_EXTERN_C()
 #define CHECK_ZVAL_STRING_REL(z)  #define CHECK_ZVAL_STRING_REL(z)
 #endif  #endif
   
#define ZVAL_RESOURCE(z, l) {                \#define CHECK_ZVAL_NULL_PATH(p) (Z_STRLEN_P(p) != strlen(Z_STRVAL_P(p)))
                Z_TYPE_P(z) = IS_RESOURCE;      \#define CHECK_NULL_PATH(p, l) (strlen(p) != l)
                Z_LVAL_P(z) = l;                 \ 
        } 
   
#define ZVAL_BOOL(z, b) {                        \#define ZVAL_RESOURCE(z, l) do { \
                Z_TYPE_P(z) = IS_BOOL;           \                zval *__z = (z);                        \
                Z_LVAL_P(z) = ((b) != 0);   \                Z_LVAL_P(__z) = l;                        \
        }                Z_TYPE_P(__z) = IS_RESOURCE;\
         } while (0)
   
   #define ZVAL_BOOL(z, b) do {            \
                   zval *__z = (z);                        \
                   Z_LVAL_P(__z) = ((b) != 0);     \
                   Z_TYPE_P(__z) = IS_BOOL;        \
           } while (0)
   
 #define ZVAL_NULL(z) {                          \  #define ZVAL_NULL(z) {                          \
                 Z_TYPE_P(z) = IS_NULL;          \                  Z_TYPE_P(z) = IS_NULL;          \
         }          }
   
 #define ZVAL_LONG(z, l) {                       \  #define ZVAL_LONG(z, l) {                       \
                Z_TYPE_P(z) = IS_LONG;           \                zval *__z = (z);                        \
                Z_LVAL_P(z) = l;                        \                Z_LVAL_P(__z) = l;                      \
                 Z_TYPE_P(__z) = IS_LONG;   \
         }          }
   
 #define ZVAL_DOUBLE(z, d) {                     \  #define ZVAL_DOUBLE(z, d) {                     \
                Z_TYPE_P(z) = IS_DOUBLE; \                zval *__z = (z);                        \
                Z_DVAL_P(z) = d;                        \                Z_DVAL_P(__z) = d;                      \
                 Z_TYPE_P(__z) = IS_DOUBLE; \
         }          }
   
#define ZVAL_STRING(z, s, duplicate) {       \#define ZVAL_STRING(z, s, duplicate) do {      \
                const char *__s=(s);                    \                const char *__s=(s);                            \
                Z_STRLEN_P(z) = strlen(__s);       \                zval *__z = (z);                                        \
                Z_STRVAL_P(z) = (duplicate?estrndup(__s, Z_STRLEN_P(z)):(char*)__s);\                Z_STRLEN_P(__z) = strlen(__s);               \
                Z_TYPE_P(z) = IS_STRING;         \                Z_STRVAL_P(__z) = (duplicate?estrndup(__s, Z_STRLEN_P(__z)):(char*)__s);\
        }                Z_TYPE_P(__z) = IS_STRING;                 \
         } while (0)
   
#define ZVAL_STRINGL(z, s, l, duplicate) {       \#define ZVAL_STRINGL(z, s, l, duplicate) do {      \
                const char *__s=(s); int __l=l;         \                const char *__s=(s); int __l=l;                 \
                Z_STRLEN_P(z) = __l;                               \                zval *__z = (z);                                                \
                Z_STRVAL_P(z) = (duplicate?estrndup(__s, __l):(char*)__s);\                Z_STRLEN_P(__z) = __l;                                       \
                Z_TYPE_P(z) = IS_STRING;                 \                Z_STRVAL_P(__z) = (duplicate?estrndup(__s, __l):(char*)__s);\
        }                Z_TYPE_P(__z) = IS_STRING;                         \
         } while (0)
   
#define ZVAL_EMPTY_STRING(z) {                \#define ZVAL_EMPTY_STRING(z) do {    \
                Z_STRLEN_P(z) = 0;                 \                zval *__z = (z);                        \
                Z_STRVAL_P(z) = STR_EMPTY_ALLOC();\                Z_STRLEN_P(__z) = 0;         \
                Z_TYPE_P(z) = IS_STRING; \                Z_STRVAL_P(__z) = STR_EMPTY_ALLOC();\
        }                Z_TYPE_P(__z) = IS_STRING; \
         } while (0)
   
 #define ZVAL_ZVAL(z, zv, copy, dtor) {                  \  #define ZVAL_ZVAL(z, zv, copy, dtor) {                  \
                 zend_uchar is_ref = Z_ISREF_P(z);               \                  zend_uchar is_ref = Z_ISREF_P(z);               \
                 zend_uint refcount = Z_REFCOUNT_P(z);   \                  zend_uint refcount = Z_REFCOUNT_P(z);   \
                *(z) = *(zv);                                                    \                ZVAL_COPY_VALUE(z, zv);                                   \
                 if (copy) {                                                             \                  if (copy) {                                                             \
                         zval_copy_ctor(z);                                      \                          zval_copy_ctor(z);                                      \
             }                                                                           \              }                                                                           \
Removed from v.1.1  
changed lines
  Added in v.1.1.1.4

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