/src/php-src/Zend/zend_constants.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | +----------------------------------------------------------------------+ |
3 | | | Zend Engine | |
4 | | +----------------------------------------------------------------------+ |
5 | | | Copyright (c) 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@php.net> | |
16 | | | Zeev Suraski <zeev@php.net> | |
17 | | +----------------------------------------------------------------------+ |
18 | | */ |
19 | | |
20 | | #include "zend.h" |
21 | | #include "zend_attributes.h" |
22 | | #include "zend_constants.h" |
23 | | #include "zend_exceptions.h" |
24 | | #include "zend_execute.h" |
25 | | #include "zend_variables.h" |
26 | | #include "zend_operators.h" |
27 | | #include "zend_globals.h" |
28 | | #include "zend_API.h" |
29 | | #include "zend_constants_arginfo.h" |
30 | | |
31 | | /* Protection from recursive self-referencing class constants */ |
32 | 700 | #define IS_CONSTANT_VISITED_MARK 0x80 |
33 | | |
34 | 239 | #define IS_CONSTANT_VISITED(zv) (Z_CONSTANT_FLAGS_P(zv) & IS_CONSTANT_VISITED_MARK) |
35 | 239 | #define MARK_CONSTANT_VISITED(zv) Z_CONSTANT_FLAGS_P(zv) |= IS_CONSTANT_VISITED_MARK |
36 | 222 | #define RESET_CONSTANT_VISITED(zv) Z_CONSTANT_FLAGS_P(zv) &= ~IS_CONSTANT_VISITED_MARK |
37 | | |
38 | | /* Use for special null/true/false constants. */ |
39 | | static zend_constant *null_const, *true_const, *false_const; |
40 | | |
41 | | void free_zend_constant(zval *zv) |
42 | 0 | { |
43 | 0 | zend_constant *c = Z_PTR_P(zv); |
44 | |
|
45 | 0 | if (!(ZEND_CONSTANT_FLAGS(c) & CONST_PERSISTENT)) { |
46 | 0 | zval_ptr_dtor_nogc(&c->value); |
47 | 0 | if (c->name) { |
48 | 0 | zend_string_release_ex(c->name, 0); |
49 | 0 | } |
50 | 0 | if (c->filename) { |
51 | 0 | zend_string_release_ex(c->filename, 0); |
52 | 0 | } |
53 | 0 | if (c->attributes) { |
54 | 0 | zend_hash_release(c->attributes); |
55 | 0 | } |
56 | 0 | efree(c); |
57 | 0 | } else { |
58 | 0 | zval_internal_ptr_dtor(&c->value); |
59 | 0 | if (c->name) { |
60 | 0 | zend_string_release_ex(c->name, 1); |
61 | 0 | } |
62 | 0 | if (c->filename) { |
63 | 0 | zend_string_release_ex(c->filename, 1); |
64 | 0 | } |
65 | 0 | if (c->attributes) { |
66 | 0 | zend_hash_release(c->attributes); |
67 | 0 | } |
68 | 0 | free(c); |
69 | 0 | } |
70 | 0 | } |
71 | | |
72 | | |
73 | | #ifdef ZTS |
74 | | static void copy_zend_constant(zval *zv) |
75 | | { |
76 | | zend_constant *c = Z_PTR_P(zv); |
77 | | |
78 | | ZEND_ASSERT(ZEND_CONSTANT_FLAGS(c) & CONST_PERSISTENT); |
79 | | Z_PTR_P(zv) = pemalloc(sizeof(zend_constant), 1); |
80 | | memcpy(Z_PTR_P(zv), c, sizeof(zend_constant)); |
81 | | |
82 | | c = Z_PTR_P(zv); |
83 | | c->name = zend_string_copy(c->name); |
84 | | if (c->filename != NULL) { |
85 | | c->filename = zend_string_copy(c->filename); |
86 | | } |
87 | | if (c->attributes != NULL) { |
88 | | // Use the same attributes table |
89 | | GC_ADDREF(c->attributes); |
90 | | } |
91 | | if (Z_TYPE(c->value) == IS_STRING) { |
92 | | Z_STR(c->value) = zend_string_dup(Z_STR(c->value), 1); |
93 | | } |
94 | | } |
95 | | |
96 | | |
97 | | void zend_copy_constants(HashTable *target, HashTable *source) |
98 | | { |
99 | | zend_hash_copy(target, source, copy_zend_constant); |
100 | | } |
101 | | #endif |
102 | | |
103 | | |
104 | | static int clean_module_constant(zval *el, void *arg) |
105 | 0 | { |
106 | 0 | zend_constant *c = (zend_constant *)Z_PTR_P(el); |
107 | 0 | int module_number = *(int *)arg; |
108 | |
|
109 | 0 | if (ZEND_CONSTANT_MODULE_NUMBER(c) == module_number) { |
110 | 0 | return ZEND_HASH_APPLY_REMOVE; |
111 | 0 | } else { |
112 | 0 | return ZEND_HASH_APPLY_KEEP; |
113 | 0 | } |
114 | 0 | } |
115 | | |
116 | | |
117 | | void clean_module_constants(int module_number) |
118 | 0 | { |
119 | 0 | zend_hash_apply_with_argument(EG(zend_constants), clean_module_constant, (void *) &module_number); |
120 | 0 | } |
121 | | |
122 | | void zend_startup_constants(void) |
123 | 0 | { |
124 | 0 | EG(zend_constants) = (HashTable *) malloc(sizeof(HashTable)); |
125 | 0 | zend_hash_init(EG(zend_constants), 128, NULL, ZEND_CONSTANT_DTOR, 1); |
126 | 0 | } |
127 | | |
128 | | |
129 | | |
130 | | void zend_register_standard_constants(void) |
131 | 16 | { |
132 | 16 | register_zend_constants_symbols(0); |
133 | | |
134 | 16 | true_const = zend_hash_str_find_ptr(EG(zend_constants), "TRUE", sizeof("TRUE")-1); |
135 | 16 | false_const = zend_hash_str_find_ptr(EG(zend_constants), "FALSE", sizeof("FALSE")-1); |
136 | 16 | null_const = zend_hash_str_find_ptr(EG(zend_constants), "NULL", sizeof("NULL")-1); |
137 | 16 | } |
138 | | |
139 | | ZEND_API void zend_register_null_constant(const char *name, size_t name_len, int flags, int module_number) |
140 | 16 | { |
141 | 16 | zend_constant c; |
142 | | |
143 | 16 | ZVAL_NULL(&c.value); |
144 | 16 | ZEND_CONSTANT_SET_FLAGS(&c, flags, module_number); |
145 | 16 | c.name = zend_string_init_interned(name, name_len, flags & CONST_PERSISTENT); |
146 | 16 | zend_register_constant(&c); |
147 | 16 | } |
148 | | |
149 | | ZEND_API void zend_register_bool_constant(const char *name, size_t name_len, bool bval, int flags, int module_number) |
150 | 112 | { |
151 | 112 | zend_constant c; |
152 | | |
153 | 112 | ZVAL_BOOL(&c.value, bval); |
154 | 112 | ZEND_CONSTANT_SET_FLAGS(&c, flags, module_number); |
155 | 112 | c.name = zend_string_init_interned(name, name_len, flags & CONST_PERSISTENT); |
156 | 112 | zend_register_constant(&c); |
157 | 112 | } |
158 | | |
159 | | ZEND_API void zend_register_long_constant(const char *name, size_t name_len, zend_long lval, int flags, int module_number) |
160 | 7.60k | { |
161 | 7.60k | zend_constant c; |
162 | | |
163 | 7.60k | ZVAL_LONG(&c.value, lval); |
164 | 7.60k | ZEND_CONSTANT_SET_FLAGS(&c, flags, module_number); |
165 | 7.60k | c.name = zend_string_init_interned(name, name_len, flags & CONST_PERSISTENT); |
166 | 7.60k | zend_register_constant(&c); |
167 | 7.60k | } |
168 | | |
169 | | |
170 | | ZEND_API void zend_register_double_constant(const char *name, size_t name_len, double dval, int flags, int module_number) |
171 | 352 | { |
172 | 352 | zend_constant c; |
173 | | |
174 | 352 | ZVAL_DOUBLE(&c.value, dval); |
175 | 352 | ZEND_CONSTANT_SET_FLAGS(&c, flags, module_number); |
176 | 352 | c.name = zend_string_init_interned(name, name_len, flags & CONST_PERSISTENT); |
177 | 352 | zend_register_constant(&c); |
178 | 352 | } |
179 | | |
180 | | |
181 | | ZEND_API void zend_register_stringl_constant(const char *name, size_t name_len, const char *strval, size_t strlen, int flags, int module_number) |
182 | 672 | { |
183 | 672 | zend_constant c; |
184 | | |
185 | 672 | ZVAL_STR(&c.value, zend_string_init_interned(strval, strlen, flags & CONST_PERSISTENT)); |
186 | 672 | ZEND_CONSTANT_SET_FLAGS(&c, flags, module_number); |
187 | 672 | c.name = zend_string_init_interned(name, name_len, flags & CONST_PERSISTENT); |
188 | 672 | zend_register_constant(&c); |
189 | 672 | } |
190 | | |
191 | | |
192 | | ZEND_API void zend_register_string_constant(const char *name, size_t name_len, const char *strval, int flags, int module_number) |
193 | 672 | { |
194 | 672 | zend_register_stringl_constant(name, name_len, strval, strlen(strval), flags, module_number); |
195 | 672 | } |
196 | | |
197 | | static zend_constant *zend_get_halt_offset_constant(const char *name, size_t name_len) |
198 | 151k | { |
199 | 151k | zend_constant *c; |
200 | 151k | static const char haltoff[] = "__COMPILER_HALT_OFFSET__"; |
201 | | |
202 | 151k | if (!EG(current_execute_data)) { |
203 | 16 | return NULL; |
204 | 151k | } else if (name_len == sizeof("__COMPILER_HALT_OFFSET__")-1 && |
205 | 151k | !memcmp(name, "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1)) { |
206 | 67.3k | const char *cfilename; |
207 | 67.3k | zend_string *haltname; |
208 | 67.3k | size_t clen; |
209 | | |
210 | 67.3k | cfilename = zend_get_executed_filename(); |
211 | 67.3k | clen = strlen(cfilename); |
212 | | /* check for __COMPILER_HALT_OFFSET__ */ |
213 | 67.3k | haltname = zend_mangle_property_name(haltoff, |
214 | 67.3k | sizeof("__COMPILER_HALT_OFFSET__") - 1, cfilename, clen, 0); |
215 | 67.3k | c = zend_hash_find_ptr(EG(zend_constants), haltname); |
216 | 67.3k | zend_string_efree(haltname); |
217 | 67.3k | return c; |
218 | 84.3k | } else { |
219 | 84.3k | return NULL; |
220 | 84.3k | } |
221 | 151k | } |
222 | | |
223 | | ZEND_API zend_constant *_zend_get_special_const(const char *name, size_t len) /* {{{ */ |
224 | 71.6k | { |
225 | 71.6k | if (len == 4) { |
226 | 44.9k | if ((name[0] == 'n' || name[0] == 'N') && |
227 | 44.9k | (name[1] == 'u' || name[1] == 'U') && |
228 | 44.9k | (name[2] == 'l' || name[2] == 'L') && |
229 | 44.9k | (name[3] == 'l' || name[3] == 'L') |
230 | 44.9k | ) { |
231 | 14.1k | return null_const; |
232 | 14.1k | } |
233 | 30.8k | if ((name[0] == 't' || name[0] == 'T') && |
234 | 30.8k | (name[1] == 'r' || name[1] == 'R') && |
235 | 30.8k | (name[2] == 'u' || name[2] == 'U') && |
236 | 30.8k | (name[3] == 'e' || name[3] == 'E') |
237 | 30.8k | ) { |
238 | 5.60k | return true_const; |
239 | 5.60k | } |
240 | 30.8k | } else { |
241 | 26.6k | if ((name[0] == 'f' || name[0] == 'F') && |
242 | 26.6k | (name[1] == 'a' || name[1] == 'A') && |
243 | 26.6k | (name[2] == 'l' || name[2] == 'L') && |
244 | 26.6k | (name[3] == 's' || name[3] == 'S') && |
245 | 26.6k | (name[4] == 'e' || name[4] == 'E') |
246 | 26.6k | ) { |
247 | 4.24k | return false_const; |
248 | 4.24k | } |
249 | 26.6k | } |
250 | 47.5k | return NULL; |
251 | 71.6k | } |
252 | | /* }}} */ |
253 | | |
254 | | ZEND_API bool zend_verify_const_access(zend_class_constant *c, zend_class_entry *scope) /* {{{ */ |
255 | 3.73k | { |
256 | 3.73k | if (ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_PUBLIC) { |
257 | 3.63k | return 1; |
258 | 3.63k | } else if (ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_PRIVATE) { |
259 | 71 | return (c->ce == scope); |
260 | 71 | } else { |
261 | 35 | ZEND_ASSERT(ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_PROTECTED); |
262 | 35 | return zend_check_protected(c->ce, scope); |
263 | 35 | } |
264 | 3.73k | } |
265 | | /* }}} */ |
266 | | |
267 | | static zend_constant *zend_get_constant_str_impl(const char *name, size_t name_len) |
268 | 67.4k | { |
269 | 67.4k | zend_constant *c = zend_hash_str_find_ptr(EG(zend_constants), name, name_len); |
270 | 67.4k | if (c) { |
271 | 109 | return c; |
272 | 109 | } |
273 | | |
274 | 67.3k | c = zend_get_halt_offset_constant(name, name_len); |
275 | 67.3k | if (c) { |
276 | 36 | return c; |
277 | 36 | } |
278 | | |
279 | 67.3k | return zend_get_special_const(name, name_len); |
280 | 67.3k | } |
281 | | |
282 | | ZEND_API zval *zend_get_constant_str(const char *name, size_t name_len) |
283 | 67.3k | { |
284 | 67.3k | zend_constant *c = zend_get_constant_str_impl(name, name_len); |
285 | 67.3k | if (c) { |
286 | 41 | return &c->value; |
287 | 41 | } |
288 | 67.3k | return NULL; |
289 | 67.3k | } |
290 | | |
291 | | ZEND_API zend_constant *zend_get_constant_ptr(zend_string *name) |
292 | 85.8k | { |
293 | 85.8k | zend_constant *c = zend_hash_find_ptr(EG(zend_constants), name); |
294 | 85.8k | if (c) { |
295 | 1.48k | return c; |
296 | 1.48k | } |
297 | | |
298 | 84.3k | c = zend_get_halt_offset_constant(ZSTR_VAL(name), ZSTR_LEN(name)); |
299 | 84.3k | if (c) { |
300 | 0 | return c; |
301 | 0 | } |
302 | | |
303 | 84.3k | return zend_get_special_const(ZSTR_VAL(name), ZSTR_LEN(name)); |
304 | 84.3k | } |
305 | | |
306 | | ZEND_API zval *zend_get_constant(zend_string *name) |
307 | 84.3k | { |
308 | 84.3k | zend_constant *c = zend_get_constant_ptr(name); |
309 | 84.3k | if (c) { |
310 | 2.05k | return &c->value; |
311 | 2.05k | } |
312 | 82.2k | return NULL; |
313 | 84.3k | } |
314 | | |
315 | | ZEND_API zval *zend_get_class_constant_ex(zend_string *class_name, zend_string *constant_name, zend_class_entry *scope, uint32_t flags) |
316 | 1.56k | { |
317 | 1.56k | zend_class_entry *ce = NULL; |
318 | 1.56k | zend_class_constant *c = NULL; |
319 | 1.56k | zval *ret_constant = NULL; |
320 | | |
321 | 1.56k | if (ZSTR_HAS_CE_CACHE(class_name)) { |
322 | 1.00k | ce = ZSTR_GET_CE_CACHE(class_name); |
323 | 1.00k | if (!ce) { |
324 | 166 | ce = zend_fetch_class(class_name, flags); |
325 | 166 | } |
326 | 1.00k | } else if (zend_string_equals_ci(class_name, ZSTR_KNOWN(ZEND_STR_SELF))) { |
327 | 278 | if (UNEXPECTED(!scope)) { |
328 | 0 | zend_throw_error(NULL, "Cannot access \"self\" when no class scope is active"); |
329 | 0 | goto failure; |
330 | 0 | } |
331 | 278 | ce = scope; |
332 | 278 | } else if (zend_string_equals_ci(class_name, ZSTR_KNOWN(ZEND_STR_PARENT))) { |
333 | 65 | if (UNEXPECTED(!scope)) { |
334 | 0 | zend_throw_error(NULL, "Cannot access \"parent\" when no class scope is active"); |
335 | 0 | goto failure; |
336 | 65 | } else if (UNEXPECTED(!scope->parent)) { |
337 | 5 | zend_throw_error(NULL, "Cannot access \"parent\" when current class scope has no parent"); |
338 | 5 | goto failure; |
339 | 60 | } else { |
340 | 60 | ce = scope->parent; |
341 | 60 | } |
342 | 210 | } else if (zend_string_equals_ci(class_name, ZSTR_KNOWN(ZEND_STR_STATIC))) { |
343 | 25 | ce = zend_get_called_scope(EG(current_execute_data)); |
344 | 25 | if (UNEXPECTED(!ce)) { |
345 | 0 | zend_throw_error(NULL, "Cannot access \"static\" when no class scope is active"); |
346 | 0 | goto failure; |
347 | 0 | } |
348 | 185 | } else { |
349 | 185 | ce = zend_fetch_class(class_name, flags); |
350 | 185 | } |
351 | 1.55k | if (ce) { |
352 | 1.45k | c = zend_hash_find_ptr(CE_CONSTANTS_TABLE(ce), constant_name); |
353 | 1.45k | if (c == NULL) { |
354 | 71 | if ((flags & ZEND_FETCH_CLASS_SILENT) == 0) { |
355 | 44 | zend_throw_error(NULL, "Undefined constant %s::%s", ZSTR_VAL(class_name), ZSTR_VAL(constant_name)); |
356 | 44 | goto failure; |
357 | 44 | } |
358 | 27 | ret_constant = NULL; |
359 | 1.38k | } else { |
360 | 1.38k | if (!zend_verify_const_access(c, scope)) { |
361 | 0 | if ((flags & ZEND_FETCH_CLASS_SILENT) == 0) { |
362 | 0 | zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(class_name), ZSTR_VAL(constant_name)); |
363 | 0 | } |
364 | 0 | goto failure; |
365 | 0 | } |
366 | | |
367 | 1.38k | if (UNEXPECTED(ce->ce_flags & ZEND_ACC_TRAIT)) { |
368 | | /** Prevent accessing trait constants directly on cases like \defined() or \constant(), etc. */ |
369 | 10 | if ((flags & ZEND_FETCH_CLASS_SILENT) == 0) { |
370 | 5 | zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(class_name), ZSTR_VAL(constant_name)); |
371 | 5 | } |
372 | 10 | goto failure; |
373 | 10 | } |
374 | | |
375 | 1.37k | if (UNEXPECTED(ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED)) { |
376 | 40 | if ((flags & ZEND_FETCH_CLASS_SILENT) == 0 && !CONST_IS_RECURSIVE(c)) { |
377 | 25 | if (c->ce->type == ZEND_USER_CLASS) { |
378 | | /* Recursion protection only applied to user constants, GH-18463 */ |
379 | 25 | CONST_PROTECT_RECURSION(c); |
380 | 25 | } |
381 | 25 | zend_deprecated_class_constant(c, constant_name); |
382 | 25 | if (c->ce->type == ZEND_USER_CLASS) { |
383 | 25 | CONST_UNPROTECT_RECURSION(c); |
384 | 25 | } |
385 | 25 | if (EG(exception)) { |
386 | 5 | goto failure; |
387 | 5 | } |
388 | 25 | } |
389 | 40 | } |
390 | 1.36k | ret_constant = &c->value; |
391 | 1.36k | } |
392 | 1.45k | } |
393 | | |
394 | 1.49k | if (ret_constant && Z_TYPE_P(ret_constant) == IS_CONSTANT_AST) { |
395 | 239 | zend_result ret; |
396 | | |
397 | 239 | if (IS_CONSTANT_VISITED(ret_constant)) { |
398 | 17 | zend_throw_error(NULL, "Cannot declare self-referencing constant %s::%s", ZSTR_VAL(class_name), ZSTR_VAL(constant_name)); |
399 | 17 | ret_constant = NULL; |
400 | 17 | goto failure; |
401 | 17 | } |
402 | | |
403 | 239 | MARK_CONSTANT_VISITED(ret_constant); |
404 | 222 | ret = zend_update_class_constant(c, constant_name, c->ce); |
405 | 222 | RESET_CONSTANT_VISITED(ret_constant); |
406 | | |
407 | 222 | if (UNEXPECTED(ret != SUCCESS)) { |
408 | 49 | ret_constant = NULL; |
409 | 49 | goto failure; |
410 | 49 | } |
411 | 222 | } |
412 | 1.55k | failure: |
413 | 1.55k | return ret_constant; |
414 | 1.49k | } |
415 | | |
416 | | ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope, uint32_t flags) |
417 | 2.04k | { |
418 | 2.04k | zend_constant *c; |
419 | 2.04k | const char *colon; |
420 | 2.04k | const char *name = ZSTR_VAL(cname); |
421 | 2.04k | size_t name_len = ZSTR_LEN(cname); |
422 | | |
423 | | /* Skip leading \\ */ |
424 | 2.04k | if (name[0] == '\\') { |
425 | 70 | name += 1; |
426 | 70 | name_len -= 1; |
427 | 70 | cname = NULL; |
428 | 70 | } |
429 | | |
430 | 2.04k | if ((colon = zend_memrchr(name, ':', name_len)) && |
431 | 2.04k | colon > name && (*(colon - 1) == ':')) { |
432 | 126 | int class_name_len = colon - name - 1; |
433 | 126 | size_t const_name_len = name_len - class_name_len - 2; |
434 | 126 | zend_string *constant_name = zend_string_init(colon + 1, const_name_len, 0); |
435 | 126 | zend_string *class_name = zend_string_init_interned(name, class_name_len, 0); |
436 | 126 | zval *ret_constant = zend_get_class_constant_ex(class_name, constant_name, scope, flags); |
437 | | |
438 | 126 | zend_string_release_ex(class_name, 0); |
439 | 126 | zend_string_efree(constant_name); |
440 | 126 | return ret_constant; |
441 | 126 | } |
442 | | |
443 | | /* non-class constant */ |
444 | 1.91k | if ((colon = zend_memrchr(name, '\\', name_len)) != NULL) { |
445 | | /* compound constant name */ |
446 | 605 | int prefix_len = colon - name; |
447 | 605 | size_t const_name_len = name_len - prefix_len - 1; |
448 | 605 | const char *constant_name = colon + 1; |
449 | 605 | char *lcname; |
450 | 605 | size_t lcname_len; |
451 | 605 | ALLOCA_FLAG(use_heap) |
452 | | |
453 | | /* Lowercase the namespace portion */ |
454 | 605 | lcname_len = prefix_len + 1 + const_name_len; |
455 | 605 | lcname = do_alloca(lcname_len + 1, use_heap); |
456 | 605 | zend_str_tolower_copy(lcname, name, prefix_len); |
457 | | |
458 | 605 | lcname[prefix_len] = '\\'; |
459 | 605 | memcpy(lcname + prefix_len + 1, constant_name, const_name_len + 1); |
460 | | |
461 | 605 | c = zend_hash_str_find_ptr(EG(zend_constants), lcname, lcname_len); |
462 | 605 | free_alloca(lcname, use_heap); |
463 | | |
464 | 605 | if (!c) { |
465 | 185 | if (flags & IS_CONSTANT_UNQUALIFIED_IN_NAMESPACE) { |
466 | | /* name requires runtime resolution, need to check non-namespaced name */ |
467 | 127 | c = zend_get_constant_str_impl(constant_name, const_name_len); |
468 | 127 | } |
469 | 185 | } |
470 | 1.30k | } else { |
471 | 1.30k | if (cname) { |
472 | 1.30k | c = zend_get_constant_ptr(cname); |
473 | 1.30k | } else { |
474 | 7 | c = zend_get_constant_str_impl(name, name_len); |
475 | 7 | } |
476 | 1.30k | } |
477 | | |
478 | 1.91k | if (!c) { |
479 | 281 | if (!(flags & ZEND_FETCH_CLASS_SILENT)) { |
480 | 208 | zend_throw_error(NULL, "Undefined constant \"%s\"", name); |
481 | 208 | } |
482 | 281 | return NULL; |
483 | 281 | } |
484 | | |
485 | 1.63k | if (!(flags & ZEND_FETCH_CLASS_SILENT) && (ZEND_CONSTANT_FLAGS(c) & CONST_DEPRECATED)) { |
486 | 30 | if (!CONST_IS_RECURSIVE(c)) { |
487 | 20 | CONST_PROTECT_RECURSION(c); |
488 | 20 | zend_deprecated_constant(c, c->name); |
489 | 20 | CONST_UNPROTECT_RECURSION(c); |
490 | 20 | } |
491 | 30 | } |
492 | 1.63k | return &c->value; |
493 | 1.91k | } |
494 | | |
495 | | static void* zend_hash_add_constant(HashTable *ht, zend_string *key, zend_constant *c) |
496 | 11.0k | { |
497 | 11.0k | void *ret; |
498 | 11.0k | zend_constant *copy = pemalloc(sizeof(zend_constant), ZEND_CONSTANT_FLAGS(c) & CONST_PERSISTENT); |
499 | | |
500 | 11.0k | memcpy(copy, c, sizeof(zend_constant)); |
501 | 11.0k | ret = zend_hash_add_ptr(ht, key, copy); |
502 | 11.0k | if (!ret) { |
503 | 52 | pefree(copy, ZEND_CONSTANT_FLAGS(c) & CONST_PERSISTENT); |
504 | 52 | } |
505 | 11.0k | return ret; |
506 | 11.0k | } |
507 | | |
508 | | ZEND_API zend_result zend_register_constant(zend_constant *c) |
509 | 11.0k | { |
510 | 11.0k | zend_string *lowercase_name = NULL; |
511 | 11.0k | zend_string *name; |
512 | 11.0k | zend_result ret = SUCCESS; |
513 | 11.0k | bool persistent = (ZEND_CONSTANT_FLAGS(c) & CONST_PERSISTENT) != 0; |
514 | | |
515 | | #if 0 |
516 | | printf("Registering constant for module %d\n", c->module_number); |
517 | | #endif |
518 | | |
519 | 11.0k | const char *slash = strrchr(ZSTR_VAL(c->name), '\\'); |
520 | 11.0k | if (slash) { |
521 | 340 | lowercase_name = zend_string_init(ZSTR_VAL(c->name), ZSTR_LEN(c->name), persistent); |
522 | 340 | zend_str_tolower(ZSTR_VAL(lowercase_name), slash - ZSTR_VAL(c->name)); |
523 | 340 | lowercase_name = zend_new_interned_string(lowercase_name); |
524 | 340 | name = lowercase_name; |
525 | 10.7k | } else { |
526 | 10.7k | name = c->name; |
527 | 10.7k | } |
528 | | |
529 | 11.0k | c->filename = NULL; |
530 | 11.0k | if (ZEND_CONSTANT_MODULE_NUMBER(c) == PHP_USER_CONSTANT) { |
531 | 2.31k | zend_string *filename = zend_get_executed_filename_ex(); |
532 | 2.31k | if (filename) { |
533 | 2.31k | c->filename = zend_string_copy(filename); |
534 | 2.31k | } |
535 | 2.31k | } |
536 | | |
537 | 11.0k | c->attributes = NULL; |
538 | | |
539 | | /* Check if the user is trying to define any special constant */ |
540 | 11.0k | if (zend_string_equals_literal(name, "__COMPILER_HALT_OFFSET__") |
541 | 11.0k | || (!persistent && zend_get_special_const(ZSTR_VAL(name), ZSTR_LEN(name))) |
542 | 11.0k | || zend_hash_add_constant(EG(zend_constants), name, c) == NULL |
543 | 11.0k | ) { |
544 | 81 | zend_error(E_WARNING, "Constant %s already defined", ZSTR_VAL(name)); |
545 | 81 | zend_string_release(c->name); |
546 | 81 | if (c->filename) { |
547 | 81 | zend_string_release(c->filename); |
548 | 81 | c->filename = NULL; |
549 | 81 | } |
550 | 81 | if (!persistent) { |
551 | 81 | zval_ptr_dtor_nogc(&c->value); |
552 | 81 | } |
553 | 81 | ret = FAILURE; |
554 | 81 | } |
555 | 11.0k | if (lowercase_name) { |
556 | 340 | zend_string_release(lowercase_name); |
557 | 340 | } |
558 | 11.0k | return ret; |
559 | 11.0k | } |
560 | | |
561 | 134 | void zend_constant_add_attributes(zend_constant *c, HashTable *attributes) { |
562 | 134 | GC_TRY_ADDREF(attributes); |
563 | 134 | c->attributes = attributes; |
564 | | |
565 | 134 | zend_attribute *deprecated_attribute = zend_get_attribute_str( |
566 | 134 | c->attributes, |
567 | 134 | "deprecated", |
568 | 134 | strlen("deprecated") |
569 | 134 | ); |
570 | | |
571 | 134 | if (deprecated_attribute) { |
572 | 79 | ZEND_CONSTANT_SET_FLAGS( |
573 | 79 | c, |
574 | 79 | ZEND_CONSTANT_FLAGS(c) | CONST_DEPRECATED, |
575 | 79 | ZEND_CONSTANT_MODULE_NUMBER(c) |
576 | 79 | ); |
577 | 79 | } |
578 | 134 | } |