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_constants.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 231 282 81.9 %
Date: 2016-09-18 Functions: 18 25 72.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | Zend Engine                                                          |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1998-2016 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             : #include "zend.h"
      23             : #include "zend_constants.h"
      24             : #include "zend_exceptions.h"
      25             : #include "zend_execute.h"
      26             : #include "zend_variables.h"
      27             : #include "zend_operators.h"
      28             : #include "zend_globals.h"
      29             : #include "zend_API.h"
      30             : 
      31    63744781 : void free_zend_constant(zval *zv)
      32             : {
      33    63744781 :         zend_constant *c = Z_PTR_P(zv);
      34             : 
      35    63744781 :         if (!(c->flags & CONST_PERSISTENT)) {
      36       74586 :                 zval_ptr_dtor(&c->value);
      37             :         } else {
      38    63670195 :                 zval_internal_dtor(&c->value);
      39             :         }
      40    63744781 :         if (c->name) {
      41    63744781 :                 zend_string_release(c->name);
      42             :         }
      43    63744781 :         pefree(c, c->flags & CONST_PERSISTENT);
      44    63744781 : }
      45             : 
      46             : 
      47           0 : static void copy_zend_constant(zval *zv)
      48             : {
      49           0 :         zend_constant *c = Z_PTR_P(zv);
      50             : 
      51           0 :         Z_PTR_P(zv) = pemalloc(sizeof(zend_constant), c->flags & CONST_PERSISTENT);
      52           0 :         memcpy(Z_PTR_P(zv), c, sizeof(zend_constant));
      53             : 
      54           0 :         c = Z_PTR_P(zv);
      55           0 :         c->name = zend_string_copy(c->name);
      56           0 :         if (!(c->flags & CONST_PERSISTENT)) {
      57           0 :                 zval_copy_ctor(&c->value);
      58             :         } else {
      59           0 :                 if (Z_TYPE(c->value) == IS_STRING) {
      60           0 :                         Z_STR(c->value) = zend_string_dup(Z_STR(c->value), 1);
      61             :                 }
      62             :         }
      63           0 : }
      64             : 
      65             : 
      66           0 : void zend_copy_constants(HashTable *target, HashTable *source)
      67             : {
      68           0 :         zend_hash_copy(target, source, copy_zend_constant);
      69           0 : }
      70             : 
      71             : 
      72       98505 : static int clean_non_persistent_constant(zval *zv)
      73             : {
      74       98505 :         zend_constant *c = Z_PTR_P(zv);
      75       98505 :         return (c->flags & CONST_PERSISTENT) ? ZEND_HASH_APPLY_STOP : ZEND_HASH_APPLY_REMOVE;
      76             : }
      77             : 
      78             : 
      79           0 : static int clean_non_persistent_constant_full(zval *zv)
      80             : {
      81           0 :         zend_constant *c = Z_PTR_P(zv);
      82           0 :         return (c->flags & CONST_PERSISTENT) ? 0 : 1;
      83             : }
      84             : 
      85             : 
      86           0 : static int clean_module_constant(zval *el, void *arg)
      87             : {
      88           0 :         zend_constant *c = (zend_constant *)Z_PTR_P(el);
      89           0 :         int module_number = *(int *)arg;
      90             : 
      91           0 :         if (c->module_number == module_number) {
      92           0 :                 return 1;
      93             :         } else {
      94           0 :                 return 0;
      95             :         }
      96             : }
      97             : 
      98             : 
      99           0 : void clean_module_constants(int module_number)
     100             : {
     101           0 :         zend_hash_apply_with_argument(EG(zend_constants), clean_module_constant, (void *) &module_number);
     102           0 : }
     103             : 
     104             : 
     105           0 : int zend_startup_constants(void)
     106             : {
     107           0 :         EG(zend_constants) = (HashTable *) malloc(sizeof(HashTable));
     108             : 
     109           0 :         zend_hash_init(EG(zend_constants), 128, NULL, ZEND_CONSTANT_DTOR, 1);
     110           0 :         return SUCCESS;
     111             : }
     112             : 
     113             : 
     114             : 
     115       23922 : void zend_register_standard_constants(void)
     116             : {
     117       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS);
     118       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_RECOVERABLE_ERROR", E_RECOVERABLE_ERROR, CONST_PERSISTENT | CONST_CS);
     119       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS);
     120       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_PARSE", E_PARSE, CONST_PERSISTENT | CONST_CS);
     121       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_NOTICE", E_NOTICE, CONST_PERSISTENT | CONST_CS);
     122       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_STRICT", E_STRICT, CONST_PERSISTENT | CONST_CS);
     123       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_DEPRECATED", E_DEPRECATED, CONST_PERSISTENT | CONST_CS);
     124       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_CORE_ERROR", E_CORE_ERROR, CONST_PERSISTENT | CONST_CS);
     125       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS);
     126       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS);
     127       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS);
     128       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS);
     129       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS);
     130       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS);
     131       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_USER_DEPRECATED", E_USER_DEPRECATED, CONST_PERSISTENT | CONST_CS);
     132             : 
     133       23922 :         REGISTER_MAIN_LONG_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS);
     134             : 
     135       23922 :         REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_PROVIDE_OBJECT", DEBUG_BACKTRACE_PROVIDE_OBJECT, CONST_PERSISTENT | CONST_CS);
     136       23922 :         REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_IGNORE_ARGS", DEBUG_BACKTRACE_IGNORE_ARGS, CONST_PERSISTENT | CONST_CS);
     137             :         /* true/false constants */
     138             :         {
     139       23922 :                 REGISTER_MAIN_BOOL_CONSTANT("TRUE", 1, CONST_PERSISTENT | CONST_CT_SUBST);
     140       23922 :                 REGISTER_MAIN_BOOL_CONSTANT("FALSE", 0, CONST_PERSISTENT | CONST_CT_SUBST);
     141       23922 :                 REGISTER_MAIN_BOOL_CONSTANT("ZEND_THREAD_SAFE", ZTS_V, CONST_PERSISTENT | CONST_CS);
     142       23922 :                 REGISTER_MAIN_BOOL_CONSTANT("ZEND_DEBUG_BUILD", ZEND_DEBUG, CONST_PERSISTENT | CONST_CS);
     143             :         }
     144       23922 :         REGISTER_MAIN_NULL_CONSTANT("NULL", CONST_PERSISTENT | CONST_CT_SUBST);
     145       23922 : }
     146             : 
     147             : 
     148           0 : int zend_shutdown_constants(void)
     149             : {
     150           0 :         zend_hash_destroy(EG(zend_constants));
     151           0 :         free(EG(zend_constants));
     152           0 :         return SUCCESS;
     153             : }
     154             : 
     155             : 
     156       23919 : void clean_non_persistent_constants(void)
     157             : {
     158       23919 :         if (EG(full_tables_cleanup)) {
     159           0 :                 zend_hash_apply(EG(zend_constants), clean_non_persistent_constant_full);
     160             :         } else {
     161       23919 :                 zend_hash_reverse_apply(EG(zend_constants), clean_non_persistent_constant);
     162             :         }
     163       23919 : }
     164             : 
     165       23922 : ZEND_API void zend_register_null_constant(const char *name, size_t name_len, int flags, int module_number)
     166             : {
     167             :         zend_constant c;
     168             : 
     169       23922 :         ZVAL_NULL(&c.value);
     170       23922 :         c.flags = flags;
     171       47844 :         c.name = zend_string_init(name, name_len, flags & CONST_PERSISTENT);
     172       23922 :         c.module_number = module_number;
     173       23922 :         zend_register_constant(&c);
     174       23922 : }
     175             : 
     176       95688 : ZEND_API void zend_register_bool_constant(const char *name, size_t name_len, zend_bool bval, int flags, int module_number)
     177             : {
     178             :         zend_constant c;
     179             : 
     180       95688 :         ZVAL_BOOL(&c.value, bval);
     181       95688 :         c.flags = flags;
     182      191376 :         c.name = zend_string_init(name, name_len, flags & CONST_PERSISTENT);
     183       95688 :         c.module_number = module_number;
     184       95688 :         zend_register_constant(&c);
     185       95688 : }
     186             : 
     187    60714753 : ZEND_API void zend_register_long_constant(const char *name, size_t name_len, zend_long lval, int flags, int module_number)
     188             : {
     189             :         zend_constant c;
     190             : 
     191    60714753 :         ZVAL_LONG(&c.value, lval);
     192    60714753 :         c.flags = flags;
     193   121429506 :         c.name = zend_string_init(name, name_len, flags & CONST_PERSISTENT);
     194    60714753 :         c.module_number = module_number;
     195    60714753 :         zend_register_constant(&c);
     196    60714753 : }
     197             : 
     198             : 
     199      454518 : ZEND_API void zend_register_double_constant(const char *name, size_t name_len, double dval, int flags, int module_number)
     200             : {
     201             :         zend_constant c;
     202             : 
     203      454518 :         ZVAL_DOUBLE(&c.value, dval);
     204      454518 :         c.flags = flags;
     205      909036 :         c.name = zend_string_init(name, name_len, flags & CONST_PERSISTENT);
     206      454518 :         c.module_number = module_number;
     207      454518 :         zend_register_constant(&c);
     208      454518 : }
     209             : 
     210             : 
     211     2272862 : ZEND_API void zend_register_stringl_constant(const char *name, size_t name_len, char *strval, size_t strlen, int flags, int module_number)
     212             : {
     213             :         zend_constant c;
     214             : 
     215     4545724 :         ZVAL_NEW_STR(&c.value, zend_string_init(strval, strlen, flags & CONST_PERSISTENT));
     216     2272862 :         c.flags = flags;
     217     4545724 :         c.name = zend_string_init(name, name_len, flags & CONST_PERSISTENT);
     218     2272862 :         c.module_number = module_number;
     219     2272862 :         zend_register_constant(&c);
     220     2272862 : }
     221             : 
     222             : 
     223     1794150 : ZEND_API void zend_register_string_constant(const char *name, size_t name_len, char *strval, int flags, int module_number)
     224             : {
     225     1794150 :         zend_register_stringl_constant(name, name_len, strval, strlen(strval), flags, module_number);
     226     1794150 : }
     227             : 
     228        1935 : static zend_constant *zend_get_special_constant(const char *name, size_t name_len)
     229             : {
     230             :         zend_constant *c;
     231             :         static char haltoff[] = "__COMPILER_HALT_OFFSET__";
     232             : 
     233        1935 :         if (!EG(current_execute_data)) {
     234         958 :                 return NULL;
     235        1638 :         } else if (name_len == sizeof("__COMPILER_HALT_OFFSET__")-1 &&
     236         661 :                   !memcmp(name, "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1)) {
     237             :                 const char *cfilename;
     238             :                 zend_string *haltname;
     239             :                 size_t clen;
     240             : 
     241         661 :                 cfilename = zend_get_executed_filename();
     242         661 :                 clen = strlen(cfilename);
     243             :                 /* check for __COMPILER_HALT_OFFSET__ */
     244         661 :                 haltname = zend_mangle_property_name(haltoff,
     245             :                         sizeof("__COMPILER_HALT_OFFSET__") - 1, cfilename, clen, 0);
     246        1322 :                 c = zend_hash_find_ptr(EG(zend_constants), haltname);
     247             :                 zend_string_free(haltname);
     248         661 :                 return c;
     249             :         } else {
     250         316 :                 return NULL;
     251             :         }
     252             : }
     253             : 
     254       11136 : ZEND_API int zend_verify_const_access(zend_class_constant *c, zend_class_entry *scope) /* {{{ */
     255             : {
     256       11136 :         if (Z_ACCESS_FLAGS(c->value) & ZEND_ACC_PUBLIC) {
     257       11124 :                 return 1;
     258          12 :         } else if (Z_ACCESS_FLAGS(c->value) & ZEND_ACC_PRIVATE) {
     259           6 :                 return (c->ce == scope);
     260             :         } else {
     261             :                 ZEND_ASSERT(Z_ACCESS_FLAGS(c->value) & ZEND_ACC_PROTECTED);
     262           6 :                 return zend_check_protected(c->ce, scope);
     263             :         }
     264             : }
     265             : /* }}} */
     266             : 
     267        1409 : ZEND_API zval *zend_get_constant_str(const char *name, size_t name_len)
     268             : {
     269             :         zend_constant *c;
     270             :         ALLOCA_FLAG(use_heap)
     271             : 
     272        2818 :         if ((c = zend_hash_str_find_ptr(EG(zend_constants), name, name_len)) == NULL) {
     273        1094 :                 char *lcname = do_alloca(name_len + 1, use_heap);
     274        1094 :                 zend_str_tolower_copy(lcname, name, name_len);
     275        2188 :                 if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, name_len)) != NULL) {
     276         221 :                         if (c->flags & CONST_CS) {
     277           0 :                                 c = NULL;
     278             :                         }
     279             :                 } else {
     280         873 :                         c = zend_get_special_constant(name, name_len);
     281             :                 }
     282        1094 :                 free_alloca(lcname, use_heap);
     283             :         }
     284             : 
     285        1409 :         return c ? &c->value : NULL;
     286             : }
     287             : 
     288        1539 : ZEND_API zval *zend_get_constant(zend_string *name)
     289             : {
     290             :         zend_constant *c;
     291             :         ALLOCA_FLAG(use_heap)
     292             : 
     293        3078 :         if ((c = zend_hash_find_ptr(EG(zend_constants), name)) == NULL) {
     294        1062 :                 char *lcname = do_alloca(ZSTR_LEN(name) + 1, use_heap);
     295        1062 :                 zend_str_tolower_copy(lcname, ZSTR_VAL(name), ZSTR_LEN(name));
     296        2124 :                 if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, ZSTR_LEN(name))) != NULL) {
     297           0 :                         if (c->flags & CONST_CS) {
     298           0 :                                 c = NULL;
     299             :                         }
     300             :                 } else {
     301        1062 :                         c = zend_get_special_constant(ZSTR_VAL(name), ZSTR_LEN(name));
     302             :                 }
     303        1062 :                 free_alloca(lcname, use_heap);
     304             :         }
     305             : 
     306        1539 :         return c ? &c->value : NULL;
     307             : }
     308             : 
     309         422 : ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope, uint32_t flags)
     310             : {
     311             :         zend_constant *c;
     312             :         const char *colon;
     313         422 :         zend_class_entry *ce = NULL;
     314         422 :         const char *name = ZSTR_VAL(cname);
     315         422 :         size_t name_len = ZSTR_LEN(cname);
     316             : 
     317             :         /* Skip leading \\ */
     318         422 :         if (name[0] == '\\') {
     319           8 :                 name += 1;
     320           8 :                 name_len -= 1;
     321           8 :                 cname = NULL;
     322             :         }
     323             : 
     324         568 :         if ((colon = zend_memrchr(name, ':', name_len)) &&
     325         146 :             colon > name && (*(colon - 1) == ':')) {
     326         146 :                 int class_name_len = colon - name - 1;
     327         146 :                 size_t const_name_len = name_len - class_name_len - 2;
     328         292 :                 zend_string *constant_name = zend_string_init(colon + 1, const_name_len, 0);
     329         292 :                 zend_string *class_name = zend_string_init(name, class_name_len, 0);
     330         146 :                 zval *ret_constant = NULL;
     331             : 
     332         181 :                 if (zend_string_equals_literal_ci(class_name, "self")) {
     333          35 :                         if (UNEXPECTED(!scope)) {
     334           0 :                                 zend_throw_error(NULL, "Cannot access self:: when no class scope is active");
     335           0 :                                 goto failure;
     336             :                         }
     337          35 :                         ce = scope;
     338         121 :                 } else if (zend_string_equals_literal_ci(class_name, "parent")) {
     339          11 :                         if (UNEXPECTED(!scope)) {
     340           0 :                                 zend_throw_error(NULL, "Cannot access parent:: when no class scope is active");
     341           0 :                                 goto failure;
     342          11 :                         } else if (UNEXPECTED(!scope->parent)) {
     343           1 :                                 zend_throw_error(NULL, "Cannot access parent:: when current class scope has no parent");
     344           1 :                                 goto failure;
     345             :                         } else {
     346          10 :                                 ce = scope->parent;
     347             :                         }
     348         105 :                 } else if (zend_string_equals_literal_ci(class_name, "static")) {
     349           5 :                         ce = zend_get_called_scope(EG(current_execute_data));
     350           5 :                         if (UNEXPECTED(!ce)) {
     351           0 :                                 zend_throw_error(NULL, "Cannot access static:: when no class scope is active");
     352           0 :                                 goto failure;
     353             :                         }
     354             :                 } else {
     355          95 :                         ce = zend_fetch_class(class_name, flags);
     356             :                 }
     357         139 :                 if (ce) {
     358         272 :                         zend_class_constant *c = zend_hash_find_ptr(&ce->constants_table, constant_name);
     359         136 :                         if (c == NULL) {
     360           6 :                                 if ((flags & ZEND_FETCH_CLASS_SILENT) == 0) {
     361           1 :                                         zend_throw_error(NULL, "Undefined class constant '%s::%s'", ZSTR_VAL(class_name), ZSTR_VAL(constant_name));
     362           1 :                                         goto failure;
     363             :                                 }
     364           5 :                                 ret_constant = NULL;
     365             :                         } else {
     366         130 :                                 if (!zend_verify_const_access(c, scope)) {
     367           3 :                                         zend_throw_error(NULL, "Cannot access %s const %s::%s", zend_visibility_string(Z_ACCESS_FLAGS(c->value)), ZSTR_VAL(class_name), ZSTR_VAL(constant_name));
     368           3 :                                         goto failure;
     369             :                                 }
     370         127 :                                 ret_constant = &c->value;
     371             :                         }
     372             :                 }
     373             : 
     374         135 :                 if (ret_constant && Z_CONSTANT_P(ret_constant)) {
     375           7 :                         if (Z_TYPE_P(ret_constant) == IS_CONSTANT_AST) {
     376           4 :                                 if (IS_CONSTANT_VISITED(ret_constant)) {
     377           0 :                                         zend_throw_error(NULL, "Cannot declare self-referencing constant '%s::%s'", ZSTR_VAL(class_name), ZSTR_VAL(constant_name));
     378           0 :                                         ret_constant = NULL;
     379           0 :                                         goto failure;
     380             :                                 }
     381           4 :                                 MARK_CONSTANT_VISITED(ret_constant);
     382             :                         }
     383           7 :                         if (UNEXPECTED(zval_update_constant_ex(ret_constant, ce) != SUCCESS)) {
     384           4 :                                 RESET_CONSTANT_VISITED(ret_constant);
     385           4 :                                 ret_constant = NULL;
     386           4 :                                 goto failure;
     387             :                         }
     388           3 :                         RESET_CONSTANT_VISITED(ret_constant);
     389             :                 }
     390             : failure:
     391             :                 zend_string_release(class_name);
     392             :                 zend_string_free(constant_name);
     393         140 :                 return ret_constant;
     394             :         }
     395             : 
     396             :         /* non-class constant */
     397         276 :         if ((colon = zend_memrchr(name, '\\', name_len)) != NULL) {
     398             :                 /* compound constant name */
     399          77 :                 int prefix_len = colon - name;
     400          77 :                 size_t const_name_len = name_len - prefix_len - 1;
     401          77 :                 const char *constant_name = colon + 1;
     402             :                 char *lcname;
     403             :                 size_t lcname_len;
     404             :                 ALLOCA_FLAG(use_heap)
     405             : 
     406          77 :                 lcname_len = prefix_len + 1 + const_name_len;
     407          77 :                 lcname = do_alloca(lcname_len + 1, use_heap);
     408          77 :                 zend_str_tolower_copy(lcname, name, prefix_len);
     409             :                 /* Check for namespace constant */
     410             : 
     411          77 :                 lcname[prefix_len] = '\\';
     412          77 :                 memcpy(lcname + prefix_len + 1, constant_name, const_name_len + 1);
     413             : 
     414         154 :                 if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, lcname_len)) == NULL) {
     415             :                         /* try lowercase */
     416          25 :                         zend_str_tolower(lcname + prefix_len + 1, const_name_len);
     417          50 :                         if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, lcname_len)) != NULL) {
     418           0 :                                 if ((c->flags & CONST_CS) != 0) {
     419           0 :                                         c = NULL;
     420             :                                 }
     421             :                         }
     422             :                 }
     423          77 :                 free_alloca(lcname, use_heap);
     424          77 :                 if (c) {
     425          52 :                         return &c->value;
     426             :                 }
     427             :                 /* name requires runtime resolution, need to check non-namespaced name */
     428          25 :                 if ((flags & IS_CONSTANT_UNQUALIFIED) != 0) {
     429          17 :                         return zend_get_constant_str(constant_name, const_name_len);
     430             :                 }
     431           8 :                 return NULL;
     432             :         }
     433             : 
     434         199 :         if (cname) {
     435         198 :                 return zend_get_constant(cname);
     436             :         } else {
     437           1 :                 return zend_get_constant_str(name, name_len);
     438             :         }
     439             : }
     440             : 
     441        3590 : zend_constant *zend_quick_get_constant(const zval *key, uint32_t flags)
     442             : {
     443             :         zend_constant *c;
     444             : 
     445        7180 :         if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
     446         419 :                 key++;
     447        1134 :                 if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
     448         296 :                     (c->flags & CONST_CS) != 0) {
     449         124 :                         if ((flags & (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) == (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) {
     450          15 :                                 key++;
     451          30 :                                 if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
     452           5 :                                     key++;
     453          10 :                                         if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
     454           0 :                                             (c->flags & CONST_CS) != 0) {
     455             : 
     456           5 :                                                 key--;
     457           5 :                                                 c = NULL;
     458             :                                         }
     459             :                                 }
     460             :                         } else {
     461         109 :                                 key--;
     462         109 :                                 c = NULL;
     463             :                         }
     464             :                 }
     465             :         }
     466        3590 :         return c;
     467             : }
     468             : 
     469    63635712 : static void* zend_hash_add_constant(HashTable *ht, zend_string *key, zend_constant *c)
     470             : {
     471             :         void *ret;
     472    63635712 :         zend_constant *copy = pemalloc(sizeof(zend_constant), c->flags & CONST_PERSISTENT);
     473             : 
     474    63635712 :         memcpy(copy, c, sizeof(zend_constant));
     475    63635712 :         ret = zend_hash_add_ptr(ht, key, copy);
     476    63635712 :         if (!ret) {
     477           6 :                 pefree(copy, c->flags & CONST_PERSISTENT);
     478             :         }
     479    63635712 :         return ret;
     480             : }
     481             : 
     482    63635715 : ZEND_API int zend_register_constant(zend_constant *c)
     483             : {
     484    63635715 :         zend_string *lowercase_name = NULL;
     485             :         zend_string *name;
     486    63635715 :         int ret = SUCCESS;
     487             : 
     488             : #if 0
     489             :         printf("Registering constant for module %d\n", c->module_number);
     490             : #endif
     491             : 
     492    63635715 :         if (!(c->flags & CONST_CS)) {
     493     5263512 :                 lowercase_name = zend_string_alloc(ZSTR_LEN(c->name), c->flags & CONST_PERSISTENT);
     494     2631756 :                 zend_str_tolower_copy(ZSTR_VAL(lowercase_name), ZSTR_VAL(c->name), ZSTR_LEN(c->name));
     495     2631756 :                 lowercase_name = zend_new_interned_string(lowercase_name);
     496     2631756 :                 name = lowercase_name;
     497             :         } else {
     498    61003959 :                 char *slash = strrchr(ZSTR_VAL(c->name), '\\');
     499    61003959 :                 if (slash) {
     500          98 :                         lowercase_name = zend_string_init(ZSTR_VAL(c->name), ZSTR_LEN(c->name), c->flags & CONST_PERSISTENT);
     501          49 :                         zend_str_tolower(ZSTR_VAL(lowercase_name), slash - ZSTR_VAL(c->name));
     502          49 :                         lowercase_name = zend_new_interned_string(lowercase_name);
     503          49 :                         name = lowercase_name;
     504             :                 } else {
     505    61003910 :                         name = c->name;
     506             :                 }
     507             :         }
     508             : 
     509             :         /* Check if the user is trying to define the internal pseudo constant name __COMPILER_HALT_OFFSET__ */
     510   192749180 :         if ((ZSTR_LEN(c->name) == sizeof("__COMPILER_HALT_OFFSET__")-1
     511    65477753 :                 && !memcmp(ZSTR_VAL(name), "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1))
     512    63635712 :                 || zend_hash_add_constant(EG(zend_constants), name, c) == NULL) {
     513             : 
     514             :                 /* The internal __COMPILER_HALT_OFFSET__ is prefixed by NULL byte */
     515           9 :                 if (ZSTR_VAL(c->name)[0] == '\0' && ZSTR_LEN(c->name) > sizeof("\0__COMPILER_HALT_OFFSET__")-1
     516           0 :                         && memcmp(ZSTR_VAL(name), "\0__COMPILER_HALT_OFFSET__", sizeof("\0__COMPILER_HALT_OFFSET__")) == 0) {
     517             :                 }
     518           9 :                 zend_error(E_NOTICE,"Constant %s already defined", ZSTR_VAL(name));
     519           9 :                 zend_string_release(c->name);
     520           9 :                 if (!(c->flags & CONST_PERSISTENT)) {
     521           9 :                         zval_dtor(&c->value);
     522             :                 }
     523           9 :                 ret = FAILURE;
     524             :         }
     525    63635715 :         if (lowercase_name) {
     526             :                 zend_string_release(lowercase_name);
     527             :         }
     528    63635715 :         return ret;
     529             : }
     530             : 
     531             : 
     532             : /*
     533             :  * Local variables:
     534             :  * tab-width: 4
     535             :  * c-basic-offset: 4
     536             :  * indent-tabs-mode: t
     537             :  * End:
     538             :  */

Generated by: LCOV version 1.10

Generated at Sun, 18 Sep 2016 08:20:03 +0000 (6 days ago)

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