Annotation of embedaddon/php/Zend/zend_operators.h, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | Zend Engine |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1998-2012 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: zend_operators.h 321634 2012-01-01 13:15:04Z felipe $ */
! 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: if (d > LONG_MAX) {
! 80: return (long)(unsigned long) d;
! 81: }
! 82: 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: 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: int base = 10, digits = 0, dp_or_e = 0;
! 106: double local_dval;
! 107: zend_uchar type;
! 108:
! 109: if (!length) {
! 110: return 0;
! 111: }
! 112:
! 113: /* Skip any whitespace
! 114: * This is much faster than the isspace() function */
! 115: while (*str == ' ' || *str == '\t' || *str == '\n' || *str == '\r' || *str == '\v' || *str == '\f') {
! 116: str++;
! 117: length--;
! 118: }
! 119: ptr = str;
! 120:
! 121: if (*ptr == '-' || *ptr == '+') {
! 122: ptr++;
! 123: }
! 124:
! 125: if (ZEND_IS_DIGIT(*ptr)) {
! 126: /* Handle hex numbers
! 127: * str is used instead of ptr to disallow signs and keep old behavior */
! 128: if (length > 2 && *str == '0' && (str[1] == 'x' || str[1] == 'X')) {
! 129: base = 16;
! 130: ptr += 2;
! 131: }
! 132:
! 133: /* Skip any leading 0s */
! 134: while (*ptr == '0') {
! 135: 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: for (type = IS_LONG; !(digits >= MAX_LENGTH_OF_LONG && (dval || allow_errors == 1)); digits++, ptr++) {
! 142: check_digits:
! 143: if (ZEND_IS_DIGIT(*ptr) || (base == 16 && ZEND_IS_XDIGIT(*ptr))) {
! 144: continue;
! 145: } else if (base == 10) {
! 146: if (*ptr == '.' && dp_or_e < 1) {
! 147: goto process_double;
! 148: } else if ((*ptr == 'e' || *ptr == 'E') && dp_or_e < 2) {
! 149: const char *e = ptr + 1;
! 150:
! 151: if (*e == '-' || *e == '+') {
! 152: ptr = e++;
! 153: }
! 154: if (ZEND_IS_DIGIT(*e)) {
! 155: goto process_double;
! 156: }
! 157: }
! 158: }
! 159:
! 160: break;
! 161: }
! 162:
! 163: if (base == 10) {
! 164: if (digits >= MAX_LENGTH_OF_LONG) {
! 165: dp_or_e = -1;
! 166: goto process_double;
! 167: }
! 168: } else if (!(digits < SIZEOF_LONG * 2 || (digits == SIZEOF_LONG * 2 && ptr[-digits] <= '7'))) {
! 169: if (dval) {
! 170: local_dval = zend_hex_strtod(str, (char **)&ptr);
! 171: }
! 172: type = IS_DOUBLE;
! 173: }
! 174: } else if (*ptr == '.' && ZEND_IS_DIGIT(ptr[1])) {
! 175: process_double:
! 176: 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: if (dval) {
! 181: local_dval = zend_strtod(str, (char **)&ptr);
! 182: } else if (allow_errors != 1 && dp_or_e != -1) {
! 183: dp_or_e = (*ptr++ == '.') ? 1 : 2;
! 184: goto check_digits;
! 185: }
! 186: } else {
! 187: return 0;
! 188: }
! 189:
! 190: if (ptr != str + length) {
! 191: if (!allow_errors) {
! 192: return 0;
! 193: }
! 194: if (allow_errors == -1) {
! 195: zend_error(E_NOTICE, "A non well formed numeric value encountered");
! 196: }
! 197: }
! 198:
! 199: if (type == IS_LONG) {
! 200: if (digits == MAX_LENGTH_OF_LONG - 1) {
! 201: int cmp = strcmp(&ptr[-digits], long_min_digits);
! 202:
! 203: if (!(cmp < 0 || (cmp == 0 && *str == '-'))) {
! 204: if (dval) {
! 205: *dval = zend_strtod(str, NULL);
! 206: }
! 207:
! 208: return IS_DOUBLE;
! 209: }
! 210: }
! 211:
! 212: if (lval) {
! 213: *lval = strtol(str, NULL, base);
! 214: }
! 215:
! 216: return IS_LONG;
! 217: } else {
! 218: if (dval) {
! 219: *dval = local_dval;
! 220: }
! 221:
! 222: return IS_DOUBLE;
! 223: }
! 224: }
! 225:
! 226: static inline char *
! 227: zend_memnstr(char *haystack, char *needle, int needle_len, char *end)
! 228: {
! 229: char *p = haystack;
! 230: char ne = needle[needle_len-1];
! 231:
! 232: if (needle_len == 1) {
! 233: return (char *)memchr(p, *needle, (end-p));
! 234: }
! 235:
! 236: if (needle_len > end-haystack) {
! 237: return NULL;
! 238: }
! 239:
! 240: end -= needle_len;
! 241:
! 242: while (p <= end) {
! 243: if ((p = (char *)memchr(p, *needle, (end-p+1))) && ne == p[needle_len-1]) {
! 244: if (!memcmp(needle, p, needle_len-1)) {
! 245: return p;
! 246: }
! 247: }
! 248:
! 249: if (p == NULL) {
! 250: return NULL;
! 251: }
! 252:
! 253: p++;
! 254: }
! 255:
! 256: return NULL;
! 257: }
! 258:
! 259: static inline void *zend_memrchr(const void *s, int c, size_t n)
! 260: {
! 261: register unsigned char *e;
! 262:
! 263: if (n <= 0) {
! 264: return NULL;
! 265: }
! 266:
! 267: for (e = (unsigned char *)s + n - 1; e >= (unsigned char *)s; e--) {
! 268: if (*e == (unsigned char)c) {
! 269: return (void *)e;
! 270: }
! 271: }
! 272:
! 273: 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: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zend_operators.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / Zend