1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1998-2014 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
free_zend_constant(zend_constant * c)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
copy_zend_constant(zend_constant * c)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
zend_copy_constants(HashTable * target,HashTable * source)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
clean_non_persistent_constant(const zend_constant * c TSRMLS_DC)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
clean_non_persistent_constant_full(const zend_constant * c TSRMLS_DC)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
clean_module_constant(const zend_constant * c,int * module_number TSRMLS_DC)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
clean_module_constants(int module_number TSRMLS_DC)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
zend_startup_constants(TSRMLS_D)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
zend_register_standard_constants(TSRMLS_D)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
zend_shutdown_constants(TSRMLS_D)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
clean_non_persistent_constants(TSRMLS_D)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
zend_register_long_constant(const char * name,uint name_len,long lval,int flags,int module_number TSRMLS_DC)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
zend_register_double_constant(const char * name,uint name_len,double dval,int flags,int module_number TSRMLS_DC)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
zend_register_stringl_constant(const char * name,uint name_len,char * strval,uint strlen,int flags,int module_number TSRMLS_DC)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
zend_register_string_constant(const char * name,uint name_len,char * strval,int flags,int module_number TSRMLS_DC)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
zend_get_special_constant(const char * name,uint name_len,zend_constant ** c TSRMLS_DC)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
zend_get_constant(const char * name,uint name_len,zval * result TSRMLS_DC)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
zend_get_constant_ex(const char * name,uint name_len,zval * result,zend_class_entry * scope,ulong flags TSRMLS_DC)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
zend_quick_get_constant(const zend_literal * key,ulong flags TSRMLS_DC)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
zend_register_constant(zend_constant * c TSRMLS_DC)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 */
549
