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: 230 280 82.1 %
Date: 2016-07-19 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    60538148 : void free_zend_constant(zval *zv)
      32             : {
      33    60538148 :         zend_constant *c = Z_PTR_P(zv);
      34             : 
      35    60538148 :         if (!(c->flags & CONST_PERSISTENT)) {
      36       73005 :                 zval_ptr_dtor(&c->value);
      37             :         } else {
      38    60465143 :                 zval_internal_dtor(&c->value);
      39             :         }
      40    60538148 :         if (c->name) {
      41    60538148 :                 zend_string_release(c->name);
      42             :         }
      43    60538148 :         pefree(c, c->flags & CONST_PERSISTENT);
      44    60538148 : }
      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       96406 : static int clean_non_persistent_constant(zval *zv)
      73             : {
      74       96406 :         zend_constant *c = Z_PTR_P(zv);
      75       96406 :         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       23409 : void zend_register_standard_constants(void)
     116             : {
     117       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS);
     118       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_RECOVERABLE_ERROR", E_RECOVERABLE_ERROR, CONST_PERSISTENT | CONST_CS);
     119       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS);
     120       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_PARSE", E_PARSE, CONST_PERSISTENT | CONST_CS);
     121       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_NOTICE", E_NOTICE, CONST_PERSISTENT | CONST_CS);
     122       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_STRICT", E_STRICT, CONST_PERSISTENT | CONST_CS);
     123       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_DEPRECATED", E_DEPRECATED, CONST_PERSISTENT | CONST_CS);
     124       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_CORE_ERROR", E_CORE_ERROR, CONST_PERSISTENT | CONST_CS);
     125       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS);
     126       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS);
     127       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS);
     128       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS);
     129       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS);
     130       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS);
     131       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_USER_DEPRECATED", E_USER_DEPRECATED, CONST_PERSISTENT | CONST_CS);
     132             : 
     133       23409 :         REGISTER_MAIN_LONG_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS);
     134             : 
     135       23409 :         REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_PROVIDE_OBJECT", DEBUG_BACKTRACE_PROVIDE_OBJECT, CONST_PERSISTENT | CONST_CS);
     136       23409 :         REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_IGNORE_ARGS", DEBUG_BACKTRACE_IGNORE_ARGS, CONST_PERSISTENT | CONST_CS);
     137             :         /* true/false constants */
     138             :         {
     139       23409 :                 REGISTER_MAIN_BOOL_CONSTANT("TRUE", 1, CONST_PERSISTENT | CONST_CT_SUBST);
     140       23409 :                 REGISTER_MAIN_BOOL_CONSTANT("FALSE", 0, CONST_PERSISTENT | CONST_CT_SUBST);
     141       23409 :                 REGISTER_MAIN_BOOL_CONSTANT("ZEND_THREAD_SAFE", ZTS_V, CONST_PERSISTENT | CONST_CS);
     142       23409 :                 REGISTER_MAIN_BOOL_CONSTANT("ZEND_DEBUG_BUILD", ZEND_DEBUG, CONST_PERSISTENT | CONST_CS);
     143             :         }
     144       23409 :         REGISTER_MAIN_NULL_CONSTANT("NULL", CONST_PERSISTENT | CONST_CT_SUBST);
     145       23409 : }
     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       23401 : void clean_non_persistent_constants(void)
     157             : {
     158       23401 :         if (EG(full_tables_cleanup)) {
     159           0 :                 zend_hash_apply(EG(zend_constants), clean_non_persistent_constant_full);
     160             :         } else {
     161       23401 :                 zend_hash_reverse_apply(EG(zend_constants), clean_non_persistent_constant);
     162             :         }
     163       23401 : }
     164             : 
     165       23409 : 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       23409 :         ZVAL_NULL(&c.value);
     170       23409 :         c.flags = flags;
     171       46818 :         c.name = zend_string_init(name, name_len, flags & CONST_PERSISTENT);
     172       23409 :         c.module_number = module_number;
     173       23409 :         zend_register_constant(&c);
     174       23409 : }
     175             : 
     176       93636 : 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       93636 :         ZVAL_BOOL(&c.value, bval);
     181       93636 :         c.flags = flags;
     182      187272 :         c.name = zend_string_init(name, name_len, flags & CONST_PERSISTENT);
     183       93636 :         c.module_number = module_number;
     184       93636 :         zend_register_constant(&c);
     185       93636 : }
     186             : 
     187    57586843 : 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    57586843 :         ZVAL_LONG(&c.value, lval);
     192    57586843 :         c.flags = flags;
     193   115173686 :         c.name = zend_string_init(name, name_len, flags & CONST_PERSISTENT);
     194    57586843 :         c.module_number = module_number;
     195    57586843 :         zend_register_constant(&c);
     196    57586843 : }
     197             : 
     198             : 
     199      444771 : 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      444771 :         ZVAL_DOUBLE(&c.value, dval);
     204      444771 :         c.flags = flags;
     205      889542 :         c.name = zend_string_init(name, name_len, flags & CONST_PERSISTENT);
     206      444771 :         c.module_number = module_number;
     207      444771 :         zend_register_constant(&c);
     208      444771 : }
     209             : 
     210             : 
     211     2224116 : 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     4448232 :         ZVAL_NEW_STR(&c.value, zend_string_init(strval, strlen, flags & CONST_PERSISTENT));
     216     2224116 :         c.flags = flags;
     217     4448232 :         c.name = zend_string_init(name, name_len, flags & CONST_PERSISTENT);
     218     2224116 :         c.module_number = module_number;
     219     2224116 :         zend_register_constant(&c);
     220     2224116 : }
     221             : 
     222             : 
     223     1755675 : ZEND_API void zend_register_string_constant(const char *name, size_t name_len, char *strval, int flags, int module_number)
     224             : {
     225     1755675 :         zend_register_stringl_constant(name, name_len, strval, strlen(strval), flags, module_number);
     226     1755675 : }
     227             : 
     228        1841 : 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        1841 :         if (!EG(current_execute_data)) {
     234        1028 :                 return NULL;
     235        1319 :         } else if (name_len == sizeof("__COMPILER_HALT_OFFSET__")-1 &&
     236         506 :                   !memcmp(name, "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1)) {
     237             :                 const char *cfilename;
     238             :                 zend_string *haltname;
     239             :                 size_t clen;
     240             : 
     241         506 :                 cfilename = zend_get_executed_filename();
     242         506 :                 clen = strlen(cfilename);
     243             :                 /* check for __COMPILER_HALT_OFFSET__ */
     244         506 :                 haltname = zend_mangle_property_name(haltoff,
     245             :                         sizeof("__COMPILER_HALT_OFFSET__") - 1, cfilename, clen, 0);
     246        1012 :                 c = zend_hash_find_ptr(EG(zend_constants), haltname);
     247             :                 zend_string_free(haltname);
     248         506 :                 return c;
     249             :         } else {
     250         307 :                 return NULL;
     251             :         }
     252             : }
     253             : 
     254       10665 : ZEND_API int zend_verify_const_access(zend_class_constant *c, zend_class_entry *scope) /* {{{ */
     255             : {
     256       10665 :         if (Z_ACCESS_FLAGS(c->value) & ZEND_ACC_PUBLIC) {
     257       10654 :                 return 1;
     258          11 :         } else if (Z_ACCESS_FLAGS(c->value) & ZEND_ACC_PRIVATE) {
     259           5 :                 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        1241 : 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        2482 :         if ((c = zend_hash_str_find_ptr(EG(zend_constants), name, name_len)) == NULL) {
     273         926 :                 char *lcname = do_alloca(name_len + 1, use_heap);
     274         926 :                 zend_str_tolower_copy(lcname, name, name_len);
     275        1852 :                 if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, name_len)) != NULL) {
     276         217 :                         if (c->flags & CONST_CS) {
     277           0 :                                 c = NULL;
     278             :                         }
     279             :                 } else {
     280         709 :                         c = zend_get_special_constant(name, name_len);
     281             :                 }
     282         926 :                 free_alloca(lcname, use_heap);
     283             :         }
     284             : 
     285        1241 :         return c ? &c->value : NULL;
     286             : }
     287             : 
     288        1654 : ZEND_API zval *zend_get_constant(zend_string *name)
     289             : {
     290             :         zend_constant *c;
     291             :         ALLOCA_FLAG(use_heap)
     292             : 
     293        3308 :         if ((c = zend_hash_find_ptr(EG(zend_constants), name)) == NULL) {
     294        1132 :                 char *lcname = do_alloca(ZSTR_LEN(name) + 1, use_heap);
     295        1132 :                 zend_str_tolower_copy(lcname, ZSTR_VAL(name), ZSTR_LEN(name));
     296        2264 :                 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        1132 :                         c = zend_get_special_constant(ZSTR_VAL(name), ZSTR_LEN(name));
     302             :                 }
     303        1132 :                 free_alloca(lcname, use_heap);
     304             :         }
     305             : 
     306        1654 :         return c ? &c->value : NULL;
     307             : }
     308             : 
     309         421 : 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         421 :         zend_class_entry *ce = NULL;
     314         421 :         const char *name = ZSTR_VAL(cname);
     315         421 :         size_t name_len = ZSTR_LEN(cname);
     316             : 
     317             :         /* Skip leading \\ */
     318         421 :         if (name[0] == '\\') {
     319           8 :                 name += 1;
     320           8 :                 name_len -= 1;
     321           8 :                 cname = NULL;
     322             :         }
     323             : 
     324         566 :         if ((colon = zend_memrchr(name, ':', name_len)) &&
     325         145 :             colon > name && (*(colon - 1) == ':')) {
     326         145 :                 int class_name_len = colon - name - 1;
     327         145 :                 size_t const_name_len = name_len - class_name_len - 2;
     328         290 :                 zend_string *constant_name = zend_string_init(colon + 1, const_name_len, 0);
     329         290 :                 zend_string *class_name = zend_string_init(name, class_name_len, 0);
     330         145 :                 zval *ret_constant = NULL;
     331             : 
     332         180 :                 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         120 :                 } 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         104 :                 } 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          94 :                         ce = zend_fetch_class(class_name, flags);
     356             :                 }
     357         138 :                 if (ce) {
     358         270 :                         zend_class_constant *c = zend_hash_find_ptr(&ce->constants_table, constant_name);
     359         135 :                         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         129 :                                 if (!zend_verify_const_access(c, scope)) {
     367           2 :                                         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           2 :                                         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 :                                         goto failure;
     379             :                                 }
     380           4 :                                 MARK_CONSTANT_VISITED(ret_constant);
     381             :                         }
     382           7 :                         if (UNEXPECTED(zval_update_constant_ex(ret_constant, ce) != SUCCESS)) {
     383           2 :                                 RESET_CONSTANT_VISITED(ret_constant);
     384           2 :                                 goto failure;
     385             :                         }
     386           5 :                         RESET_CONSTANT_VISITED(ret_constant);
     387             :                 }
     388             : failure:
     389             :                 zend_string_release(class_name);
     390             :                 zend_string_free(constant_name);
     391         139 :                 return ret_constant;
     392             :         }
     393             : 
     394             :         /* non-class constant */
     395         276 :         if ((colon = zend_memrchr(name, '\\', name_len)) != NULL) {
     396             :                 /* compound constant name */
     397          77 :                 int prefix_len = colon - name;
     398          77 :                 size_t const_name_len = name_len - prefix_len - 1;
     399          77 :                 const char *constant_name = colon + 1;
     400             :                 char *lcname;
     401             :                 size_t lcname_len;
     402             :                 ALLOCA_FLAG(use_heap)
     403             : 
     404          77 :                 lcname_len = prefix_len + 1 + const_name_len;
     405          77 :                 lcname = do_alloca(lcname_len + 1, use_heap);
     406          77 :                 zend_str_tolower_copy(lcname, name, prefix_len);
     407             :                 /* Check for namespace constant */
     408             : 
     409          77 :                 lcname[prefix_len] = '\\';
     410          77 :                 memcpy(lcname + prefix_len + 1, constant_name, const_name_len + 1);
     411             : 
     412         154 :                 if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, lcname_len)) == NULL) {
     413             :                         /* try lowercase */
     414          25 :                         zend_str_tolower(lcname + prefix_len + 1, const_name_len);
     415          50 :                         if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, lcname_len)) != NULL) {
     416           0 :                                 if ((c->flags & CONST_CS) != 0) {
     417           0 :                                         c = NULL;
     418             :                                 }
     419             :                         }
     420             :                 }
     421          77 :                 free_alloca(lcname, use_heap);
     422          77 :                 if (c) {
     423          52 :                         return &c->value;
     424             :                 }
     425             :                 /* name requires runtime resolution, need to check non-namespaced name */
     426          25 :                 if ((flags & IS_CONSTANT_UNQUALIFIED) != 0) {
     427          17 :                         return zend_get_constant_str(constant_name, const_name_len);
     428             :                 }
     429           8 :                 return NULL;
     430             :         }
     431             : 
     432         199 :         if (cname) {
     433         198 :                 return zend_get_constant(cname);
     434             :         } else {
     435           1 :                 return zend_get_constant_str(name, name_len);
     436             :         }
     437             : }
     438             : 
     439        3444 : zend_constant *zend_quick_get_constant(const zval *key, uint32_t flags)
     440             : {
     441             :         zend_constant *c;
     442             : 
     443        6888 :         if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
     444         339 :                 key++;
     445         904 :                 if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
     446         226 :                     (c->flags & CONST_CS) != 0) {
     447         114 :                         if ((flags & (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) == (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) {
     448          15 :                                 key++;
     449          30 :                                 if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
     450           5 :                                     key++;
     451          10 :                                         if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
     452           0 :                                             (c->flags & CONST_CS) != 0) {
     453             : 
     454           5 :                                                 key--;
     455           5 :                                                 c = NULL;
     456             :                                         }
     457             :                                 }
     458             :                         } else {
     459          99 :                                 key--;
     460          99 :                                 c = NULL;
     461             :                         }
     462             :                 }
     463             :         }
     464        3444 :         return c;
     465             : }
     466             : 
     467    60445186 : static void* zend_hash_add_constant(HashTable *ht, zend_string *key, zend_constant *c)
     468             : {
     469             :         void *ret;
     470    60445186 :         zend_constant *copy = pemalloc(sizeof(zend_constant), c->flags & CONST_PERSISTENT);
     471             : 
     472    60445186 :         memcpy(copy, c, sizeof(zend_constant));
     473    60445186 :         ret = zend_hash_add_ptr(ht, key, copy);
     474    60445186 :         if (!ret) {
     475           5 :                 pefree(copy, c->flags & CONST_PERSISTENT);
     476             :         }
     477    60445186 :         return ret;
     478             : }
     479             : 
     480    60445189 : ZEND_API int zend_register_constant(zend_constant *c)
     481             : {
     482    60445189 :         zend_string *lowercase_name = NULL;
     483             :         zend_string *name;
     484    60445189 :         int ret = SUCCESS;
     485             : 
     486             : #if 0
     487             :         printf("Registering constant for module %d\n", c->module_number);
     488             : #endif
     489             : 
     490    60445189 :         if (!(c->flags & CONST_CS)) {
     491     2060666 :                 lowercase_name = zend_string_alloc(ZSTR_LEN(c->name), c->flags & CONST_PERSISTENT);
     492     1030333 :                 zend_str_tolower_copy(ZSTR_VAL(lowercase_name), ZSTR_VAL(c->name), ZSTR_LEN(c->name));
     493     1030333 :                 lowercase_name = zend_new_interned_string(lowercase_name);
     494     1030333 :                 name = lowercase_name;
     495             :         } else {
     496    59414856 :                 char *slash = strrchr(ZSTR_VAL(c->name), '\\');
     497    59414856 :                 if (slash) {
     498          98 :                         lowercase_name = zend_string_init(ZSTR_VAL(c->name), ZSTR_LEN(c->name), c->flags & CONST_PERSISTENT);
     499          49 :                         zend_str_tolower(ZSTR_VAL(lowercase_name), slash - ZSTR_VAL(c->name));
     500          49 :                         lowercase_name = zend_new_interned_string(lowercase_name);
     501          49 :                         name = lowercase_name;
     502             :                 } else {
     503    59414807 :                         name = c->name;
     504             :                 }
     505             :         }
     506             : 
     507             :         /* Check if the user is trying to define the internal pseudo constant name __COMPILER_HALT_OFFSET__ */
     508   183044465 :         if ((ZSTR_LEN(c->name) == sizeof("__COMPILER_HALT_OFFSET__")-1
     509    62154090 :                 && !memcmp(ZSTR_VAL(name), "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1))
     510    60445186 :                 || zend_hash_add_constant(EG(zend_constants), name, c) == NULL) {
     511             : 
     512             :                 /* The internal __COMPILER_HALT_OFFSET__ is prefixed by NULL byte */
     513           8 :                 if (ZSTR_VAL(c->name)[0] == '\0' && ZSTR_LEN(c->name) > sizeof("\0__COMPILER_HALT_OFFSET__")-1
     514           0 :                         && memcmp(ZSTR_VAL(name), "\0__COMPILER_HALT_OFFSET__", sizeof("\0__COMPILER_HALT_OFFSET__")) == 0) {
     515             :                 }
     516           8 :                 zend_error(E_NOTICE,"Constant %s already defined", ZSTR_VAL(name));
     517           8 :                 zend_string_release(c->name);
     518           8 :                 if (!(c->flags & CONST_PERSISTENT)) {
     519           8 :                         zval_dtor(&c->value);
     520             :                 }
     521           8 :                 ret = FAILURE;
     522             :         }
     523    60445189 :         if (lowercase_name) {
     524             :                 zend_string_release(lowercase_name);
     525             :         }
     526    60445189 :         return ret;
     527             : }
     528             : 
     529             : 
     530             : /*
     531             :  * Local variables:
     532             :  * tab-width: 4
     533             :  * c-basic-offset: 4
     534             :  * indent-tabs-mode: t
     535             :  * End:
     536             :  */

Generated by: LCOV version 1.10

Generated at Wed, 20 Jul 2016 02:56:15 +0000 (5 days ago)

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