release/src/router/php/Zend/zend_constants.c

   1 /*
   2    +----------------------------------------------------------------------+
   3    | Zend Engine                                                          |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 2.00 of the Zend license,     |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.zend.com/license/2_00.txt.                                |
  11    | If you did not receive a copy of the Zend license and are unable to  |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@zend.com so we can mail you a copy immediately.              |
  14    +----------------------------------------------------------------------+
  15    | Authors: Andi Gutmans <andi@zend.com>                                |
  16    |          Zeev Suraski <zeev@zend.com>                                |
  17    +----------------------------------------------------------------------+
  18 */
  19
  20 /* $Id$ */
  21
  22 #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 {
  32         if (!(c->flags & CONST_PERSISTENT)) {
  33                 zval_dtor(&c->value);
  34         }
  35         str_free(c->name);
  36 }
  37
  38
  39 void copy_zend_constant(zend_constant *c)
  40 {
  41         if (!IS_INTERNED(c->name)) {
  42                 c->name = zend_strndup(c->name, c->name_len - 1);
  43         }
  44         if (!(c->flags & CONST_PERSISTENT)) {
  45                 zval_copy_ctor(&c->value);
  46         }
  47 }
  48
  49
  50 void zend_copy_constants(HashTable *target, HashTable *source)
  51 {
  52         zend_constant tmp_constant;
  53
  54         zend_hash_copy(target, source, (copy_ctor_func_t) copy_zend_constant, &tmp_constant, sizeof(zend_constant));
  55 }
  56
  57
  58 static int clean_non_persistent_constant(const zend_constant *c TSRMLS_DC)
  59 {
  60         return (c->flags & CONST_PERSISTENT) ? ZEND_HASH_APPLY_STOP : ZEND_HASH_APPLY_REMOVE;
  61 }
  62
  63
  64 static int clean_non_persistent_constant_full(const zend_constant *c TSRMLS_DC)
  65 {
  66         return (c->flags & CONST_PERSISTENT) ? 0 : 1;
  67 }
  68
  69
  70 static int clean_module_constant(const zend_constant *c, int *module_number TSRMLS_DC)
  71 {
  72         if (c->module_number == *module_number) {
  73                 return 1;
  74         } else {
  75                 return 0;
  76         }
  77 }
  78
  79
  80 void clean_module_constants(int module_number TSRMLS_DC)
  81 {
  82         zend_hash_apply_with_argument(EG(zend_constants), (apply_func_arg_t) clean_module_constant, (void *) &module_number TSRMLS_CC);
  83 }
  84
  85
  86 int zend_startup_constants(TSRMLS_D)
  87 {
  88         EG(zend_constants) = (HashTable *) malloc(sizeof(HashTable));
  89
  90         if (zend_hash_init(EG(zend_constants), 20, NULL, ZEND_CONSTANT_DTOR, 1)==FAILURE) {
  91                 return FAILURE;
  92         }
  93         return SUCCESS;
  94 }
  95
  96
  97
  98 void zend_register_standard_constants(TSRMLS_D)
  99 {
 100         REGISTER_MAIN_LONG_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS);
 101         REGISTER_MAIN_LONG_CONSTANT("E_RECOVERABLE_ERROR", E_RECOVERABLE_ERROR, CONST_PERSISTENT | CONST_CS);
 102         REGISTER_MAIN_LONG_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS);
 103         REGISTER_MAIN_LONG_CONSTANT("E_PARSE", E_PARSE, CONST_PERSISTENT | CONST_CS);
 104         REGISTER_MAIN_LONG_CONSTANT("E_NOTICE", E_NOTICE, CONST_PERSISTENT | CONST_CS);
 105         REGISTER_MAIN_LONG_CONSTANT("E_STRICT", E_STRICT, CONST_PERSISTENT | CONST_CS);
 106         REGISTER_MAIN_LONG_CONSTANT("E_DEPRECATED", E_DEPRECATED, CONST_PERSISTENT | CONST_CS);
 107         REGISTER_MAIN_LONG_CONSTANT("E_CORE_ERROR", E_CORE_ERROR, CONST_PERSISTENT | CONST_CS);
 108         REGISTER_MAIN_LONG_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS);
 109         REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS);
 110         REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS);
 111         REGISTER_MAIN_LONG_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS);
 112         REGISTER_MAIN_LONG_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS);
 113         REGISTER_MAIN_LONG_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS);
 114         REGISTER_MAIN_LONG_CONSTANT("E_USER_DEPRECATED", E_USER_DEPRECATED, CONST_PERSISTENT | CONST_CS);
 115
 116         REGISTER_MAIN_LONG_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS);
 117
 118         REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_PROVIDE_OBJECT", DEBUG_BACKTRACE_PROVIDE_OBJECT, CONST_PERSISTENT | CONST_CS);
 119         REGISTER_MAIN_LONG_CONSTANT("DEBUG_BACKTRACE_IGNORE_ARGS", DEBUG_BACKTRACE_IGNORE_ARGS, CONST_PERSISTENT | CONST_CS);
 120         /* true/false constants */
 121         {
 122                 zend_constant c;
 123
 124                 c.flags = CONST_PERSISTENT | CONST_CT_SUBST;
 125                 c.module_number = 0;
 126
 127                 c.name = zend_strndup(ZEND_STRL("TRUE"));
 128                 c.name_len = sizeof("TRUE");
 129                 c.value.value.lval = 1;
 130                 c.value.type = IS_BOOL;
 131                 zend_register_constant(&c TSRMLS_CC);
 132
 133                 c.name = zend_strndup(ZEND_STRL("FALSE"));
 134                 c.name_len = sizeof("FALSE");
 135                 c.value.value.lval = 0;
 136                 c.value.type = IS_BOOL;
 137                 zend_register_constant(&c TSRMLS_CC);
 138
 139                 c.name = zend_strndup(ZEND_STRL("NULL"));
 140                 c.name_len = sizeof("NULL");
 141                 c.value.type = IS_NULL;
 142                 zend_register_constant(&c TSRMLS_CC);
 143
 144                 c.flags = CONST_PERSISTENT | CONST_CS;
 145
 146                 c.name = zend_strndup(ZEND_STRL("ZEND_THREAD_SAFE"));
 147                 c.name_len = sizeof("ZEND_THREAD_SAFE");
 148                 c.value.value.lval = ZTS_V;
 149                 c.value.type = IS_BOOL;
 150                 zend_register_constant(&c TSRMLS_CC);
 151
 152                 c.name = zend_strndup(ZEND_STRL("ZEND_DEBUG_BUILD"));
 153                 c.name_len = sizeof("ZEND_DEBUG_BUILD");
 154                 c.value.value.lval = ZEND_DEBUG;
 155                 c.value.type = IS_BOOL;
 156                 zend_register_constant(&c TSRMLS_CC);
 157         }
 158 }
 159
 160
 161 int zend_shutdown_constants(TSRMLS_D)
 162 {
 163         zend_hash_destroy(EG(zend_constants));
 164         free(EG(zend_constants));
 165         return SUCCESS;
 166 }
 167
 168
 169 void clean_non_persistent_constants(TSRMLS_D)
 170 {
 171         if (EG(full_tables_cleanup)) {
 172                 zend_hash_apply(EG(zend_constants), (apply_func_t) clean_non_persistent_constant_full TSRMLS_CC);
 173         } else {
 174                 zend_hash_reverse_apply(EG(zend_constants), (apply_func_t) clean_non_persistent_constant TSRMLS_CC);
 175         }
 176 }
 177
 178
 179 ZEND_API void zend_register_long_constant(const char *name, uint name_len, long lval, int flags, int module_number TSRMLS_DC)
 180 {
 181         zend_constant c;
 182
 183         c.value.type = IS_LONG;
 184         c.value.value.lval = lval;
 185         c.flags = flags;
 186         c.name = zend_strndup(name, name_len-1);
 187         c.name_len = name_len;
 188         c.module_number = module_number;
 189         zend_register_constant(&c TSRMLS_CC);
 190 }
 191
 192
 193 ZEND_API void zend_register_double_constant(const char *name, uint name_len, double dval, int flags, int module_number TSRMLS_DC)
 194 {
 195         zend_constant c;
 196
 197         c.value.type = IS_DOUBLE;
 198         c.value.value.dval = dval;
 199         c.flags = flags;
 200         c.name = zend_strndup(name, name_len-1);
 201         c.name_len = name_len;
 202         c.module_number = module_number;
 203         zend_register_constant(&c TSRMLS_CC);
 204 }
 205
 206
 207 ZEND_API void zend_register_stringl_constant(const char *name, uint name_len, char *strval, uint strlen, int flags, int module_number TSRMLS_DC)
 208 {
 209         zend_constant c;
 210
 211         c.value.type = IS_STRING;
 212         c.value.value.str.val = strval;
 213         c.value.value.str.len = strlen;
 214         c.flags = flags;
 215         c.name = zend_strndup(name, name_len-1);
 216         c.name_len = name_len;
 217         c.module_number = module_number;
 218         zend_register_constant(&c TSRMLS_CC);
 219 }
 220
 221
 222 ZEND_API void zend_register_string_constant(const char *name, uint name_len, char *strval, int flags, int module_number TSRMLS_DC)
 223 {
 224         zend_register_stringl_constant(name, name_len, strval, strlen(strval), flags, module_number TSRMLS_CC);
 225 }
 226
 227 static int zend_get_special_constant(const char *name, uint name_len, zend_constant **c TSRMLS_DC)
 228 {
 229         int ret;
 230         static char haltoff[] = "__COMPILER_HALT_OFFSET__";
 231
 232         if (!EG(in_execution)) {
 233                 return 0;
 234         } else if (name_len == sizeof("__CLASS__")-1 &&
 235                   !memcmp(name, "__CLASS__", sizeof("__CLASS__")-1)) {
 236                 zend_constant tmp;
 237
 238                 /* Returned constants may be cached, so they have to be stored */
 239                 if (EG(scope) && EG(scope)->name) {
 240                         int const_name_len;
 241                         char *const_name;
 242                         ALLOCA_FLAG(use_heap)
 243
 244                         const_name_len = sizeof("\0__CLASS__") + EG(scope)->name_length;
 245                         const_name = do_alloca(const_name_len, use_heap);
 246                         memcpy(const_name, "\0__CLASS__", sizeof("\0__CLASS__")-1);
 247                         zend_str_tolower_copy(const_name + sizeof("\0__CLASS__")-1, EG(scope)->name, EG(scope)->name_length);
 248                         if (zend_hash_find(EG(zend_constants), const_name, const_name_len, (void**)c) == FAILURE) {
 249                                 zend_hash_add(EG(zend_constants), const_name, const_name_len, (void*)&tmp, sizeof(zend_constant), (void**)c);
 250                                 memset(*c, 0, sizeof(zend_constant));
 251                                 Z_STRVAL((**c).value) = estrndup(EG(scope)->name, EG(scope)->name_length);
 252                                 Z_STRLEN((**c).value) = EG(scope)->name_length;
 253                                 Z_TYPE((**c).value) = IS_STRING;
 254                         }
 255                         free_alloca(const_name, use_heap);
 256                 } else {
 257                         if (zend_hash_find(EG(zend_constants), "\0__CLASS__", sizeof("\0__CLASS__"), (void**)c) == FAILURE) {
 258                                 zend_hash_add(EG(zend_constants), "\0__CLASS__", sizeof("\0__CLASS__"), (void*)&tmp, sizeof(zend_constant), (void**)c);
 259                                 memset(*c, 0, sizeof(zend_constant));
 260                                 Z_STRVAL((**c).value) = estrndup("", 0);
 261                                 Z_STRLEN((**c).value) = 0;
 262                                 Z_TYPE((**c).value) = IS_STRING;
 263                         }
 264                 }
 265                 return 1;
 266         } else if (name_len == sizeof("__COMPILER_HALT_OFFSET__")-1 &&
 267                   !memcmp(name, "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1)) {
 268                 const char *cfilename;
 269                 char *haltname;
 270                 int len, clen;
 271
 272                 cfilename = zend_get_executed_filename(TSRMLS_C);
 273                 clen = strlen(cfilename);
 274                 /* check for __COMPILER_HALT_OFFSET__ */
 275                 zend_mangle_property_name(&haltname, &len, haltoff,
 276                         sizeof("__COMPILER_HALT_OFFSET__") - 1, cfilename, clen, 0);
 277                 ret = zend_hash_find(EG(zend_constants), haltname, len+1, (void **) c);
 278                 efree(haltname);
 279                 return (ret == SUCCESS);
 280         } else {
 281                 return 0;
 282         }
 283 }
 284
 285
 286 ZEND_API int zend_get_constant(const char *name, uint name_len, zval *result TSRMLS_DC)
 287 {
 288         zend_constant *c;
 289         int retval = 1;
 290         char *lookup_name;
 291
 292         if (zend_hash_find(EG(zend_constants), name, name_len+1, (void **) &c) == FAILURE) {
 293                 lookup_name = zend_str_tolower_dup(name, name_len);
 294
 295                 if (zend_hash_find(EG(zend_constants), lookup_name, name_len+1, (void **) &c)==SUCCESS) {
 296                         if (c->flags & CONST_CS) {
 297                                 retval=0;
 298                         }
 299                 } else {
 300                         retval = zend_get_special_constant(name, name_len, &c TSRMLS_CC);
 301                 }
 302                 efree(lookup_name);
 303         }
 304
 305         if (retval) {
 306                 *result = c->value;
 307                 zval_copy_ctor(result);
 308                 Z_SET_REFCOUNT_P(result, 1);
 309                 Z_UNSET_ISREF_P(result);
 310         }
 311
 312         return retval;
 313 }
 314
 315 ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result, zend_class_entry *scope, ulong flags TSRMLS_DC)
 316 {
 317         zend_constant *c;
 318         int retval = 1;
 319         const char *colon;
 320         zend_class_entry *ce = NULL;
 321         char *class_name;
 322         zval **ret_constant;
 323
 324         /* Skip leading \\ */
 325         if (name[0] == '\\') {
 326                 name += 1;
 327                 name_len -= 1;
 328         }
 329
 330
 331         if ((colon = zend_memrchr(name, ':', name_len)) &&
 332             colon > name && (*(colon - 1) == ':')) {
 333                 int class_name_len = colon - name - 1;
 334                 int const_name_len = name_len - class_name_len - 2;
 335                 const char *constant_name = colon + 1;
 336                 char *lcname;
 337
 338                 class_name = estrndup(name, class_name_len);
 339                 lcname = zend_str_tolower_dup(class_name, class_name_len);
 340                 if (!scope) {
 341                         if (EG(in_execution)) {
 342                                 scope = EG(scope);
 343                         } else {
 344                                 scope = CG(active_class_entry);
 345                         }
 346                 }
 347
 348                 if (class_name_len == sizeof("self")-1 &&
 349                     !memcmp(lcname, "self", sizeof("self")-1)) {
 350                         if (scope) {
 351                                 ce = scope;
 352                         } else {
 353                                 zend_error(E_ERROR, "Cannot access self:: when no class scope is active");
 354                                 retval = 0;
 355                         }
 356                         efree(lcname);
 357                 } else if (class_name_len == sizeof("parent")-1 &&
 358                            !memcmp(lcname, "parent", sizeof("parent")-1)) {
 359                         if (!scope) {
 360                                 zend_error(E_ERROR, "Cannot access parent:: when no class scope is active");
 361                         } else if (!scope->parent) {
 362                                 zend_error(E_ERROR, "Cannot access parent:: when current class scope has no parent");
 363                         } else {
 364                                 ce = scope->parent;
 365                         }
 366                         efree(lcname);
 367                 } else if (class_name_len == sizeof("static")-1 &&
 368                            !memcmp(lcname, "static", sizeof("static")-1)) {
 369                         if (EG(called_scope)) {
 370                                 ce = EG(called_scope);
 371                         } else {
 372                                 zend_error(E_ERROR, "Cannot access static:: when no class scope is active");
 373                         }
 374                         efree(lcname);
 375                 } else {
 376                         efree(lcname);
 377                         ce = zend_fetch_class(class_name, class_name_len, flags TSRMLS_CC);
 378                 }
 379                 if (retval && ce) {
 380                         if (zend_hash_find(&ce->constants_table, constant_name, const_name_len+1, (void **) &ret_constant) != SUCCESS) {
 381                                 retval = 0;
 382                                 if ((flags & ZEND_FETCH_CLASS_SILENT) == 0) {
 383                                         zend_error(E_ERROR, "Undefined class constant '%s::%s'", class_name, constant_name);
 384                                 }
 385                         }
 386                 } else if (!ce) {
 387                         retval = 0;
 388                 }
 389                 efree(class_name);
 390                 goto finish;
 391         }
 392
 393         /* non-class constant */
 394         if ((colon = zend_memrchr(name, '\\', name_len)) != NULL) {
 395                 /* compound constant name */
 396                 int prefix_len = colon - name;
 397                 int const_name_len = name_len - prefix_len - 1;
 398                 const char *constant_name = colon + 1;
 399                 char *lcname;
 400                 int found_const = 0;
 401
 402                 lcname = zend_str_tolower_dup(name, prefix_len);
 403                 /* Check for namespace constant */
 404
 405                 /* Concatenate lowercase namespace name and constant name */
 406                 lcname = erealloc(lcname, prefix_len + 1 + const_name_len + 1);
 407                 lcname[prefix_len] = '\\';
 408                 memcpy(lcname + prefix_len + 1, constant_name, const_name_len + 1);
 409
 410                 if (zend_hash_find(EG(zend_constants), lcname, prefix_len + 1 + const_name_len + 1, (void **) &c) == SUCCESS) {
 411                         found_const = 1;
 412                 } else {
 413                         /* try lowercase */
 414                         zend_str_tolower(lcname + prefix_len + 1, const_name_len);
 415                         if (zend_hash_find(EG(zend_constants), lcname, prefix_len + 1 + const_name_len + 1, (void **) &c) == SUCCESS) {
 416                                 if ((c->flags & CONST_CS) == 0) {
 417                                         found_const = 1;
 418                                 }
 419                         }
 420                 }
 421                 efree(lcname);
 422                 if(found_const) {
 423                         *result = c->value;
 424                         zval_update_constant_ex(&result, (void*)1, NULL TSRMLS_CC);
 425                         zval_copy_ctor(result);
 426                         Z_SET_REFCOUNT_P(result, 1);
 427                         Z_UNSET_ISREF_P(result);
 428                         return 1;
 429                 }
 430                 /* name requires runtime resolution, need to check non-namespaced name */
 431                 if ((flags & IS_CONSTANT_UNQUALIFIED) != 0) {
 432                         name = constant_name;
 433                         name_len = const_name_len;
 434                         return zend_get_constant(name, name_len, result TSRMLS_CC);
 435                 }
 436                 retval = 0;
 437 finish:
 438                 if (retval) {
 439                         zval_update_constant_ex(ret_constant, (void*)1, ce TSRMLS_CC);
 440                         *result = **ret_constant;
 441                         zval_copy_ctor(result);
 442                         INIT_PZVAL(result);
 443                 }
 444
 445                 return retval;
 446         }
 447
 448         return zend_get_constant(name, name_len, result TSRMLS_CC);
 449 }
 450
 451 zend_constant *zend_quick_get_constant(const zend_literal *key, ulong flags TSRMLS_DC)
 452 {
 453         zend_constant *c;
 454
 455         if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
 456                 key++;
 457                 if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
 458                     (c->flags & CONST_CS) != 0) {
 459                         if ((flags & (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) == (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) {
 460                                 key++;
 461                                 if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
 462                                     key++;
 463                                         if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
 464                                             (c->flags & CONST_CS) != 0) {
 465
 466                                                 key--;
 467                                                 if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
 468                                                         return NULL;
 469                                                 }
 470                                         }
 471                                 }
 472                         } else {
 473                                 key--;
 474                                 if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
 475                                         return NULL;
 476                                 }
 477                         }
 478                 }
 479         }
 480         return c;
 481 }
 482
 483 ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC)
 484 {
 485         char *lowercase_name = NULL;
 486         char *name;
 487         int ret = SUCCESS;
 488         ulong chash = 0;
 489
 490 #if 0
 491         printf("Registering constant for module %d\n", c->module_number);
 492 #endif
 493
 494         if (!(c->flags & CONST_CS)) {
 495                 /* keep in mind that c->name_len already contains the '\0' */
 496                 lowercase_name = estrndup(c->name, c->name_len-1);
 497                 zend_str_tolower(lowercase_name, c->name_len-1);
 498                 lowercase_name = (char*)zend_new_interned_string(lowercase_name, c->name_len, 1 TSRMLS_CC);
 499                 name = lowercase_name;
 500                 chash = IS_INTERNED(lowercase_name) ? INTERNED_HASH(lowercase_name) : 0;
 501         } else {
 502                 char *slash = strrchr(c->name, '\\');
 503                 if(slash) {
 504                         lowercase_name = estrndup(c->name, c->name_len-1);
 505                         zend_str_tolower(lowercase_name, slash-c->name);
 506                         lowercase_name = (char*)zend_new_interned_string(lowercase_name, c->name_len, 1 TSRMLS_CC);
 507                         name = lowercase_name;
 508
 509                         chash = IS_INTERNED(lowercase_name) ? INTERNED_HASH(lowercase_name) : 0;
 510                 } else {
 511                         name = c->name;
 512                 }
 513         }
 514         if (chash == 0) {
 515                 chash = zend_hash_func(name, c->name_len);
 516         }
 517
 518         /* Check if the user is trying to define the internal pseudo constant name __COMPILER_HALT_OFFSET__ */
 519         if ((c->name_len == sizeof("__COMPILER_HALT_OFFSET__")
 520                 && !memcmp(name, "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1))
 521                 || zend_hash_quick_add(EG(zend_constants), name, c->name_len, chash, (void *) c, sizeof(zend_constant), NULL)==FAILURE) {
 522
 523                 /* The internal __COMPILER_HALT_OFFSET__ is prefixed by NULL byte */
 524                 if (c->name[0] == '\0' && c->name_len > sizeof("\0__COMPILER_HALT_OFFSET__")
 525                         && memcmp(name, "\0__COMPILER_HALT_OFFSET__", sizeof("\0__COMPILER_HALT_OFFSET__")) == 0) {
 526                         name++;
 527                 }
 528                 zend_error(E_NOTICE,"Constant %s already defined", name);
 529                 str_free(c->name);
 530                 if (!(c->flags & CONST_PERSISTENT)) {
 531                         zval_dtor(&c->value);
 532                 }
 533                 ret = FAILURE;
 534         }
 535         if (lowercase_name && !IS_INTERNED(lowercase_name)) {
 536                 efree(lowercase_name);
 537         }
 538         return ret;
 539 }
 540
 541
 542 /*
 543  * Local variables:
 544  * tab-width: 4
 545  * c-basic-offset: 4
 546  * indent-tabs-mode: t
 547  * End:
 548  */