LTP GCOV extension - code coverage report
Current view: directory - Zend - zend_constants.c
Test: PHP Code Coverage
Date: 2007-04-10 Instrumented lines: 186
Code covered: 62.9 % Executed lines: 117
Legend: not executed executed

       1                 : /*
       2                 :    +----------------------------------------------------------------------+
       3                 :    | Zend Engine                                                          |
       4                 :    +----------------------------------------------------------------------+
       5                 :    | Copyright (c) 1998-2007 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_constants.c,v 1.71.2.5.2.5 2007/04/04 00:42:42 iliaa Exp $ */
      21                 : 
      22                 : #include "zend.h"
      23                 : #include "zend_constants.h"
      24                 : #include "zend_execute.h"
      25                 : #include "zend_variables.h"
      26                 : #include "zend_operators.h"
      27                 : #include "zend_globals.h"
      28                 : 
      29                 : 
      30                 : void free_zend_constant(zend_constant *c)
      31          107904 : {
      32          107904 :         if (!(c->flags & CONST_PERSISTENT)) {
      33             156 :                 zval_dtor(&c->value);
      34                 :         }
      35          107904 :         free(c->name);
      36          107904 : }
      37                 : 
      38                 : 
      39                 : void copy_zend_constant(zend_constant *c)
      40               0 : {
      41               0 :         c->name = zend_strndup(c->name, c->name_len - 1);
      42               0 :         if (!(c->flags & CONST_PERSISTENT)) {
      43               0 :                 zval_copy_ctor(&c->value);
      44                 :         }
      45               0 : }
      46                 : 
      47                 : 
      48                 : void zend_copy_constants(HashTable *target, HashTable *source)
      49               0 : {
      50                 :         zend_constant tmp_constant;
      51                 : 
      52               0 :         zend_hash_copy(target, source, (copy_ctor_func_t) copy_zend_constant, &tmp_constant, sizeof(zend_constant));
      53               0 : }
      54                 : 
      55                 : 
      56                 : static int clean_non_persistent_constant(zend_constant *c TSRMLS_DC)
      57             369 : {
      58             369 :         return (c->flags & CONST_PERSISTENT) ? ZEND_HASH_APPLY_STOP : ZEND_HASH_APPLY_REMOVE;
      59                 : }
      60                 : 
      61                 : 
      62                 : static int clean_non_persistent_constant_full(zend_constant *c TSRMLS_DC)
      63               0 : {
      64               0 :         return (c->flags & CONST_PERSISTENT) ? 0 : 1;
      65                 : }
      66                 : 
      67                 : 
      68                 : static int clean_module_constant(zend_constant *c, int *module_number TSRMLS_DC)
      69               0 : {
      70               0 :         if (c->module_number == *module_number) {
      71               0 :                 return 1;
      72                 :         } else {
      73               0 :                 return 0;
      74                 :         }
      75                 : }
      76                 : 
      77                 : 
      78                 : void clean_module_constants(int module_number TSRMLS_DC)
      79               0 : {
      80               0 :         zend_hash_apply_with_argument(EG(zend_constants), (apply_func_arg_t) clean_module_constant, (void *) &module_number TSRMLS_CC);
      81               0 : }
      82                 : 
      83                 : 
      84                 : int zend_startup_constants(TSRMLS_D)
      85             220 : {
      86             220 :         EG(zend_constants) = (HashTable *) malloc(sizeof(HashTable));
      87                 : 
      88             220 :         if (zend_hash_init(EG(zend_constants), 20, NULL, ZEND_CONSTANT_DTOR, 1)==FAILURE) {
      89               0 :                 return FAILURE;
      90                 :         }
      91             220 :         return SUCCESS;
      92                 : }
      93                 : 
      94                 : 
      95                 : 
      96                 : void zend_register_standard_constants(TSRMLS_D)
      97             220 : {
      98             220 :         REGISTER_MAIN_LONG_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS);
      99             220 :         REGISTER_MAIN_LONG_CONSTANT("E_RECOVERABLE_ERROR", E_RECOVERABLE_ERROR, CONST_PERSISTENT | CONST_CS);
     100             220 :         REGISTER_MAIN_LONG_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS);
     101             220 :         REGISTER_MAIN_LONG_CONSTANT("E_PARSE", E_PARSE, CONST_PERSISTENT | CONST_CS);
     102             220 :         REGISTER_MAIN_LONG_CONSTANT("E_NOTICE", E_NOTICE, CONST_PERSISTENT | CONST_CS);
     103             220 :         REGISTER_MAIN_LONG_CONSTANT("E_STRICT", E_STRICT, CONST_PERSISTENT | CONST_CS);
     104             220 :         REGISTER_MAIN_LONG_CONSTANT("E_CORE_ERROR", E_CORE_ERROR, CONST_PERSISTENT | CONST_CS);
     105             220 :         REGISTER_MAIN_LONG_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS);
     106             220 :         REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS);
     107             220 :         REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS);
     108             220 :         REGISTER_MAIN_LONG_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS);
     109             220 :         REGISTER_MAIN_LONG_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS);
     110             220 :         REGISTER_MAIN_LONG_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS);
     111                 : 
     112             220 :         REGISTER_MAIN_LONG_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS);
     113                 : 
     114                 :         /* true/false constants */
     115                 :         {
     116                 :                 zend_constant c;
     117                 :         
     118             220 :                 c.flags = CONST_PERSISTENT | CONST_CT_SUBST;
     119             220 :                 c.module_number = 0;
     120                 : 
     121             220 :                 c.name = zend_strndup(ZEND_STRL("TRUE"));
     122             220 :                 c.name_len = sizeof("TRUE");
     123             220 :                 c.value.value.lval = 1;
     124             220 :                 c.value.type = IS_BOOL;
     125             220 :                 zend_register_constant(&c TSRMLS_CC);
     126                 :                 
     127             220 :                 c.name = zend_strndup(ZEND_STRL("FALSE"));
     128             220 :                 c.name_len = sizeof("FALSE");
     129             220 :                 c.value.value.lval = 0;
     130             220 :                 c.value.type = IS_BOOL;
     131             220 :                 zend_register_constant(&c TSRMLS_CC);
     132                 : 
     133             220 :                 c.name = zend_strndup(ZEND_STRL("NULL"));
     134             220 :                 c.name_len = sizeof("NULL");
     135             220 :                 c.value.type = IS_NULL;
     136             220 :                 zend_register_constant(&c TSRMLS_CC);
     137                 : 
     138             220 :                 c.flags = CONST_PERSISTENT;
     139                 : 
     140             220 :                 c.name = zend_strndup(ZEND_STRL("ZEND_THREAD_SAFE"));
     141             220 :                 c.name_len = sizeof("ZEND_THREAD_SAFE");
     142             220 :                 c.value.value.lval = ZTS_V;
     143             220 :                 c.value.type = IS_BOOL;
     144             220 :                 zend_register_constant(&c TSRMLS_CC);
     145                 :         }
     146             220 : }
     147                 : 
     148                 : 
     149                 : int zend_shutdown_constants(TSRMLS_D)
     150               0 : {
     151               0 :         zend_hash_destroy(EG(zend_constants));
     152               0 :         free(EG(zend_constants));
     153               0 :         return SUCCESS;
     154                 : }
     155                 : 
     156                 : 
     157                 : void clean_non_persistent_constants(TSRMLS_D)
     158             219 : {
     159             219 :         if (EG(full_tables_cleanup)) {
     160               0 :                 zend_hash_apply(EG(zend_constants), (apply_func_t) clean_non_persistent_constant_full TSRMLS_CC);
     161                 :         } else {
     162             219 :                 zend_hash_reverse_apply(EG(zend_constants), (apply_func_t) clean_non_persistent_constant TSRMLS_CC);
     163                 :         }
     164             219 : }
     165                 : 
     166                 : 
     167                 : ZEND_API void zend_register_long_constant(char *name, uint name_len, long lval, int flags, int module_number TSRMLS_DC)
     168           96146 : {
     169                 :         zend_constant c;
     170                 :         
     171           96146 :         c.value.type = IS_LONG;
     172           96146 :         c.value.value.lval = lval;
     173           96146 :         c.flags = flags;
     174           96146 :         c.name = zend_strndup(name, name_len-1);
     175           96146 :         c.name_len = name_len;
     176           96146 :         c.module_number = module_number;
     177           96146 :         zend_register_constant(&c TSRMLS_CC);
     178           96146 : }
     179                 : 
     180                 : 
     181                 : ZEND_API void zend_register_double_constant(char *name, uint name_len, double dval, int flags, int module_number TSRMLS_DC)
     182            4180 : {
     183                 :         zend_constant c;
     184                 :         
     185            4180 :         c.value.type = IS_DOUBLE;
     186            4180 :         c.value.value.dval = dval;
     187            4180 :         c.flags = flags;
     188            4180 :         c.name = zend_strndup(name, name_len-1);
     189            4180 :         c.name_len = name_len;
     190            4180 :         c.module_number = module_number;
     191            4180 :         zend_register_constant(&c TSRMLS_CC);
     192            4180 : }
     193                 : 
     194                 : 
     195                 : ZEND_API void zend_register_stringl_constant(char *name, uint name_len, char *strval, uint strlen, int flags, int module_number TSRMLS_DC)
     196            7041 : {
     197                 :         zend_constant c;
     198                 :         
     199            7041 :         c.value.type = IS_STRING;
     200            7041 :         c.value.value.str.val = strval;
     201            7041 :         c.value.value.str.len = strlen;
     202            7041 :         c.flags = flags;
     203            7041 :         c.name = zend_strndup(name, name_len-1);
     204            7041 :         c.name_len = name_len;
     205            7041 :         c.module_number = module_number;
     206            7041 :         zend_register_constant(&c TSRMLS_CC);
     207            7041 : }
     208                 : 
     209                 : 
     210                 : ZEND_API void zend_register_string_constant(char *name, uint name_len, char *strval, int flags, int module_number TSRMLS_DC)
     211            3300 : {
     212            3300 :         zend_register_stringl_constant(name, name_len, strval, strlen(strval), flags, module_number TSRMLS_CC);
     213            3300 : }
     214                 : 
     215                 : 
     216                 : ZEND_API int zend_get_constant_ex(char *name, uint name_len, zval *result, zend_class_entry *scope TSRMLS_DC)
     217            4356 : {
     218                 :         zend_constant *c;
     219            4356 :         int retval = 1;
     220                 :         char *lookup_name;
     221                 :         char *colon;
     222                 : 
     223            4356 :         if ((colon = memchr(name, ':', name_len)) && colon[1] == ':') {
     224                 :                 /* class constant */
     225               0 :                 zend_class_entry **ce = NULL;
     226               0 :                 int class_name_len = colon-name;
     227               0 :                 int const_name_len = name_len - class_name_len - 2;
     228               0 :                 char *constant_name = colon+2;
     229                 :                 zval **ret_constant;
     230                 :                 char *class_name;
     231                 : 
     232               0 :                 if (!scope) {
     233               0 :                         if (EG(in_execution)) {
     234               0 :                                 scope = EG(scope);
     235                 :                         } else {
     236               0 :                                 scope = CG(active_class_entry);
     237                 :                         }
     238                 :                 }
     239                 :         
     240               0 :                 class_name = estrndup(name, class_name_len);
     241                 : 
     242               0 :                 if (class_name_len == sizeof("self")-1 && strcmp(class_name, "self") == 0) {
     243               0 :                         if (scope) {
     244               0 :                                 ce = &scope;
     245                 :                         } else {
     246               0 :                                 zend_error(E_ERROR, "Cannot access self:: when no class scope is active");
     247               0 :                                 retval = 0;
     248                 :                         }
     249               0 :                 } else if (class_name_len == sizeof("parent")-1 && strcmp(class_name, "parent") == 0) {
     250               0 :                         if (!scope) {            
     251               0 :                                 zend_error(E_ERROR, "Cannot access parent:: when no class scope is active");
     252               0 :                         } else if (!scope->parent) {          
     253               0 :                                 zend_error(E_ERROR, "Cannot access parent:: when current class scope has no parent");          
     254                 :                         } else {
     255               0 :                                 ce = &scope->parent;
     256                 :                         }
     257                 :                 } else {
     258               0 :                         if (zend_lookup_class(class_name, class_name_len, &ce TSRMLS_CC) != SUCCESS) {
     259               0 :                                 retval = 0;
     260                 :                         }
     261                 :                 }
     262               0 :                 efree(class_name);
     263                 : 
     264               0 :                 if (retval && ce) {
     265               0 :                         if (zend_hash_find(&((*ce)->constants_table), constant_name, const_name_len+1, (void **) &ret_constant) != SUCCESS) {
     266               0 :                                 retval = 0;
     267                 :                         }
     268                 :                 } else {
     269               0 :                         retval = 0;
     270                 :                 }
     271                 : 
     272               0 :                 if (retval) {
     273               0 :                         zval_update_constant(ret_constant, (void*)1 TSRMLS_CC);
     274               0 :                         *result = **ret_constant;
     275               0 :                         zval_copy_ctor(result);
     276                 :                 }
     277                 : 
     278               0 :                 return retval;
     279                 :         }
     280                 : 
     281            4356 :         if (zend_hash_find(EG(zend_constants), name, name_len+1, (void **) &c) == FAILURE) {
     282            2296 :                 lookup_name = estrndup(name, name_len);
     283            2296 :                 zend_str_tolower(lookup_name, name_len);
     284                 :                  
     285            2296 :                 if (zend_hash_find(EG(zend_constants), lookup_name, name_len+1, (void **) &c)==SUCCESS) {
     286               0 :                         if ((c->flags & CONST_CS) && memcmp(c->name, name, name_len)!=0) {
     287               0 :                                 retval=0;
     288                 :                         }
     289                 :                 } else {
     290            2296 :                         char haltoff[] = "__COMPILER_HALT_OFFSET__";
     291            2296 :                         if (!EG(in_execution)) {
     292            2188 :                                 retval = 0;
     293             108 :                         } else if (name_len == sizeof("__COMPILER_HALT_OFFSET__") - 1 && memcmp(haltoff, name, name_len) == 0) {
     294                 :                                 char *cfilename, *haltname;
     295                 :                                 int len, clen;
     296               0 :                                 cfilename = zend_get_executed_filename(TSRMLS_C);
     297               0 :                                 clen = strlen(cfilename);
     298                 :                                 /* check for __COMPILER_HALT_OFFSET__ */
     299               0 :                                 zend_mangle_property_name(&haltname, &len, haltoff,
     300                 :                                         sizeof("__COMPILER_HALT_OFFSET__") - 1, cfilename, clen, 0);
     301               0 :                                 if (zend_hash_find(EG(zend_constants), haltname, len+1, (void **) &c) == SUCCESS) {
     302               0 :                                         retval = 1;
     303                 :                                 } else {
     304               0 :                                         retval=0;
     305                 :                                 }
     306               0 :                                 pefree(haltname, 0);
     307                 :                         } else {
     308             108 :                                 retval = 0;
     309                 :                         }
     310                 :                 }
     311            2296 :                 efree(lookup_name);
     312                 :         }
     313                 : 
     314            4356 :         if (retval) {
     315            2060 :                 *result = c->value;
     316            2060 :                 zval_copy_ctor(result);
     317            2060 :                 result->refcount = 1;
     318            2060 :                 result->is_ref = 0;
     319                 :         }
     320                 : 
     321            4356 :         return retval;
     322                 : }
     323                 : 
     324                 : ZEND_API int zend_get_constant(char *name, uint name_len, zval *result TSRMLS_DC)
     325            4356 : {
     326            4356 :     return zend_get_constant_ex(name, name_len, result, NULL TSRMLS_CC);
     327                 : }
     328                 : 
     329                 : ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC)
     330          108396 : {
     331          108396 :         char *lowercase_name = NULL;
     332                 :         char *name;
     333          108396 :         int ret = SUCCESS;
     334                 : 
     335                 : #if 0
     336                 :         printf("Registering constant for module %d\n", c->module_number);
     337                 : #endif
     338                 : 
     339          108396 :         if (!(c->flags & CONST_CS)) {
     340                 :                 /* keep in mind that c->name_len already contains the '\0' */
     341             881 :                 lowercase_name = estrndup(c->name, c->name_len-1);
     342             881 :                 zend_str_tolower(lowercase_name, c->name_len-1);
     343             881 :                 name = lowercase_name;
     344                 :         } else {
     345          107515 :                 name = c->name;
     346                 :         }
     347                 : 
     348          108396 :         if ((strncmp(name, "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1) == 0) ||
     349                 :                         zend_hash_add(EG(zend_constants), name, c->name_len, (void *) c, sizeof(zend_constant), NULL)==FAILURE) {
     350               0 :                 zend_error(E_NOTICE,"Constant %s already defined", name);
     351               0 :                 free(c->name);
     352               0 :                 if (!(c->flags & CONST_PERSISTENT)) {
     353               0 :                         zval_dtor(&c->value);
     354                 :                 }
     355               0 :                 ret = FAILURE;
     356                 :         }
     357          108396 :         if (lowercase_name) {
     358             881 :                 efree(lowercase_name);
     359                 :         }
     360          108396 :         return ret;
     361                 : }
     362                 : 
     363                 : 
     364                 : /*
     365                 :  * Local variables:
     366                 :  * tab-width: 4
     367                 :  * c-basic-offset: 4
     368                 :  * indent-tabs-mode: t
     369                 :  * End:
     370                 :  */

Generated by: LTP GCOV extension version 1.5