Coverage Report

Created: 2025-06-13 06:43

/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
}