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_operators.h (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 82 88 93.2 %
Date: 2014-07-27 Functions: 3 3 100.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_OPERATORS_H
      23             : #define ZEND_OPERATORS_H
      24             : 
      25             : #include <errno.h>
      26             : #include <math.h>
      27             : #include <assert.h>
      28             : 
      29             : #ifdef HAVE_IEEEFP_H
      30             : #include <ieeefp.h>
      31             : #endif
      32             : 
      33             : #include "zend_strtod.h"
      34             : 
      35             : #if 0&&HAVE_BCMATH
      36             : #include "ext/bcmath/libbcmath/src/bcmath.h"
      37             : #endif
      38             : 
      39             : BEGIN_EXTERN_C()
      40             : ZEND_API int add_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      41             : ZEND_API int sub_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      42             : ZEND_API int mul_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      43             : ZEND_API int div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      44             : ZEND_API int mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      45             : ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      46             : ZEND_API int boolean_not_function(zval *result, zval *op1 TSRMLS_DC);
      47             : ZEND_API int bitwise_not_function(zval *result, zval *op1 TSRMLS_DC);
      48             : ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      49             : ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      50             : ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      51             : ZEND_API int shift_left_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      52             : ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      53             : ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      54             : 
      55             : ZEND_API int is_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      56             : ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      57             : ZEND_API int is_not_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      58             : ZEND_API int is_not_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      59             : ZEND_API int is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      60             : ZEND_API int is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
      61             : 
      62             : ZEND_API zend_bool instanceof_function_ex(const zend_class_entry *instance_ce, const zend_class_entry *ce, zend_bool interfaces_only TSRMLS_DC);
      63             : ZEND_API zend_bool instanceof_function(const zend_class_entry *instance_ce, const zend_class_entry *ce TSRMLS_DC);
      64             : END_EXTERN_C()
      65             : 
      66             : #if ZEND_DVAL_TO_LVAL_CAST_OK
      67             : # define zend_dval_to_lval(d) ((long) (d))
      68             : #elif SIZEOF_LONG == 4 && defined(HAVE_ZEND_LONG64)
      69             : static zend_always_inline long zend_dval_to_lval(double d)
      70             : {
      71             :         if (d > LONG_MAX || d < LONG_MIN) {
      72             :                 return (long)(unsigned long)(zend_long64) d;
      73             :         }
      74             :         return (long) d;
      75             : }
      76             : #else
      77             : static zend_always_inline long zend_dval_to_lval(double d)
      78             : {
      79        6584 :         if (d > LONG_MAX) {
      80          17 :                 return (long)(unsigned long) d;
      81             :         }
      82        6567 :         return (long) d;
      83             : }
      84             : #endif
      85             : /* }}} */
      86             : 
      87             : #define ZEND_IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
      88             : #define ZEND_IS_XDIGIT(c) (((c) >= 'A' && (c) <= 'F') || ((c) >= 'a' && (c) <= 'f'))
      89             : 
      90             : /**
      91             :  * Checks whether the string "str" with length "length" is numeric. The value
      92             :  * of allow_errors determines whether it's required to be entirely numeric, or
      93             :  * just its prefix. Leading whitespace is allowed.
      94             :  *
      95             :  * The function returns 0 if the string did not contain a valid number; IS_LONG
      96             :  * if it contained a number that fits within the range of a long; or IS_DOUBLE
      97             :  * if the number was out of long range or contained a decimal point/exponent.
      98             :  * The number's value is returned into the respective pointer, *lval or *dval,
      99             :  * if that pointer is not NULL.
     100             :  */
     101             : 
     102     2201105 : static inline zend_uchar is_numeric_string(const char *str, int length, long *lval, double *dval, int allow_errors)
     103             : {
     104             :         const char *ptr;
     105     2201105 :         int base = 10, digits = 0, dp_or_e = 0;
     106             :         double local_dval;
     107             :         zend_uchar type;
     108             : 
     109     2201105 :         if (!length) {
     110        1524 :                 return 0;
     111             :         }
     112             : 
     113             :         /* Skip any whitespace
     114             :          * This is much faster than the isspace() function */
     115     4400938 :         while (*str == ' ' || *str == '\t' || *str == '\n' || *str == '\r' || *str == '\v' || *str == '\f') {
     116        1776 :                 str++;
     117        1776 :                 length--;
     118             :         }
     119     2199581 :         ptr = str;
     120             : 
     121     2199581 :         if (*ptr == '-' || *ptr == '+') {
     122        2707 :                 ptr++;
     123             :         }
     124             : 
     125     2749390 :         if (ZEND_IS_DIGIT(*ptr)) {
     126             :                 /* Handle hex numbers
     127             :                  * str is used instead of ptr to disallow signs and keep old behavior */
     128      754263 :                 if (length > 2 && *str == '0' && (str[1] == 'x' || str[1] == 'X')) {
     129         235 :                         base = 16;
     130         235 :                         ptr += 2;
     131             :                 }
     132             : 
     133             :                 /* Skip any leading 0s */
     134     1725489 :                 while (*ptr == '0') {
     135      216963 :                         ptr++;
     136             :                 }
     137             : 
     138             :                 /* Count the number of digits. If a decimal point/exponent is found,
     139             :                  * it's a double. Otherwise, if there's a dval or no need to check for
     140             :                  * a full match, stop when there are too many digits for a long */
     141    10847590 :                 for (type = IS_LONG; !(digits >= MAX_LENGTH_OF_LONG && (dval || allow_errors == 1)); digits++, ptr++) {
     142             : check_digits:
     143     5422375 :                         if (ZEND_IS_DIGIT(*ptr) || (base == 16 && ZEND_IS_XDIGIT(*ptr))) {
     144     4669532 :                                 continue;
     145      752843 :                         } else if (base == 10) {
     146      752608 :                                 if (*ptr == '.' && dp_or_e < 1) {
     147             :                                         goto process_double;
     148      549831 :                                 } else if ((*ptr == 'e' || *ptr == 'E') && dp_or_e < 2) {
     149         260 :                                         const char *e = ptr + 1;
     150             : 
     151         260 :                                         if (*e == '-' || *e == '+') {
     152           8 :                                                 ptr = e++;
     153             :                                         }
     154         260 :                                         if (ZEND_IS_DIGIT(*e)) {
     155         255 :                                                 goto process_double;
     156             :                                         }
     157             :                                 }
     158             :                         }
     159             : 
     160      549811 :                         break;
     161             :                 }
     162             : 
     163      551243 :                 if (base == 10) {
     164      551008 :                         if (digits >= MAX_LENGTH_OF_LONG) {
     165        1434 :                                 dp_or_e = -1;
     166        1434 :                                 goto process_double;
     167             :                         }
     168         235 :                 } else if (!(digits < SIZEOF_LONG * 2 || (digits == SIZEOF_LONG * 2 && ptr[-digits] <= '7'))) {
     169           0 :                         if (dval) {
     170           0 :                                 local_dval = zend_hex_strtod(str, (char **)&ptr);
     171             :                         }
     172           0 :                         type = IS_DOUBLE;
     173             :                 }
     174     1650024 :         } else if (*ptr == '.' && ZEND_IS_DIGIT(ptr[1])) {
     175             : process_double:
     176      204718 :                 type = IS_DOUBLE;
     177             : 
     178             :                 /* If there's a dval, do the conversion; else continue checking
     179             :                  * the digits if we need to check for a full match */
     180      204718 :                 if (dval) {
     181      204704 :                         local_dval = zend_strtod(str, (char **)&ptr);
     182          14 :                 } else if (allow_errors != 1 && dp_or_e != -1) {
     183          12 :                         dp_or_e = (*ptr++ == '.') ? 1 : 2;
     184          12 :                         goto check_digits;
     185             :                 }
     186             :         } else {
     187     1445066 :                 return 0;
     188             :         }
     189             : 
     190      754515 :         if (ptr != str + length) {
     191        1828 :                 if (!allow_errors) {
     192         992 :                         return 0;
     193             :                 }
     194         836 :                 if (allow_errors == -1) {
     195          61 :                         zend_error(E_NOTICE, "A non well formed numeric value encountered");
     196             :                 }
     197             :         }
     198             : 
     199      753523 :         if (type == IS_LONG) {
     200      549420 :                 if (digits == MAX_LENGTH_OF_LONG - 1) {
     201         177 :                         int cmp = strcmp(&ptr[-digits], long_min_digits);
     202             : 
     203         177 :                         if (!(cmp < 0 || (cmp == 0 && *str == '-'))) {
     204           0 :                                 if (dval) {
     205           0 :                                         *dval = zend_strtod(str, NULL);
     206             :                                 }
     207             : 
     208           0 :                                 return IS_DOUBLE;
     209             :                         }
     210             :                 }
     211             : 
     212      549420 :                 if (lval) {
     213      549364 :                         *lval = strtol(str, NULL, base);
     214             :                 }
     215             : 
     216      549420 :                 return IS_LONG;
     217             :         } else {
     218      204103 :                 if (dval) {
     219      204092 :                         *dval = local_dval;
     220             :                 }
     221             : 
     222      204103 :                 return IS_DOUBLE;
     223             :         }
     224             : }
     225             : 
     226             : static inline char *
     227     2422830 : zend_memnstr(char *haystack, char *needle, int needle_len, char *end)
     228             : {
     229     2422830 :         char *p = haystack;
     230     2422830 :         char ne = needle[needle_len-1];
     231             : 
     232     2422830 :         if (needle_len == 1) {
     233     1614286 :                 return (char *)memchr(p, *needle, (end-p));
     234             :         }
     235             : 
     236      808544 :         if (needle_len > end-haystack) {
     237       54548 :                 return NULL;
     238             :         }
     239             : 
     240      753996 :         end -= needle_len;
     241             : 
     242     4588407 :         while (p <= end) {
     243     3765468 :                 if ((p = (char *)memchr(p, *needle, (end-p+1))) && ne == p[needle_len-1]) {
     244      551441 :                         if (!memcmp(needle, p, needle_len-1)) {
     245      176754 :                                 return p;
     246             :                         }
     247             :                 }
     248             : 
     249     3588714 :                 if (p == NULL) {
     250      508299 :                         return NULL;
     251             :                 }
     252             : 
     253     3080415 :                 p++;
     254             :         }
     255             : 
     256       68943 :         return NULL;
     257             : }
     258             : 
     259     3304451 : static inline void *zend_memrchr(const void *s, int c, size_t n)
     260             : {
     261             :         register unsigned char *e;
     262             : 
     263     3304451 :         if (n <= 0) {
     264         419 :                 return NULL;
     265             :         }
     266             : 
     267    41979019 :         for (e = (unsigned char *)s + n - 1; e >= (unsigned char *)s; e--) {
     268    38698798 :                 if (*e == (unsigned char)c) {
     269       23811 :                         return (void *)e;
     270             :                 }
     271             :         }
     272             : 
     273     3280221 :         return NULL;
     274             : }
     275             : 
     276             : BEGIN_EXTERN_C()
     277             : ZEND_API int increment_function(zval *op1);
     278             : ZEND_API int decrement_function(zval *op2);
     279             : 
     280             : ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC);
     281             : ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC);
     282             : ZEND_API void convert_to_long(zval *op);
     283             : ZEND_API void convert_to_double(zval *op);
     284             : ZEND_API void convert_to_long_base(zval *op, int base);
     285             : ZEND_API void convert_to_null(zval *op);
     286             : ZEND_API void convert_to_boolean(zval *op);
     287             : ZEND_API void convert_to_array(zval *op);
     288             : ZEND_API void convert_to_object(zval *op);
     289             : ZEND_API void multi_convert_to_long_ex(int argc, ...);
     290             : ZEND_API void multi_convert_to_double_ex(int argc, ...);
     291             : ZEND_API void multi_convert_to_string_ex(int argc, ...);
     292             : ZEND_API int add_char_to_string(zval *result, const zval *op1, const zval *op2);
     293             : ZEND_API int add_string_to_string(zval *result, const zval *op1, const zval *op2);
     294             : #define convert_to_string(op) if ((op)->type != IS_STRING) { _convert_to_string((op) ZEND_FILE_LINE_CC); }
     295             : 
     296             : ZEND_API double zend_string_to_double(const char *number, zend_uint length);
     297             : 
     298             : ZEND_API int zval_is_true(zval *op);
     299             : ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
     300             : ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
     301             : ZEND_API int string_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
     302             : #if HAVE_STRCOLL
     303             : ZEND_API int string_locale_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
     304             : #endif
     305             : 
     306             : ZEND_API void zend_str_tolower(char *str, unsigned int length);
     307             : ZEND_API char *zend_str_tolower_copy(char *dest, const char *source, unsigned int length);
     308             : ZEND_API char *zend_str_tolower_dup(const char *source, unsigned int length);
     309             : 
     310             : ZEND_API int zend_binary_zval_strcmp(zval *s1, zval *s2);
     311             : ZEND_API int zend_binary_zval_strncmp(zval *s1, zval *s2, zval *s3);
     312             : ZEND_API int zend_binary_zval_strcasecmp(zval *s1, zval *s2);
     313             : ZEND_API int zend_binary_zval_strncasecmp(zval *s1, zval *s2, zval *s3);
     314             : ZEND_API int zend_binary_strcmp(const char *s1, uint len1, const char *s2, uint len2);
     315             : ZEND_API int zend_binary_strncmp(const char *s1, uint len1, const char *s2, uint len2, uint length);
     316             : ZEND_API int zend_binary_strcasecmp(const char *s1, uint len1, const char *s2, uint len2);
     317             : ZEND_API int zend_binary_strncasecmp(const char *s1, uint len1, const char *s2, uint len2, uint length);
     318             : 
     319             : ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2);
     320             : ZEND_API void zend_compare_symbol_tables(zval *result, HashTable *ht1, HashTable *ht2 TSRMLS_DC);
     321             : ZEND_API void zend_compare_arrays(zval *result, zval *a1, zval *a2 TSRMLS_DC);
     322             : ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2 TSRMLS_DC);
     323             : 
     324             : ZEND_API int zend_atoi(const char *str, int str_len);
     325             : ZEND_API long zend_atol(const char *str, int str_len);
     326             : 
     327             : ZEND_API void zend_locale_sprintf_double(zval *op ZEND_FILE_LINE_DC);
     328             : END_EXTERN_C()
     329             : 
     330             : #define convert_to_ex_master(ppzv, lower_type, upper_type)      \
     331             :         if (Z_TYPE_PP(ppzv)!=IS_##upper_type) {                                 \
     332             :                 SEPARATE_ZVAL_IF_NOT_REF(ppzv);                                         \
     333             :                 convert_to_##lower_type(*ppzv);                                         \
     334             :         }
     335             : 
     336             : #define convert_to_explicit_type(pzv, type)             \
     337             :         do {                                                                            \
     338             :                 switch (type) {                                                 \
     339             :                         case IS_NULL:                                           \
     340             :                                 convert_to_null(pzv);                   \
     341             :                                 break;                                                  \
     342             :                         case IS_LONG:                                           \
     343             :                                 convert_to_long(pzv);                   \
     344             :                                 break;                                                  \
     345             :                         case IS_DOUBLE:                                         \
     346             :                                 convert_to_double(pzv);                 \
     347             :                                 break;                                                  \
     348             :                         case IS_BOOL:                                           \
     349             :                                 convert_to_boolean(pzv);                \
     350             :                                 break;                                                  \
     351             :                         case IS_ARRAY:                                          \
     352             :                                 convert_to_array(pzv);                  \
     353             :                                 break;                                                  \
     354             :                         case IS_OBJECT:                                         \
     355             :                                 convert_to_object(pzv);                 \
     356             :                                 break;                                                  \
     357             :                         case IS_STRING:                                         \
     358             :                                 convert_to_string(pzv);                 \
     359             :                                 break;                                                  \
     360             :                         default:                                                        \
     361             :                                 assert(0);                                              \
     362             :                                 break;                                                  \
     363             :                 }                                                                               \
     364             :         } while (0);
     365             : 
     366             : #define convert_to_explicit_type_ex(ppzv, str_type)     \
     367             :         if (Z_TYPE_PP(ppzv) != str_type) {                              \
     368             :                 SEPARATE_ZVAL_IF_NOT_REF(ppzv);                         \
     369             :                 convert_to_explicit_type(*ppzv, str_type);      \
     370             :         }
     371             : 
     372             : #define convert_to_boolean_ex(ppzv)     convert_to_ex_master(ppzv, boolean, BOOL)
     373             : #define convert_to_long_ex(ppzv)        convert_to_ex_master(ppzv, long, LONG)
     374             : #define convert_to_double_ex(ppzv)      convert_to_ex_master(ppzv, double, DOUBLE)
     375             : #define convert_to_string_ex(ppzv)      convert_to_ex_master(ppzv, string, STRING)
     376             : #define convert_to_array_ex(ppzv)       convert_to_ex_master(ppzv, array, ARRAY)
     377             : #define convert_to_object_ex(ppzv)      convert_to_ex_master(ppzv, object, OBJECT)
     378             : #define convert_to_null_ex(ppzv)        convert_to_ex_master(ppzv, null, NULL)
     379             : 
     380             : #define convert_scalar_to_number_ex(ppzv)                                                       \
     381             :         if (Z_TYPE_PP(ppzv)!=IS_LONG && Z_TYPE_PP(ppzv)!=IS_DOUBLE) {   \
     382             :                 if (!Z_ISREF_PP(ppzv)) {                                                                        \
     383             :                         SEPARATE_ZVAL(ppzv);                                                                    \
     384             :                 }                                                                                                                       \
     385             :                 convert_scalar_to_number(*ppzv TSRMLS_CC);                                      \
     386             :         }
     387             : 
     388             : 
     389             : #define Z_LVAL(zval)                    (zval).value.lval
     390             : #define Z_BVAL(zval)                    ((zend_bool)(zval).value.lval)
     391             : #define Z_DVAL(zval)                    (zval).value.dval
     392             : #define Z_STRVAL(zval)                  (zval).value.str.val
     393             : #define Z_STRLEN(zval)                  (zval).value.str.len
     394             : #define Z_ARRVAL(zval)                  (zval).value.ht
     395             : #define Z_OBJVAL(zval)                  (zval).value.obj
     396             : #define Z_OBJ_HANDLE(zval)              Z_OBJVAL(zval).handle
     397             : #define Z_OBJ_HT(zval)                  Z_OBJVAL(zval).handlers
     398             : #define Z_OBJCE(zval)                   zend_get_class_entry(&(zval) TSRMLS_CC)
     399             : #define Z_OBJPROP(zval)                 Z_OBJ_HT((zval))->get_properties(&(zval) TSRMLS_CC)
     400             : #define Z_OBJ_HANDLER(zval, hf) Z_OBJ_HT((zval))->hf
     401             : #define Z_RESVAL(zval)                  (zval).value.lval
     402             : #define Z_OBJDEBUG(zval,is_tmp) (Z_OBJ_HANDLER((zval),get_debug_info)?Z_OBJ_HANDLER((zval),get_debug_info)(&(zval),&is_tmp TSRMLS_CC):(is_tmp=0,Z_OBJ_HANDLER((zval),get_properties)?Z_OBJPROP(zval):NULL))
     403             : 
     404             : #define Z_LVAL_P(zval_p)                Z_LVAL(*zval_p)
     405             : #define Z_BVAL_P(zval_p)                Z_BVAL(*zval_p)
     406             : #define Z_DVAL_P(zval_p)                Z_DVAL(*zval_p)
     407             : #define Z_STRVAL_P(zval_p)              Z_STRVAL(*zval_p)
     408             : #define Z_STRLEN_P(zval_p)              Z_STRLEN(*zval_p)
     409             : #define Z_ARRVAL_P(zval_p)              Z_ARRVAL(*zval_p)
     410             : #define Z_OBJPROP_P(zval_p)             Z_OBJPROP(*zval_p)
     411             : #define Z_OBJCE_P(zval_p)               Z_OBJCE(*zval_p)
     412             : #define Z_RESVAL_P(zval_p)              Z_RESVAL(*zval_p)
     413             : #define Z_OBJVAL_P(zval_p)              Z_OBJVAL(*zval_p)
     414             : #define Z_OBJ_HANDLE_P(zval_p)  Z_OBJ_HANDLE(*zval_p)
     415             : #define Z_OBJ_HT_P(zval_p)              Z_OBJ_HT(*zval_p)
     416             : #define Z_OBJ_HANDLER_P(zval_p, h)      Z_OBJ_HANDLER(*zval_p, h)
     417             : #define Z_OBJDEBUG_P(zval_p,is_tmp)     Z_OBJDEBUG(*zval_p,is_tmp)
     418             : 
     419             : #define Z_LVAL_PP(zval_pp)              Z_LVAL(**zval_pp)
     420             : #define Z_BVAL_PP(zval_pp)              Z_BVAL(**zval_pp)
     421             : #define Z_DVAL_PP(zval_pp)              Z_DVAL(**zval_pp)
     422             : #define Z_STRVAL_PP(zval_pp)    Z_STRVAL(**zval_pp)
     423             : #define Z_STRLEN_PP(zval_pp)    Z_STRLEN(**zval_pp)
     424             : #define Z_ARRVAL_PP(zval_pp)    Z_ARRVAL(**zval_pp)
     425             : #define Z_OBJPROP_PP(zval_pp)   Z_OBJPROP(**zval_pp)
     426             : #define Z_OBJCE_PP(zval_pp)             Z_OBJCE(**zval_pp)
     427             : #define Z_RESVAL_PP(zval_pp)    Z_RESVAL(**zval_pp)
     428             : #define Z_OBJVAL_PP(zval_pp)    Z_OBJVAL(**zval_pp)
     429             : #define Z_OBJ_HANDLE_PP(zval_p) Z_OBJ_HANDLE(**zval_p)
     430             : #define Z_OBJ_HT_PP(zval_p)             Z_OBJ_HT(**zval_p)
     431             : #define Z_OBJ_HANDLER_PP(zval_p, h)             Z_OBJ_HANDLER(**zval_p, h)
     432             : #define Z_OBJDEBUG_PP(zval_pp,is_tmp)   Z_OBJDEBUG(**zval_pp,is_tmp)
     433             : 
     434             : #define Z_TYPE(zval)            (zval).type
     435             : #define Z_TYPE_P(zval_p)        Z_TYPE(*zval_p)
     436             : #define Z_TYPE_PP(zval_pp)      Z_TYPE(**zval_pp)
     437             : 
     438             : #if HAVE_SETLOCALE && defined(ZEND_WIN32) && !defined(ZTS) && defined(_MSC_VER) && (_MSC_VER >= 1400)
     439             : /* This is performance improvement of tolower() on Windows and VC2005
     440             :  * Gives 10-18% on bench.php
     441             :  */
     442             : #define ZEND_USE_TOLOWER_L 1
     443             : #endif
     444             : 
     445             : #ifdef ZEND_USE_TOLOWER_L
     446             : ZEND_API void zend_update_current_locale(void);
     447             : #else
     448             : #define zend_update_current_locale()
     449             : #endif
     450             : 
     451             : #endif
     452             : 
     453             : /*
     454             :  * Local variables:
     455             :  * tab-width: 4
     456             :  * c-basic-offset: 4
     457             :  * indent-tabs-mode: t
     458             :  * End:
     459             :  */

Generated by: LCOV version 1.10

Generated at Sun, 27 Jul 2014 12:58:24 +0000 (4 days ago)

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