PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - Zend - zend.h (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 8 8 100.0 %
Date: 2014-07-23 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | Zend Engine                                                          |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
       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             :    +----------------------------------------------------------------------+
      18             : */
      19             : 
      20             : /* $Id$ */
      21             : 
      22             : #ifndef ZEND_H
      23             : #define ZEND_H
      24             : 
      25             : #define ZEND_VERSION "2.3.0"
      26             : 
      27             : #define ZEND_ENGINE_2
      28             : 
      29             : #ifdef __cplusplus
      30             : #define BEGIN_EXTERN_C() extern "C" {
      31             : #define END_EXTERN_C() }
      32             : #else
      33             : #define BEGIN_EXTERN_C()
      34             : #define END_EXTERN_C()
      35             : #endif
      36             : 
      37             : /*
      38             :  * general definitions
      39             :  */
      40             : 
      41             : #ifdef ZEND_WIN32
      42             : # include "zend_config.w32.h"
      43             : # define ZEND_PATHS_SEPARATOR           ';'
      44             : #elif defined(NETWARE)
      45             : # include <zend_config.h>
      46             : # define ZEND_PATHS_SEPARATOR           ';'
      47             : #elif defined(__riscos__)
      48             : # include <zend_config.h>
      49             : # define ZEND_PATHS_SEPARATOR           ';'
      50             : #else
      51             : # include <zend_config.h>
      52             : # define ZEND_PATHS_SEPARATOR           ':'
      53             : #endif
      54             : 
      55             : #ifdef ZEND_WIN32
      56             : /* Only use this macro if you know for sure that all of the switches values
      57             :    are covered by its case statements */
      58             : #define EMPTY_SWITCH_DEFAULT_CASE() \
      59             :                         default:                                \
      60             :                                 __assume(0);            \
      61             :                                 break;
      62             : #else
      63             : #define EMPTY_SWITCH_DEFAULT_CASE()
      64             : #endif
      65             : 
      66             : /* all HAVE_XXX test have to be after the include of zend_config above */
      67             : 
      68             : #include <stdio.h>
      69             : 
      70             : #ifdef HAVE_UNIX_H
      71             : # include <unix.h>
      72             : #endif
      73             : 
      74             : #ifdef HAVE_STDARG_H
      75             : # include <stdarg.h>
      76             : #endif
      77             : 
      78             : #ifdef HAVE_DLFCN_H
      79             : # include <dlfcn.h>
      80             : #endif
      81             : 
      82             : #if defined(HAVE_LIBDL) && !defined(ZEND_WIN32)
      83             : 
      84             : # ifndef RTLD_LAZY
      85             : #  define RTLD_LAZY 1    /* Solaris 1, FreeBSD's (2.1.7.1 and older) */
      86             : # endif
      87             : 
      88             : # ifndef RTLD_GLOBAL
      89             : #  define RTLD_GLOBAL 0
      90             : # endif
      91             : 
      92             : # if defined(RTLD_GROUP) && defined(RTLD_WORLD) && defined(RTLD_PARENT)
      93             : #  define DL_LOAD(libname)                      dlopen(libname, RTLD_LAZY | RTLD_GLOBAL | RTLD_GROUP | RTLD_WORLD | RTLD_PARENT)
      94             : # elif defined(RTLD_DEEPBIND)
      95             : #  define DL_LOAD(libname)                      dlopen(libname, RTLD_LAZY | RTLD_GLOBAL | RTLD_DEEPBIND)
      96             : # else
      97             : #  define DL_LOAD(libname)                      dlopen(libname, RTLD_LAZY | RTLD_GLOBAL)
      98             : # endif
      99             : # define DL_UNLOAD                                      dlclose
     100             : # if defined(DLSYM_NEEDS_UNDERSCORE)
     101             : #  define DL_FETCH_SYMBOL(h,s)          dlsym((h), "_" s)
     102             : # else
     103             : #  define DL_FETCH_SYMBOL                       dlsym
     104             : # endif
     105             : # define DL_ERROR                                       dlerror
     106             : # define DL_HANDLE                                      void *
     107             : # define ZEND_EXTENSIONS_SUPPORT        1
     108             : #elif defined(ZEND_WIN32)
     109             : # define DL_LOAD(libname)                       LoadLibrary(libname)
     110             : # define DL_FETCH_SYMBOL                        GetProcAddress
     111             : # define DL_UNLOAD                                      FreeLibrary
     112             : # define DL_HANDLE                                      HMODULE
     113             : # define ZEND_EXTENSIONS_SUPPORT        1
     114             : #else
     115             : # define DL_HANDLE                                      void *
     116             : # define ZEND_EXTENSIONS_SUPPORT        0
     117             : #endif
     118             : 
     119             : #if HAVE_ALLOCA_H && !defined(_ALLOCA_H)
     120             : #  include <alloca.h>
     121             : #endif
     122             : 
     123             : /* AIX requires this to be the first thing in the file.  */
     124             : #ifndef __GNUC__
     125             : # ifndef HAVE_ALLOCA_H
     126             : #  ifdef _AIX
     127             : #pragma alloca
     128             : #  else
     129             : #   ifndef alloca /* predefined by HP cc +Olibcalls */
     130             : char *alloca ();
     131             : #   endif
     132             : #  endif
     133             : # endif
     134             : #endif
     135             : 
     136             : /* GCC x.y.z supplies __GNUC__ = x and __GNUC_MINOR__ = y */
     137             : #ifdef __GNUC__
     138             : # define ZEND_GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
     139             : #else
     140             : # define ZEND_GCC_VERSION 0
     141             : #endif
     142             : 
     143             : #if ZEND_GCC_VERSION >= 2096
     144             : # define ZEND_ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
     145             : #else
     146             : # define ZEND_ATTRIBUTE_MALLOC
     147             : #endif
     148             : 
     149             : #if ZEND_GCC_VERSION >= 2007
     150             : # define ZEND_ATTRIBUTE_FORMAT(type, idx, first) __attribute__ ((format(type, idx, first)))
     151             : #else
     152             : # define ZEND_ATTRIBUTE_FORMAT(type, idx, first)
     153             : #endif
     154             : 
     155             : #if ZEND_GCC_VERSION >= 3001 && !defined(__INTEL_COMPILER)
     156             : # define ZEND_ATTRIBUTE_PTR_FORMAT(type, idx, first) __attribute__ ((format(type, idx, first)))
     157             : #else
     158             : # define ZEND_ATTRIBUTE_PTR_FORMAT(type, idx, first)
     159             : #endif
     160             : 
     161             : #if ZEND_GCC_VERSION >= 3001
     162             : # define ZEND_ATTRIBUTE_DEPRECATED  __attribute__((deprecated))
     163             : #elif defined(ZEND_WIN32) && defined(_MSC_VER) && _MSC_VER >= 1300
     164             : # define ZEND_ATTRIBUTE_DEPRECATED  __declspec(deprecated)
     165             : #else
     166             : # define ZEND_ATTRIBUTE_DEPRECATED
     167             : #endif
     168             : 
     169             : #if defined(__GNUC__) && ZEND_GCC_VERSION >= 3004 && defined(__i386__)
     170             : # define ZEND_FASTCALL __attribute__((fastcall))
     171             : #elif defined(_MSC_VER) && defined(_M_IX86)
     172             : # define ZEND_FASTCALL __fastcall
     173             : #else
     174             : # define ZEND_FASTCALL
     175             : #endif
     176             : 
     177             : #if defined(__GNUC__) && ZEND_GCC_VERSION >= 3004
     178             : #else
     179             : # define __restrict__
     180             : #endif
     181             : #define restrict __restrict__
     182             : 
     183             : #if (HAVE_ALLOCA || (defined (__GNUC__) && __GNUC__ >= 2)) && !(defined(ZTS) && defined(ZEND_WIN32)) && !(defined(ZTS) && defined(NETWARE)) && !(defined(ZTS) && defined(HPUX)) && !defined(DARWIN)
     184             : # define ZEND_ALLOCA_MAX_SIZE (32 * 1024)
     185             : # define ALLOCA_FLAG(name) \
     186             :         zend_bool name;
     187             : # define SET_ALLOCA_FLAG(name) \
     188             :         name = 1
     189             : # define do_alloca_ex(size, limit, use_heap) \
     190             :         ((use_heap = (UNEXPECTED((size) > (limit)))) ? emalloc(size) : alloca(size))
     191             : # define do_alloca(size, use_heap) \
     192             :         do_alloca_ex(size, ZEND_ALLOCA_MAX_SIZE, use_heap)
     193             : # define free_alloca(p, use_heap) \
     194             :         do { if (UNEXPECTED(use_heap)) efree(p); } while (0)
     195             : #else
     196             : # define ALLOCA_FLAG(name)
     197             : # define SET_ALLOCA_FLAG(name)
     198             : # define do_alloca(p, use_heap)         emalloc(p)
     199             : # define free_alloca(p, use_heap)       efree(p)
     200             : #endif
     201             : 
     202             : #if ZEND_DEBUG
     203             : #define ZEND_FILE_LINE_D                                char *__zend_filename, uint __zend_lineno
     204             : #define ZEND_FILE_LINE_DC                               , ZEND_FILE_LINE_D
     205             : #define ZEND_FILE_LINE_ORIG_D                   char *__zend_orig_filename, uint __zend_orig_lineno
     206             : #define ZEND_FILE_LINE_ORIG_DC                  , ZEND_FILE_LINE_ORIG_D
     207             : #define ZEND_FILE_LINE_RELAY_C                  __zend_filename, __zend_lineno
     208             : #define ZEND_FILE_LINE_RELAY_CC                 , ZEND_FILE_LINE_RELAY_C
     209             : #define ZEND_FILE_LINE_C                                __FILE__, __LINE__
     210             : #define ZEND_FILE_LINE_CC                               , ZEND_FILE_LINE_C
     211             : #define ZEND_FILE_LINE_EMPTY_C                  NULL, 0
     212             : #define ZEND_FILE_LINE_EMPTY_CC                 , ZEND_FILE_LINE_EMPTY_C
     213             : #define ZEND_FILE_LINE_ORIG_RELAY_C             __zend_orig_filename, __zend_orig_lineno
     214             : #define ZEND_FILE_LINE_ORIG_RELAY_CC    , ZEND_FILE_LINE_ORIG_RELAY_C
     215             : #else
     216             : #define ZEND_FILE_LINE_D
     217             : #define ZEND_FILE_LINE_DC
     218             : #define ZEND_FILE_LINE_ORIG_D
     219             : #define ZEND_FILE_LINE_ORIG_DC
     220             : #define ZEND_FILE_LINE_RELAY_C
     221             : #define ZEND_FILE_LINE_RELAY_CC
     222             : #define ZEND_FILE_LINE_C
     223             : #define ZEND_FILE_LINE_CC
     224             : #define ZEND_FILE_LINE_EMPTY_C
     225             : #define ZEND_FILE_LINE_EMPTY_CC
     226             : #define ZEND_FILE_LINE_ORIG_RELAY_C
     227             : #define ZEND_FILE_LINE_ORIG_RELAY_CC
     228             : #endif  /* ZEND_DEBUG */
     229             : 
     230             : #ifdef ZTS
     231             : #define ZTS_V 1
     232             : #else
     233             : #define ZTS_V 0
     234             : #endif
     235             : 
     236             : #include "zend_errors.h"
     237             : #include "zend_alloc.h"
     238             : 
     239             : #include "zend_types.h"
     240             : 
     241             : #ifdef HAVE_LIMITS_H
     242             : # include <limits.h>
     243             : #endif
     244             : 
     245             : #ifndef LONG_MAX
     246             : #define LONG_MAX 2147483647L
     247             : #endif
     248             : 
     249             : #ifndef LONG_MIN
     250             : #define LONG_MIN (- LONG_MAX - 1)
     251             : #endif
     252             : 
     253             : #if SIZEOF_LONG == 4
     254             : #define MAX_LENGTH_OF_LONG 11
     255             : static const char long_min_digits[] = "2147483648";
     256             : #elif SIZEOF_LONG == 8
     257             : #define MAX_LENGTH_OF_LONG 20
     258             : static const char long_min_digits[] = "9223372036854775808";
     259             : #else
     260             : #error "Unknown SIZEOF_LONG"
     261             : #endif
     262             : 
     263             : #define MAX_LENGTH_OF_DOUBLE 32
     264             : 
     265             : #undef SUCCESS
     266             : #undef FAILURE
     267             : #define SUCCESS 0
     268             : #define FAILURE -1                              /* this MUST stay a negative number, or it may affect functions! */
     269             : 
     270             : #include "zend_hash.h"
     271             : #include "zend_ts_hash.h"
     272             : #include "zend_llist.h"
     273             : 
     274             : #define INTERNAL_FUNCTION_PARAMETERS int ht, zval *return_value, zval **return_value_ptr, zval *this_ptr, int return_value_used TSRMLS_DC
     275             : #define INTERNAL_FUNCTION_PARAM_PASSTHRU ht, return_value, return_value_ptr, this_ptr, return_value_used TSRMLS_CC
     276             : 
     277             : #if defined(__GNUC__) && __GNUC__ >= 3 && !defined(__INTEL_COMPILER) && !defined(DARWIN) && !defined(__hpux) && !defined(_AIX) && !defined(__osf__)
     278             : void zend_error_noreturn(int type, const char *format, ...) __attribute__ ((noreturn));
     279             : #else
     280             : #  define zend_error_noreturn zend_error
     281             : #endif
     282             : 
     283             : /*
     284             :  * zval
     285             :  */
     286             : typedef struct _zval_struct zval;
     287             : typedef struct _zend_class_entry zend_class_entry;
     288             : 
     289             : typedef struct _zend_guard {
     290             :         zend_bool in_get;
     291             :         zend_bool in_set;
     292             :         zend_bool in_unset;
     293             :         zend_bool in_isset;
     294             :         zend_bool dummy; /* sizeof(zend_guard) must not be equal to sizeof(void*) */
     295             : } zend_guard;
     296             : 
     297             : typedef struct _zend_object {
     298             :         zend_class_entry *ce;
     299             :         HashTable *properties;
     300             :         HashTable *guards; /* protects from __get/__set ... recursion */
     301             : } zend_object;
     302             : 
     303             : #include "zend_object_handlers.h"
     304             : 
     305             : typedef union _zvalue_value {
     306             :         long lval;                                      /* long value */
     307             :         double dval;                            /* double value */
     308             :         struct {
     309             :                 char *val;
     310             :                 int len;
     311             :         } str;
     312             :         HashTable *ht;                          /* hash table value */
     313             :         zend_object_value obj;
     314             : } zvalue_value;
     315             : 
     316             : struct _zval_struct {
     317             :         /* Variable information */
     318             :         zvalue_value value;             /* value */
     319             :         zend_uint refcount__gc;
     320             :         zend_uchar type;        /* active type */
     321             :         zend_uchar is_ref__gc;
     322             : };
     323             : 
     324             : #define Z_REFCOUNT_PP(ppz)              Z_REFCOUNT_P(*(ppz))
     325             : #define Z_SET_REFCOUNT_PP(ppz, rc)      Z_SET_REFCOUNT_P(*(ppz), rc)
     326             : #define Z_ADDREF_PP(ppz)                Z_ADDREF_P(*(ppz))
     327             : #define Z_DELREF_PP(ppz)                Z_DELREF_P(*(ppz))
     328             : #define Z_ISREF_PP(ppz)                 Z_ISREF_P(*(ppz))
     329             : #define Z_SET_ISREF_PP(ppz)             Z_SET_ISREF_P(*(ppz))
     330             : #define Z_UNSET_ISREF_PP(ppz)           Z_UNSET_ISREF_P(*(ppz))
     331             : #define Z_SET_ISREF_TO_PP(ppz, isref)   Z_SET_ISREF_TO_P(*(ppz), isref)
     332             : 
     333             : #define Z_REFCOUNT_P(pz)                zval_refcount_p(pz)
     334             : #define Z_SET_REFCOUNT_P(pz, rc)        zval_set_refcount_p(pz, rc)
     335             : #define Z_ADDREF_P(pz)                  zval_addref_p(pz)
     336             : #define Z_DELREF_P(pz)                  zval_delref_p(pz)
     337             : #define Z_ISREF_P(pz)                   zval_isref_p(pz)
     338             : #define Z_SET_ISREF_P(pz)               zval_set_isref_p(pz)
     339             : #define Z_UNSET_ISREF_P(pz)             zval_unset_isref_p(pz)
     340             : #define Z_SET_ISREF_TO_P(pz, isref)     zval_set_isref_to_p(pz, isref)
     341             : 
     342             : #define Z_REFCOUNT(z)                   Z_REFCOUNT_P(&(z))
     343             : #define Z_SET_REFCOUNT(z, rc)           Z_SET_REFCOUNT_P(&(z), rc)
     344             : #define Z_ADDREF(z)                     Z_ADDREF_P(&(z))
     345             : #define Z_DELREF(z)                     Z_DELREF_P(&(z))
     346             : #define Z_ISREF(z)                      Z_ISREF_P(&(z))
     347             : #define Z_SET_ISREF(z)                  Z_SET_ISREF_P(&(z))
     348             : #define Z_UNSET_ISREF(z)                Z_UNSET_ISREF_P(&(z))
     349             : #define Z_SET_ISREF_TO(z, isref)        Z_SET_ISREF_TO_P(&(z), isref)
     350             : 
     351             : #if defined(__GNUC__)
     352             : #if __GNUC__ >= 3
     353             : #define zend_always_inline inline __attribute__((always_inline))
     354             : #else
     355             : #define zend_always_inline inline
     356             : #endif
     357             : 
     358             : #elif defined(_MSC_VER)
     359             : #define zend_always_inline __forceinline
     360             : #else
     361             : #define zend_always_inline inline
     362             : #endif
     363             : 
     364             : #if (defined (__GNUC__) && __GNUC__ > 2 ) && !defined(__INTEL_COMPILER) && !defined(DARWIN) && !defined(__hpux) && !defined(_AIX)
     365             : # define EXPECTED(condition)   __builtin_expect(condition, 1)
     366             : # define UNEXPECTED(condition) __builtin_expect(condition, 0)
     367             : #else
     368             : # define EXPECTED(condition)   (condition)
     369             : # define UNEXPECTED(condition) (condition)
     370             : #endif
     371             : 
     372             : static zend_always_inline zend_uint zval_refcount_p(zval* pz) {
     373   167270651 :         return pz->refcount__gc;
     374             : }
     375             : 
     376             : static zend_always_inline zend_uint zval_set_refcount_p(zval* pz, zend_uint rc) {
     377    36650591 :         return pz->refcount__gc = rc;
     378             : }
     379             : 
     380             : static zend_always_inline zend_uint zval_addref_p(zval* pz) {
     381    83255139 :         return ++pz->refcount__gc;
     382             : }
     383             : 
     384             : static zend_always_inline zend_uint zval_delref_p(zval* pz) {
     385   153323355 :         return --pz->refcount__gc;
     386             : }
     387             : 
     388             : static zend_always_inline zend_bool zval_isref_p(zval* pz) {
     389    97232695 :         return pz->is_ref__gc;
     390             : }
     391             : 
     392             : static zend_always_inline zend_bool zval_set_isref_p(zval* pz) {
     393     5733548 :         return pz->is_ref__gc = 1;
     394             : }
     395             : 
     396             : static zend_always_inline zend_bool zval_unset_isref_p(zval* pz) {
     397    69727483 :         return pz->is_ref__gc = 0;
     398             : }
     399             : 
     400             : static zend_always_inline zend_bool zval_set_isref_to_p(zval* pz, zend_bool isref) {
     401      400766 :         return pz->is_ref__gc = isref;
     402             : }
     403             : 
     404             : /* excpt.h on Digital Unix 4.0 defines function_table */
     405             : #undef function_table
     406             : 
     407             : /* A lot of stuff needs shifiting around in order to include zend_compile.h here */
     408             : union _zend_function;
     409             : 
     410             : #include "zend_iterators.h"
     411             : 
     412             : struct _zend_serialize_data;
     413             : struct _zend_unserialize_data;
     414             : 
     415             : typedef struct _zend_serialize_data zend_serialize_data;
     416             : typedef struct _zend_unserialize_data zend_unserialize_data;
     417             : 
     418             : struct _zend_class_entry {
     419             :         char type;
     420             :         char *name;
     421             :         zend_uint name_length;
     422             :         struct _zend_class_entry *parent;
     423             :         int refcount;
     424             :         zend_bool constants_updated;
     425             :         zend_uint ce_flags;
     426             : 
     427             :         HashTable function_table;
     428             :         HashTable default_properties;
     429             :         HashTable properties_info;
     430             :         HashTable default_static_members;
     431             :         HashTable *static_members;
     432             :         HashTable constants_table;
     433             :         const struct _zend_function_entry *builtin_functions;
     434             : 
     435             :         union _zend_function *constructor;
     436             :         union _zend_function *destructor;
     437             :         union _zend_function *clone;
     438             :         union _zend_function *__get;
     439             :         union _zend_function *__set;
     440             :         union _zend_function *__unset;
     441             :         union _zend_function *__isset;
     442             :         union _zend_function *__call;
     443             :         union _zend_function *__callstatic;
     444             :         union _zend_function *__tostring;
     445             :         union _zend_function *serialize_func;
     446             :         union _zend_function *unserialize_func;
     447             : 
     448             :         zend_class_iterator_funcs iterator_funcs;
     449             : 
     450             :         /* handlers */
     451             :         zend_object_value (*create_object)(zend_class_entry *class_type TSRMLS_DC);
     452             :         zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
     453             :         int (*interface_gets_implemented)(zend_class_entry *iface, zend_class_entry *class_type TSRMLS_DC); /* a class implements this interface */
     454             :         union _zend_function *(*get_static_method)(zend_class_entry *ce, char* method, int method_len TSRMLS_DC);
     455             : 
     456             :         /* serializer callbacks */
     457             :         int (*serialize)(zval *object, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC);
     458             :         int (*unserialize)(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC);
     459             : 
     460             :         zend_class_entry **interfaces;
     461             :         zend_uint num_interfaces;
     462             : 
     463             :         char *filename;
     464             :         zend_uint line_start;
     465             :         zend_uint line_end;
     466             :         char *doc_comment;
     467             :         zend_uint doc_comment_len;
     468             : 
     469             :         struct _zend_module_entry *module;
     470             : };
     471             : 
     472             : #include "zend_stream.h"
     473             : typedef struct _zend_utility_functions {
     474             :         void (*error_function)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0);
     475             :         int (*printf_function)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2);
     476             :         int (*write_function)(const char *str, uint str_length);
     477             :         FILE *(*fopen_function)(const char *filename, char **opened_path TSRMLS_DC);
     478             :         void (*message_handler)(long message, void *data TSRMLS_DC);
     479             :         void (*block_interruptions)(void);
     480             :         void (*unblock_interruptions)(void);
     481             :         int (*get_configuration_directive)(const char *name, uint name_length, zval *contents);
     482             :         void (*ticks_function)(int ticks);
     483             :         void (*on_timeout)(int seconds TSRMLS_DC);
     484             :         int (*stream_open_function)(const char *filename, zend_file_handle *handle TSRMLS_DC);
     485             :         int (*vspprintf_function)(char **pbuf, size_t max_len, const char *format, va_list ap);
     486             :         char *(*getenv_function)(char *name, size_t name_len TSRMLS_DC);
     487             :         char *(*resolve_path_function)(const char *filename, int filename_len TSRMLS_DC);
     488             : } zend_utility_functions;
     489             : 
     490             : typedef struct _zend_utility_values {
     491             :         char *import_use_extension;
     492             :         uint import_use_extension_length;
     493             :         zend_bool html_errors;
     494             : } zend_utility_values;
     495             : 
     496             : typedef int (*zend_write_func_t)(const char *str, uint str_length);
     497             : 
     498             : #undef MIN
     499             : #undef MAX
     500             : #define MAX(a, b)  (((a)>(b))?(a):(b))
     501             : #define MIN(a, b)  (((a)<(b))?(a):(b))
     502             : #define ZEND_STRL(str)          (str), (sizeof(str)-1)
     503             : #define ZEND_STRS(str)          (str), (sizeof(str))
     504             : #define ZEND_NORMALIZE_BOOL(n)                  \
     505             :         ((n) ? (((n)>0) ? 1 : -1) : 0)
     506             : #define ZEND_TRUTH(x)           ((x) ? 1 : 0)
     507             : #define ZEND_LOG_XOR(a, b)              (ZEND_TRUTH(a) ^ ZEND_TRUTH(b))
     508             : 
     509             : /* data types */
     510             : /* All data types <= IS_BOOL have their constructor/destructors skipped */
     511             : #define IS_NULL         0
     512             : #define IS_LONG         1
     513             : #define IS_DOUBLE       2
     514             : #define IS_BOOL         3
     515             : #define IS_ARRAY        4
     516             : #define IS_OBJECT       5
     517             : #define IS_STRING       6
     518             : #define IS_RESOURCE     7
     519             : #define IS_CONSTANT     8
     520             : #define IS_CONSTANT_ARRAY       9
     521             : 
     522             : /* Ugly hack to support constants as static array indices */
     523             : #define IS_CONSTANT_TYPE_MASK   0x0f
     524             : #define IS_CONSTANT_UNQUALIFIED 0x10
     525             : #define IS_CONSTANT_INDEX               0x80
     526             : #define IS_LEXICAL_VAR                  0x20
     527             : #define IS_LEXICAL_REF                  0x40
     528             : 
     529             : /* overloaded elements data types */
     530             : #define OE_IS_ARRAY             (1<<0)
     531             : #define OE_IS_OBJECT    (1<<1)
     532             : #define OE_IS_METHOD    (1<<2)
     533             : 
     534             : int zend_startup(zend_utility_functions *utility_functions, char **extensions TSRMLS_DC);
     535             : void zend_shutdown(TSRMLS_D);
     536             : void zend_register_standard_ini_entries(TSRMLS_D);
     537             : void zend_post_startup(TSRMLS_D);
     538             : void zend_set_utility_values(zend_utility_values *utility_values);
     539             : 
     540             : BEGIN_EXTERN_C()
     541             : ZEND_API void _zend_bailout(char *filename, uint lineno);
     542             : END_EXTERN_C()
     543             : 
     544             : #define zend_bailout()          _zend_bailout(__FILE__, __LINE__)
     545             : 
     546             : #ifdef HAVE_SIGSETJMP
     547             : #       define SETJMP(a) sigsetjmp(a, 0)
     548             : #       define LONGJMP(a,b) siglongjmp(a, b)
     549             : #       define JMP_BUF sigjmp_buf
     550             : #else
     551             : #       define SETJMP(a) setjmp(a)
     552             : #       define LONGJMP(a,b) longjmp(a, b)
     553             : #       define JMP_BUF jmp_buf
     554             : #endif
     555             : 
     556             : #define zend_try                                                                                                \
     557             :         {                                                                                                                       \
     558             :                 JMP_BUF *__orig_bailout = EG(bailout);                                  \
     559             :                 JMP_BUF __bailout;                                                                              \
     560             :                                                                                                                                 \
     561             :                 EG(bailout) = &__bailout;                                                           \
     562             :                 if (SETJMP(__bailout)==0) {
     563             : #define zend_catch                                                                                              \
     564             :                 } else {                                                                                                \
     565             :                         EG(bailout) = __orig_bailout;
     566             : #define zend_end_try()                                                                                  \
     567             :                 }                                                                                                               \
     568             :                 EG(bailout) = __orig_bailout;                                                   \
     569             :         }
     570             : #define zend_first_try          EG(bailout)=NULL;       zend_try
     571             : 
     572             : BEGIN_EXTERN_C()
     573             : ZEND_API char *get_zend_version(void);
     574             : ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy);
     575             : ZEND_API int zend_print_zval(zval *expr, int indent);
     576             : ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent);
     577             : ZEND_API void zend_print_zval_r(zval *expr, int indent TSRMLS_DC);
     578             : ZEND_API void zend_print_flat_zval_r(zval *expr TSRMLS_DC);
     579             : ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC);
     580             : ZEND_API void zend_output_debug_string(zend_bool trigger_break, const char *format, ...) ZEND_ATTRIBUTE_FORMAT(printf, 2, 3);
     581             : END_EXTERN_C()
     582             : 
     583             : void zend_activate(TSRMLS_D);
     584             : void zend_deactivate(TSRMLS_D);
     585             : void zend_call_destructors(TSRMLS_D);
     586             : void zend_activate_modules(TSRMLS_D);
     587             : void zend_deactivate_modules(TSRMLS_D);
     588             : void zend_post_deactivate_modules(TSRMLS_D);
     589             : 
     590             : #if ZEND_DEBUG
     591             : #define Z_DBG(expr)             (expr)
     592             : #else
     593             : #define Z_DBG(expr)
     594             : #endif
     595             : 
     596             : BEGIN_EXTERN_C()
     597             : ZEND_API void free_estring(char **str_p);
     598             : END_EXTERN_C()
     599             : 
     600             : /* FIXME: Check if we can save if (ptr) too */
     601             : 
     602             : #define STR_FREE(ptr) if (ptr) { efree(ptr); }
     603             : #define STR_FREE_REL(ptr) if (ptr) { efree_rel(ptr); }
     604             : 
     605             : #define STR_EMPTY_ALLOC() estrndup("", sizeof("")-1)
     606             : 
     607             : #define STR_REALLOC(ptr, size) \
     608             :                         ptr = (char *) erealloc(ptr, size);
     609             : 
     610             : /* output support */
     611             : #define ZEND_WRITE(str, str_len)                zend_write((str), (str_len))
     612             : #define ZEND_WRITE_EX(str, str_len)             write_func((str), (str_len))
     613             : #define ZEND_PUTS(str)                                  zend_write((str), strlen((str)))
     614             : #define ZEND_PUTS_EX(str)                               write_func((str), strlen((str)))
     615             : #define ZEND_PUTC(c)                                    zend_write(&(c), 1), (c)
     616             : 
     617             : BEGIN_EXTERN_C()
     618             : extern ZEND_API int (*zend_printf)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2);
     619             : extern ZEND_API zend_write_func_t zend_write;
     620             : extern ZEND_API FILE *(*zend_fopen)(const char *filename, char **opened_path TSRMLS_DC);
     621             : extern ZEND_API void (*zend_block_interruptions)(void);
     622             : extern ZEND_API void (*zend_unblock_interruptions)(void);
     623             : extern ZEND_API void (*zend_ticks_function)(int ticks);
     624             : extern ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0);
     625             : extern void (*zend_on_timeout)(int seconds TSRMLS_DC);
     626             : extern ZEND_API int (*zend_stream_open_function)(const char *filename, zend_file_handle *handle TSRMLS_DC);
     627             : extern int (*zend_vspprintf)(char **pbuf, size_t max_len, const char *format, va_list ap);
     628             : extern ZEND_API char *(*zend_getenv)(char *name, size_t name_len TSRMLS_DC);
     629             : extern ZEND_API char *(*zend_resolve_path)(const char *filename, int filename_len TSRMLS_DC);
     630             : 
     631             : ZEND_API void zend_error(int type, const char *format, ...) ZEND_ATTRIBUTE_FORMAT(printf, 2, 3);
     632             : 
     633             : void zenderror(const char *error);
     634             : 
     635             : /* The following #define is used for code duality in PHP for Engine 1 & 2 */
     636             : #define ZEND_STANDARD_CLASS_DEF_PTR zend_standard_class_def
     637             : extern ZEND_API zend_class_entry *zend_standard_class_def;
     638             : extern ZEND_API zend_utility_values zend_uv;
     639             : extern ZEND_API zval zval_used_for_init;
     640             : 
     641             : END_EXTERN_C()
     642             : 
     643             : #define ZEND_UV(name) (zend_uv.name)
     644             : 
     645             : #define HANDLE_BLOCK_INTERRUPTIONS()            if (zend_block_interruptions) { zend_block_interruptions(); }
     646             : #define HANDLE_UNBLOCK_INTERRUPTIONS()          if (zend_unblock_interruptions) { zend_unblock_interruptions(); }
     647             : 
     648             : BEGIN_EXTERN_C()
     649             : ZEND_API void zend_message_dispatcher(long message, void *data TSRMLS_DC);
     650             : 
     651             : ZEND_API int zend_get_configuration_directive(const char *name, uint name_length, zval *contents);
     652             : END_EXTERN_C()
     653             : 
     654             : /* Messages for applications of Zend */
     655             : #define ZMSG_FAILED_INCLUDE_FOPEN               1L
     656             : #define ZMSG_FAILED_REQUIRE_FOPEN               2L
     657             : #define ZMSG_FAILED_HIGHLIGHT_FOPEN             3L
     658             : #define ZMSG_MEMORY_LEAK_DETECTED               4L
     659             : #define ZMSG_MEMORY_LEAK_REPEATED               5L
     660             : #define ZMSG_LOG_SCRIPT_NAME                    6L
     661             : #define ZMSG_MEMORY_LEAKS_GRAND_TOTAL   7L
     662             : 
     663             : #define INIT_PZVAL(z)           \
     664             :         (z)->refcount__gc = 1;       \
     665             :         (z)->is_ref__gc = 0;
     666             : 
     667             : #define INIT_ZVAL(z) z = zval_used_for_init;
     668             : 
     669             : #define ALLOC_INIT_ZVAL(zp)                                             \
     670             :         ALLOC_ZVAL(zp);         \
     671             :         INIT_ZVAL(*zp);
     672             : 
     673             : #define MAKE_STD_ZVAL(zv)                                \
     674             :         ALLOC_ZVAL(zv); \
     675             :         INIT_PZVAL(zv);
     676             : 
     677             : #define PZVAL_IS_REF(z)         Z_ISREF_P(z)
     678             : 
     679             : #define SEPARATE_ZVAL(ppzv)                                                                     \
     680             :         {                                                                                                               \
     681             :                 zval *orig_ptr = *(ppzv);                                                       \
     682             :                                                                                                                         \
     683             :                 if (Z_REFCOUNT_P(orig_ptr) > 1) {                                    \
     684             :                         Z_DELREF_P(orig_ptr);                                                   \
     685             :                         ALLOC_ZVAL(*(ppzv));                                                    \
     686             :                         **(ppzv) = *orig_ptr;                                                   \
     687             :                         zval_copy_ctor(*(ppzv));                                                \
     688             :                         Z_SET_REFCOUNT_PP(ppzv, 1);                                             \
     689             :                         Z_UNSET_ISREF_PP((ppzv));                                               \
     690             :                 }                                                                                                       \
     691             :         }
     692             : 
     693             : #define SEPARATE_ZVAL_IF_NOT_REF(ppzv)          \
     694             :         if (!PZVAL_IS_REF(*ppzv)) {                             \
     695             :                 SEPARATE_ZVAL(ppzv);                            \
     696             :         }
     697             : 
     698             : #define SEPARATE_ZVAL_TO_MAKE_IS_REF(ppzv)      \
     699             :         if (!PZVAL_IS_REF(*ppzv)) {                             \
     700             :                 SEPARATE_ZVAL(ppzv);                            \
     701             :                 Z_SET_ISREF_PP((ppzv));                         \
     702             :         }
     703             : 
     704             : #define COPY_PZVAL_TO_ZVAL(zv, pzv)                     \
     705             :         (zv) = *(pzv);                                                  \
     706             :         if (Z_REFCOUNT_P(pzv)>1) {                           \
     707             :                 zval_copy_ctor(&(zv));                              \
     708             :                 Z_DELREF_P((pzv));                                      \
     709             :         } else {                                                                \
     710             :                 FREE_ZVAL(pzv);                                         \
     711             :         }                                                                               \
     712             :         INIT_PZVAL(&(zv));
     713             :         
     714             : #define MAKE_COPY_ZVAL(ppzv, pzv) \
     715             :         *(pzv) = **(ppzv);            \
     716             :         zval_copy_ctor((pzv));        \
     717             :         INIT_PZVAL((pzv));
     718             : 
     719             : #define REPLACE_ZVAL_VALUE(ppzv_dest, pzv_src, copy) {  \
     720             :         int is_ref, refcount;                                           \
     721             :                                                                                                 \
     722             :         SEPARATE_ZVAL_IF_NOT_REF(ppzv_dest);            \
     723             :         is_ref = Z_ISREF_PP(ppzv_dest);                         \
     724             :         refcount = Z_REFCOUNT_PP(ppzv_dest);            \
     725             :         zval_dtor(*ppzv_dest);                                          \
     726             :         **ppzv_dest = *pzv_src;                                         \
     727             :         if (copy) {                                 \
     728             :                 zval_copy_ctor(*ppzv_dest);                             \
     729             :     }                                               \
     730             :         Z_SET_ISREF_TO_PP(ppzv_dest, is_ref);           \
     731             :         Z_SET_REFCOUNT_PP(ppzv_dest, refcount);         \
     732             : }
     733             : 
     734             : #define SEPARATE_ARG_IF_REF(varptr) \
     735             :         if (PZVAL_IS_REF(varptr)) { \
     736             :                 zval *original_var = varptr; \
     737             :                 ALLOC_ZVAL(varptr); \
     738             :                 varptr->value = original_var->value; \
     739             :                 Z_TYPE_P(varptr) = Z_TYPE_P(original_var); \
     740             :                 Z_UNSET_ISREF_P(varptr); \
     741             :                 Z_SET_REFCOUNT_P(varptr, 1); \
     742             :                 zval_copy_ctor(varptr); \
     743             :         } else { \
     744             :                 Z_ADDREF_P(varptr); \
     745             :         }
     746             : 
     747             : #define READY_TO_DESTROY(zv) \
     748             :         (Z_REFCOUNT_P(zv) == 1 && \
     749             :          (Z_TYPE_P(zv) != IS_OBJECT || \
     750             :           zend_objects_store_get_refcount(zv TSRMLS_CC) == 1))
     751             : 
     752             : #define ZEND_MAX_RESERVED_RESOURCES     4
     753             : 
     754             : #include "zend_gc.h"
     755             : #include "zend_operators.h"
     756             : #include "zend_variables.h"
     757             : 
     758             : typedef enum {
     759             :         EH_NORMAL = 0,
     760             :         EH_SUPPRESS,
     761             :         EH_THROW
     762             : } zend_error_handling_t;
     763             : 
     764             : typedef struct {
     765             :         zend_error_handling_t  handling;
     766             :         zend_class_entry       *exception;
     767             :         zval                   *user_handler;
     768             : } zend_error_handling;
     769             : 
     770             : ZEND_API void zend_save_error_handling(zend_error_handling *current TSRMLS_DC);
     771             : ZEND_API void zend_replace_error_handling(zend_error_handling_t error_handling, zend_class_entry *exception_class, zend_error_handling *current TSRMLS_DC);
     772             : ZEND_API void zend_restore_error_handling(zend_error_handling *saved TSRMLS_DC);
     773             : 
     774             : #define DEBUG_BACKTRACE_PROVIDE_OBJECT (1<<0)
     775             : #define DEBUG_BACKTRACE_IGNORE_ARGS    (1<<1)
     776             : 
     777             : #endif /* ZEND_H */
     778             : 
     779             : /*
     780             :  * Local variables:
     781             :  * tab-width: 4
     782             :  * c-basic-offset: 4
     783             :  * indent-tabs-mode: t
     784             :  * End:
     785             :  */

Generated by: LCOV version 1.10

Generated at Wed, 23 Jul 2014 19:58:28 +0000 (17 hours ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.