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   |          Nikita Popov <nikic@php.net>                                |
18   +----------------------------------------------------------------------+
19*/
20
21/* $Id$ */
22
23#include <zend_language_parser.h>
24#include "zend.h"
25#include "zend_compile.h"
26#include "zend_constants.h"
27#include "zend_llist.h"
28#include "zend_API.h"
29#include "zend_exceptions.h"
30#include "zend_virtual_cwd.h"
31#include "zend_multibyte.h"
32#include "zend_language_scanner.h"
33#include "zend_inheritance.h"
34
35#define CONSTANT_EX(op_array, op) \
36    (op_array)->literals[op]
37
38#define CONSTANT(op) \
39    CONSTANT_EX(CG(active_op_array), op)
40
41#define SET_NODE(target, src) do { \
42        target ## _type = (src)->op_type; \
43        if ((src)->op_type == IS_CONST) { \
44            target.constant = zend_add_literal(CG(active_op_array), &(src)->u.constant TSRMLS_CC); \
45        } else { \
46            target = (src)->u.op; \
47        } \
48    } while (0)
49
50#define GET_NODE(target, src) do { \
51        (target)->op_type = src ## _type; \
52        if ((target)->op_type == IS_CONST) { \
53            (target)->u.constant = CONSTANT(src.constant); \
54        } else { \
55            (target)->u.op = src; \
56        } \
57    } while (0)
58
59static inline void zend_alloc_cache_slot(uint32_t literal TSRMLS_DC) {
60    zend_op_array *op_array = CG(active_op_array);
61    Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot++;
62}
63
64#define POLYMORPHIC_CACHE_SLOT_SIZE 2
65
66static inline void zend_alloc_polymorphic_cache_slot(uint32_t literal TSRMLS_DC) {
67    zend_op_array *op_array = CG(active_op_array);
68    Z_CACHE_SLOT(op_array->literals[literal]) = op_array->last_cache_slot;
69    op_array->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE;
70}
71
72ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
73ZEND_API zend_op_array *(*zend_compile_string)(zval *source_string, char *filename TSRMLS_DC);
74
75#ifndef ZTS
76ZEND_API zend_compiler_globals compiler_globals;
77ZEND_API zend_executor_globals executor_globals;
78#endif
79
80static void zend_destroy_property_info(zval *zv) /* {{{ */
81{
82    zend_property_info *property_info = Z_PTR_P(zv);
83
84    zend_string_release(property_info->name);
85    if (property_info->doc_comment) {
86        zend_string_release(property_info->doc_comment);
87    }
88}
89/* }}} */
90
91static void zend_destroy_property_info_internal(zval *zv) /* {{{ */
92{
93    zend_property_info *property_info = Z_PTR_P(zv);
94
95    zend_string_release(property_info->name);
96    free(property_info);
97}
98/* }}} */
99
100static zend_string *zend_new_interned_string_safe(zend_string *str TSRMLS_DC) /* {{{ */ {
101    zend_string *interned_str;
102
103    zend_string_addref(str);
104    interned_str = zend_new_interned_string(str TSRMLS_CC);
105    if (str != interned_str) {
106        return interned_str;
107    } else {
108        zend_string_release(str);
109        return str;
110    }
111}
112/* }}} */
113
114static zend_string *zend_build_runtime_definition_key(zend_string *name, unsigned char *lex_pos TSRMLS_DC) /* {{{ */
115{
116    zend_string *result;
117    char char_pos_buf[32];
118    size_t filename_len, char_pos_len = zend_sprintf(char_pos_buf, "%p", lex_pos);
119
120    const char *filename;
121    if (CG(active_op_array)->filename) {
122        filename = CG(active_op_array)->filename->val;
123        filename_len = CG(active_op_array)->filename->len;
124    } else {
125        filename = "-";
126        filename_len = sizeof("-") - 1;
127    }
128    /* NULL, name length, filename length, last accepting char position length */
129    result = zend_string_alloc(1 + name->len + filename_len + char_pos_len, 0);
130    sprintf(result->val, "%c%s%s%s", '\0', name->val, filename, char_pos_buf);
131    return zend_new_interned_string(result TSRMLS_CC);
132}
133/* }}} */
134
135static zend_bool zend_get_unqualified_name(const zend_string *name, const char **result, size_t *result_len) /* {{{ */
136{
137    const char *ns_separator = zend_memrchr(name->val, '\\', name->len);
138    if (ns_separator != NULL) {
139        *result = ns_separator + 1;
140        *result_len = name->val + name->len - *result;
141        return 1;
142    }
143
144    return 0;
145}
146/* }}} */
147
148static void init_compiler_declarables(TSRMLS_D) /* {{{ */
149{
150    ZVAL_LONG(&CG(declarables).ticks, 0);
151}
152/* }}} */
153
154void zend_init_compiler_context(TSRMLS_D) /* {{{ */
155{
156    CG(context).opcodes_size = INITIAL_OP_ARRAY_SIZE;
157    CG(context).vars_size = 0;
158    CG(context).literals_size = 0;
159    CG(context).current_brk_cont = -1;
160    CG(context).backpatch_count = 0;
161    CG(context).in_finally = 0;
162    CG(context).labels = NULL;
163}
164/* }}} */
165
166void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */
167{
168    zend_stack_init(&CG(loop_var_stack), sizeof(znode));
169    zend_stack_init(&CG(delayed_oplines_stack), sizeof(zend_op));
170    CG(active_class_entry) = NULL;
171    CG(in_compilation) = 0;
172    CG(start_lineno) = 0;
173    CG(current_namespace) = NULL;
174    CG(in_namespace) = 0;
175    CG(has_bracketed_namespaces) = 0;
176    CG(current_import) = NULL;
177    CG(current_import_function) = NULL;
178    CG(current_import_const) = NULL;
179    zend_hash_init(&CG(const_filenames), 8, NULL, NULL, 0);
180    init_compiler_declarables(TSRMLS_C);
181    zend_stack_init(&CG(context_stack), sizeof(CG(context)));
182
183    CG(encoding_declared) = 0;
184}
185/* }}} */
186
187ZEND_API void file_handle_dtor(zend_file_handle *fh) /* {{{ */
188{
189    TSRMLS_FETCH();
190
191    zend_file_handle_dtor(fh TSRMLS_CC);
192}
193/* }}} */
194
195void init_compiler(TSRMLS_D) /* {{{ */
196{
197    CG(arena) = zend_arena_create(64 * 1024);
198    CG(active_op_array) = NULL;
199    memset(&CG(context), 0, sizeof(CG(context)));
200    zend_init_compiler_data_structures(TSRMLS_C);
201    zend_init_rsrc_list(TSRMLS_C);
202    zend_hash_init(&CG(filenames_table), 8, NULL, free_string_zval, 0);
203    zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) file_handle_dtor, 0);
204    CG(unclean_shutdown) = 0;
205}
206/* }}} */
207
208void shutdown_compiler(TSRMLS_D) /* {{{ */
209{
210    zend_stack_destroy(&CG(loop_var_stack));
211    zend_stack_destroy(&CG(delayed_oplines_stack));
212    zend_hash_destroy(&CG(filenames_table));
213    zend_hash_destroy(&CG(const_filenames));
214    zend_stack_destroy(&CG(context_stack));
215    zend_arena_destroy(CG(arena));
216}
217/* }}} */
218
219ZEND_API zend_string *zend_set_compiled_filename(zend_string *new_compiled_filename TSRMLS_DC) /* {{{ */
220{
221    zend_string *p;
222
223    p = zend_hash_find_ptr(&CG(filenames_table), new_compiled_filename);
224    if (p != NULL) {
225        CG(compiled_filename) = p;
226        return p;
227    }
228    p = zend_string_copy(new_compiled_filename);
229    zend_hash_update_ptr(&CG(filenames_table), new_compiled_filename, p);
230    CG(compiled_filename) = p;
231    return p;
232}
233/* }}} */
234
235ZEND_API void zend_restore_compiled_filename(zend_string *original_compiled_filename TSRMLS_DC) /* {{{ */
236{
237    CG(compiled_filename) = original_compiled_filename;
238}
239/* }}} */
240
241ZEND_API zend_string *zend_get_compiled_filename(TSRMLS_D) /* {{{ */
242{
243    return CG(compiled_filename);
244}
245/* }}} */
246
247ZEND_API int zend_get_compiled_lineno(TSRMLS_D) /* {{{ */
248{
249    return CG(zend_lineno);
250}
251/* }}} */
252
253ZEND_API zend_bool zend_is_compiling(TSRMLS_D) /* {{{ */
254{
255    return CG(in_compilation);
256}
257/* }}} */
258
259static uint32_t get_temporary_variable(zend_op_array *op_array) /* {{{ */
260{
261    return (uint32_t)op_array->T++;
262}
263/* }}} */
264
265static int lookup_cv(zend_op_array *op_array, zend_string* name TSRMLS_DC) /* {{{ */{
266    int i = 0;
267    zend_ulong hash_value = zend_string_hash_val(name);
268
269    while (i < op_array->last_var) {
270        if (op_array->vars[i]->val == name->val ||
271            (op_array->vars[i]->h == hash_value &&
272             op_array->vars[i]->len == name->len &&
273             memcmp(op_array->vars[i]->val, name->val, name->len) == 0)) {
274            zend_string_release(name);
275            return (int)(zend_intptr_t)EX_VAR_NUM_2(NULL, i);
276        }
277        i++;
278    }
279    i = op_array->last_var;
280    op_array->last_var++;
281    if (op_array->last_var > CG(context).vars_size) {
282        CG(context).vars_size += 16; /* FIXME */
283        op_array->vars = erealloc(op_array->vars, CG(context).vars_size * sizeof(zend_string*));
284    }
285
286    op_array->vars[i] = zend_new_interned_string(name TSRMLS_CC);
287    return (int)(zend_intptr_t)EX_VAR_NUM_2(NULL, i);
288}
289/* }}} */
290
291void zend_del_literal(zend_op_array *op_array, int n) /* {{{ */
292{
293    zval_dtor(&CONSTANT_EX(op_array, n));
294    if (n + 1 == op_array->last_literal) {
295        op_array->last_literal--;
296    } else {
297        ZVAL_UNDEF(&CONSTANT_EX(op_array, n));
298    }
299}
300/* }}} */
301
302/* Common part of zend_add_literal and zend_append_individual_literal */
303static inline void zend_insert_literal(zend_op_array *op_array, zval *zv, int literal_position TSRMLS_DC) /* {{{ */
304{
305    if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_CONSTANT) {
306        zend_string_hash_val(Z_STR_P(zv));
307        Z_STR_P(zv) = zend_new_interned_string(Z_STR_P(zv) TSRMLS_CC);
308        if (IS_INTERNED(Z_STR_P(zv))) {
309            Z_TYPE_FLAGS_P(zv) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
310        }
311    }
312    ZVAL_COPY_VALUE(&CONSTANT_EX(op_array, literal_position), zv);
313    Z_CACHE_SLOT(op_array->literals[literal_position]) = -1;
314}
315/* }}} */
316
317/* Is used while compiling a function, using the context to keep track
318   of an approximate size to avoid to relocate to often.
319   Literals are truncated to actual size in the second compiler pass (pass_two()). */
320int zend_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */
321{
322    int i = op_array->last_literal;
323    op_array->last_literal++;
324    if (i >= CG(context).literals_size) {
325        while (i >= CG(context).literals_size) {
326            CG(context).literals_size += 16; /* FIXME */
327        }
328        op_array->literals = (zval*)erealloc(op_array->literals, CG(context).literals_size * sizeof(zval));
329    }
330    zend_insert_literal(op_array, zv, i TSRMLS_CC);
331    return i;
332}
333/* }}} */
334
335static inline int zend_add_literal_string(zend_op_array *op_array, zend_string **str TSRMLS_DC) /* {{{ */
336{
337    int ret;
338    zval zv;
339    ZVAL_STR(&zv, *str);
340    ret = zend_add_literal(op_array, &zv TSRMLS_CC);
341    *str = Z_STR(zv);
342    return ret;
343}
344
345static int zend_add_func_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) /* {{{ */
346{
347    /* Original name */
348    int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
349
350    /* Lowercased name */
351    zend_string *lc_name = zend_string_alloc(name->len, 0);
352    zend_str_tolower_copy(lc_name->val, name->val, name->len);
353    zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
354
355    return ret;
356}
357/* }}} */
358
359static int zend_add_ns_func_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) /* {{{ */
360{
361    const char *unqualified_name;
362    size_t unqualified_name_len;
363
364    /* Original name */
365    int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
366
367    /* Lowercased name */
368    zend_string *lc_name = zend_string_alloc(name->len, 0);
369    zend_str_tolower_copy(lc_name->val, name->val, name->len);
370    zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
371
372    /* Lowercased unqualfied name */
373    if (zend_get_unqualified_name(name, &unqualified_name, &unqualified_name_len)) {
374        lc_name = zend_string_alloc(unqualified_name_len, 0);
375        zend_str_tolower_copy(lc_name->val, unqualified_name, unqualified_name_len);
376        zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
377    }
378
379    return ret;
380}
381/* }}} */
382
383static int zend_add_class_name_literal(zend_op_array *op_array, zend_string *name TSRMLS_DC) /* {{{ */
384{
385    /* Original name */
386    int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
387
388    /* Lowercased name */
389    zend_string *lc_name = zend_string_alloc(name->len, 0);
390    zend_str_tolower_copy(lc_name->val, name->val, name->len);
391    zend_add_literal_string(op_array, &lc_name TSRMLS_CC);
392
393    zend_alloc_cache_slot(ret TSRMLS_CC);
394
395    return ret;
396}
397/* }}} */
398
399static int zend_add_const_name_literal(zend_op_array *op_array, zend_string *name, zend_bool unqualified TSRMLS_DC) /* {{{ */
400{
401    zend_string *tmp_name;
402
403    int ret = zend_add_literal_string(op_array, &name TSRMLS_CC);
404
405    size_t ns_len = 0, after_ns_len = name->len;
406    const char *after_ns = zend_memrchr(name->val, '\\', name->len);
407    if (after_ns) {
408        after_ns += 1;
409        ns_len = after_ns - name->val - 1;
410        after_ns_len = name->len - ns_len - 1;
411
412        /* lowercased namespace name & original constant name */
413        tmp_name = zend_string_init(name->val, name->len, 0);
414        zend_str_tolower(tmp_name->val, ns_len);
415        zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
416
417        /* lowercased namespace name & lowercased constant name */
418        tmp_name = zend_string_alloc(name->len, 0);
419        zend_str_tolower_copy(tmp_name->val, name->val, name->len);
420        zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
421
422        if (!unqualified) {
423            return ret;
424        }
425    } else {
426        after_ns = name->val;
427    }
428
429    /* original unqualified constant name */
430    tmp_name = zend_string_init(after_ns, after_ns_len, 0);
431    zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
432
433    /* lowercased unqualified constant name */
434    tmp_name = zend_string_alloc(after_ns_len, 0);
435    zend_str_tolower_copy(tmp_name->val, after_ns, after_ns_len);
436    zend_add_literal_string(op_array, &tmp_name TSRMLS_CC);
437
438    return ret;
439}
440/* }}} */
441
442#define LITERAL_STR(op, str) do { \
443        zval _c; \
444        ZVAL_STR(&_c, str); \
445        op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
446    } while (0)
447
448#define MAKE_NOP(opline) do { \
449    opline->opcode = ZEND_NOP; \
450    memset(&opline->result, 0, sizeof(opline->result)); \
451    memset(&opline->op1, 0, sizeof(opline->op1)); \
452    memset(&opline->op2, 0, sizeof(opline->op2)); \
453    opline->result_type = opline->op1_type = opline->op2_type = IS_UNUSED; \
454} while (0)
455
456void zend_stop_lexing(TSRMLS_D) {
457    LANG_SCNG(yy_cursor) = LANG_SCNG(yy_limit);
458}
459
460static inline void zend_begin_loop(TSRMLS_D) /* {{{ */
461{
462    zend_brk_cont_element *brk_cont_element;
463    int parent;
464
465    parent = CG(context).current_brk_cont;
466    CG(context).current_brk_cont = CG(active_op_array)->last_brk_cont;
467    brk_cont_element = get_next_brk_cont_element(CG(active_op_array));
468    brk_cont_element->start = get_next_op_number(CG(active_op_array));
469    brk_cont_element->parent = parent;
470}
471/* }}} */
472
473static inline void zend_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{ */
474{
475    if (!has_loop_var) {
476        /* The start fileld is used to free temporary variables in case of exceptions.
477         * We won't try to free something of we don't have loop variable.
478         */
479        CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].start = -1;
480    }
481    CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].cont = cont_addr;
482    CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].brk = get_next_op_number(CG(active_op_array));
483    CG(context).current_brk_cont = CG(active_op_array)->brk_cont_array[CG(context).current_brk_cont].parent;
484}
485/* }}} */
486
487void zend_do_free(znode *op1 TSRMLS_DC) /* {{{ */
488{
489    if (op1->op_type==IS_TMP_VAR) {
490        zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
491
492        opline->opcode = ZEND_FREE;
493        SET_NODE(opline->op1, op1);
494        SET_UNUSED(opline->op2);
495    } else if (op1->op_type==IS_VAR) {
496        zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
497
498        while (opline->opcode == ZEND_END_SILENCE || opline->opcode == ZEND_EXT_FCALL_END || opline->opcode == ZEND_OP_DATA) {
499            opline--;
500        }
501        if (opline->result_type == IS_VAR
502            && opline->result.var == op1->u.op.var) {
503            if (opline->opcode == ZEND_FETCH_R ||
504                opline->opcode == ZEND_FETCH_DIM_R ||
505                opline->opcode == ZEND_FETCH_OBJ_R) {
506                /* It's very rare and useless case. It's better to use
507                   additional FREE opcode and simplify the FETCH handlers
508                   their selves */
509                opline = get_next_op(CG(active_op_array) TSRMLS_CC);
510                opline->opcode = ZEND_FREE;
511                SET_NODE(opline->op1, op1);
512                SET_UNUSED(opline->op2);
513            } else {
514                opline->result_type |= EXT_TYPE_UNUSED;
515            }
516        } else {
517            while (opline >= CG(active_op_array)->opcodes) {
518                if (opline->opcode == ZEND_FETCH_LIST &&
519                    opline->op1_type == IS_VAR &&
520                    opline->op1.var == op1->u.op.var) {
521                    opline = get_next_op(CG(active_op_array) TSRMLS_CC);
522
523                    opline->opcode = ZEND_FREE;
524                    SET_NODE(opline->op1, op1);
525                    SET_UNUSED(opline->op2);
526                    return;
527                }
528                if (opline->result_type==IS_VAR
529                    && opline->result.var == op1->u.op.var) {
530                    if (opline->opcode == ZEND_NEW) {
531                        opline->result_type |= EXT_TYPE_UNUSED;
532                        opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
533                        while (opline->opcode != ZEND_DO_FCALL || opline->op1.num != ZEND_CALL_CTOR) {
534                            opline--;
535                        }
536                        opline->op1.num |= ZEND_CALL_CTOR_RESULT_UNUSED;
537                    }
538                    break;
539                }
540                opline--;
541            }
542        }
543    } else if (op1->op_type == IS_CONST) {
544        /* Destroy value without using GC: When opcache moves arrays into SHM it will
545         * free the zend_array structure, so references to it from outside the op array
546         * become invalid. GC would cause such a reference in the root buffer. */
547        zval_ptr_dtor_nogc(&op1->u.constant);
548    }
549}
550/* }}} */
551
552uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag) /* {{{ */
553{
554    uint32_t new_flags = flags | new_flag;
555    if ((flags & ZEND_ACC_PPP_MASK) && (new_flag & ZEND_ACC_PPP_MASK)) {
556        zend_error_noreturn(E_COMPILE_ERROR, "Multiple access type modifiers are not allowed");
557    }
558    if ((flags & ZEND_ACC_ABSTRACT) && (new_flag & ZEND_ACC_ABSTRACT)) {
559        zend_error_noreturn(E_COMPILE_ERROR, "Multiple abstract modifiers are not allowed");
560    }
561    if ((flags & ZEND_ACC_STATIC) && (new_flag & ZEND_ACC_STATIC)) {
562        zend_error_noreturn(E_COMPILE_ERROR, "Multiple static modifiers are not allowed");
563    }
564    if ((flags & ZEND_ACC_FINAL) && (new_flag & ZEND_ACC_FINAL)) {
565        zend_error_noreturn(E_COMPILE_ERROR, "Multiple final modifiers are not allowed");
566    }
567    if ((new_flags & ZEND_ACC_ABSTRACT) && (new_flags & ZEND_ACC_FINAL)) {
568        zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the final modifier on an abstract class member");
569    }
570    return new_flags;
571}
572/* }}} */
573
574zend_string *zend_concat3(char *str1, size_t str1_len, char *str2, size_t str2_len, char *str3, size_t str3_len) /* {{{ */
575{
576    size_t len = str1_len + str2_len + str3_len;
577    zend_string *res = zend_string_alloc(len, 0);
578
579    memcpy(res->val, str1, str1_len);
580    memcpy(res->val + str1_len, str2, str2_len);
581    memcpy(res->val + str1_len + str2_len, str3, str3_len);
582    res->val[len] = '\0';
583
584    return res;
585}
586
587zend_string *zend_concat_names(char *name1, size_t name1_len, char *name2, size_t name2_len) {
588    return zend_concat3(name1, name1_len, "\\", 1, name2, name2_len);
589}
590
591zend_string *zend_prefix_with_ns(zend_string *name TSRMLS_DC) {
592    if (CG(current_namespace)) {
593        zend_string *ns = CG(current_namespace);
594        return zend_concat_names(ns->val, ns->len, name->val, name->len);
595    } else {
596        return zend_string_copy(name);
597    }
598}
599
600void *zend_hash_find_ptr_lc(HashTable *ht, const char *str, size_t len) {
601    void *result;
602    zend_string *lcname;
603    ALLOCA_FLAG(use_heap);
604
605    STR_ALLOCA_ALLOC(lcname, len, use_heap);
606    zend_str_tolower_copy(lcname->val, str, len);
607    result = zend_hash_find_ptr(ht, lcname);
608    STR_ALLOCA_FREE(lcname, use_heap);
609
610    return result;
611}
612
613zend_string *zend_resolve_non_class_name(
614    zend_string *name, uint32_t type, zend_bool *is_fully_qualified,
615    zend_bool case_sensitive, HashTable *current_import_sub TSRMLS_DC
616) {
617    char *compound;
618    *is_fully_qualified = 0;
619
620    if (name->val[0] == '\\') {
621        /* Remove \ prefix (only relevant if this is a string rather than a label) */
622        return zend_string_init(name->val + 1, name->len - 1, 0);
623    }
624
625    if (type == ZEND_NAME_FQ) {
626        *is_fully_qualified = 1;
627        return zend_string_copy(name);
628    }
629
630    if (type == ZEND_NAME_RELATIVE) {
631        *is_fully_qualified = 1;
632        return zend_prefix_with_ns(name TSRMLS_CC);
633    }
634
635    if (current_import_sub) {
636        /* If an unqualified name is a function/const alias, replace it. */
637        zend_string *import_name;
638        if (case_sensitive) {
639            import_name = zend_hash_find_ptr(current_import_sub, name);
640        } else {
641            import_name = zend_hash_find_ptr_lc(current_import_sub, name->val, name->len);
642        }
643
644        if (import_name) {
645            *is_fully_qualified = 1;
646            return zend_string_copy(import_name);
647        }
648    }
649
650    compound = memchr(name->val, '\\', name->len);
651    if (compound) {
652        *is_fully_qualified = 1;
653    }
654
655    if (compound && CG(current_import)) {
656        /* If the first part of a qualified name is an alias, substitute it. */
657        size_t len = compound - name->val;
658        zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len);
659
660        if (import_name) {
661            return zend_concat_names(
662                import_name->val, import_name->len, name->val + len + 1, name->len - len - 1);
663        }
664    }
665
666    return zend_prefix_with_ns(name TSRMLS_CC);
667}
668/* }}} */
669
670zend_string *zend_resolve_function_name(zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC) /* {{{ */
671{
672    return zend_resolve_non_class_name(
673        name, type, is_fully_qualified, 0, CG(current_import_function) TSRMLS_CC);
674}
675/* }}} */
676
677zend_string *zend_resolve_const_name(zend_string *name, uint32_t type, zend_bool *is_fully_qualified TSRMLS_DC) /* {{{ */ {
678    return zend_resolve_non_class_name(
679        name, type, is_fully_qualified, 1, CG(current_import_const) TSRMLS_CC);
680}
681/* }}} */
682
683zend_string *zend_resolve_class_name(zend_string *name, uint32_t type TSRMLS_DC) /* {{{ */
684{
685    char *compound;
686
687    if (type == ZEND_NAME_RELATIVE) {
688        return zend_prefix_with_ns(name TSRMLS_CC);
689    }
690
691    if (type == ZEND_NAME_FQ || name->val[0] == '\\') {
692        /* Remove \ prefix (only relevant if this is a string rather than a label) */
693        if (name->val[0] == '\\') {
694            name = zend_string_init(name->val + 1, name->len - 1, 0);
695        } else {
696            zend_string_addref(name);
697        }
698        /* Ensure that \self, \parent and \static are not used */
699        if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
700            zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", name->val);
701        }
702        return name;
703    }
704
705    if (CG(current_import)) {
706        compound = memchr(name->val, '\\', name->len);
707        if (compound) {
708            /* If the first part of a qualified name is an alias, substitute it. */
709            size_t len = compound - name->val;
710            zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len);
711
712            if (import_name) {
713                return zend_concat_names(
714                    import_name->val, import_name->len, name->val + len + 1, name->len - len - 1);
715            }
716        } else {
717            /* If an unqualified name is an alias, replace it. */
718            zend_string *import_name
719                = zend_hash_find_ptr_lc(CG(current_import), name->val, name->len);
720
721            if (import_name) {
722                return zend_string_copy(import_name);
723            }
724        }
725    }
726
727    /* If not fully qualified and not an alias, prepend the current namespace */
728    return zend_prefix_with_ns(name TSRMLS_CC);
729}
730/* }}} */
731
732zend_string *zend_resolve_class_name_ast(zend_ast *ast TSRMLS_DC) /* {{{ */
733{
734    zend_string *name = zend_ast_get_str(ast);
735    return zend_resolve_class_name(name, ast->attr TSRMLS_CC);
736}
737/* }}} */
738
739static void ptr_dtor(zval *zv) /* {{{ */
740{
741    efree(Z_PTR_P(zv));
742}
743/* }}} */
744
745static void str_dtor(zval *zv)  /* {{{ */ {
746    zend_string_release(Z_STR_P(zv));
747}
748/* }}} */
749
750void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */
751{
752    zend_label *dest;
753    zend_long current, distance;
754    zval *label;
755
756    if (pass2) {
757        label = opline->op2.zv;
758    } else {
759        label = &CONSTANT_EX(op_array, opline->op2.constant);
760    }
761    if (CG(context).labels == NULL ||
762        (dest = zend_hash_find_ptr(CG(context).labels, Z_STR_P(label))) == NULL) {
763
764        if (pass2) {
765            CG(in_compilation) = 1;
766            CG(active_op_array) = op_array;
767            CG(zend_lineno) = opline->lineno;
768            zend_error_noreturn(E_COMPILE_ERROR, "'goto' to undefined label '%s'", Z_STRVAL_P(label));
769        } else {
770            /* Label is not defined. Delay to pass 2. */
771            return;
772        }
773    }
774
775    opline->op1.opline_num = dest->opline_num;
776    zval_dtor(label);
777    ZVAL_NULL(label);
778
779    /* Check that we are not moving into loop or switch */
780    current = opline->extended_value;
781    for (distance = 0; current != dest->brk_cont; distance++) {
782        if (current == -1) {
783            if (pass2) {
784                CG(in_compilation) = 1;
785                CG(active_op_array) = op_array;
786                CG(zend_lineno) = opline->lineno;
787            }
788            zend_error_noreturn(E_COMPILE_ERROR, "'goto' into loop or switch statement is disallowed");
789        }
790        current = op_array->brk_cont_array[current].parent;
791    }
792
793    if (distance == 0) {
794        /* Nothing to break out of, optimize to ZEND_JMP */
795        opline->opcode = ZEND_JMP;
796        opline->extended_value = 0;
797        SET_UNUSED(opline->op2);
798    } else {
799        /* Set real break distance */
800        ZVAL_LONG(label, distance);
801    }
802}
803/* }}} */
804
805void zend_release_labels(int temporary TSRMLS_DC) /* {{{ */
806{
807    if (CG(context).labels) {
808        zend_hash_destroy(CG(context).labels);
809        FREE_HASHTABLE(CG(context).labels);
810        CG(context).labels = NULL;
811    }
812    if (!temporary && !zend_stack_is_empty(&CG(context_stack))) {
813        zend_compiler_context *ctx = zend_stack_top(&CG(context_stack));
814        CG(context) = *ctx;
815        zend_stack_del_top(&CG(context_stack));
816    }
817}
818/* }}} */
819
820static zend_bool zend_is_call(zend_ast *ast);
821
822static int generate_free_loop_var(znode *var TSRMLS_DC) /* {{{ */
823{
824    switch (var->op_type) {
825        case IS_UNUSED:
826            /* Stack separator on function boundary, stop applying */
827            return 1;
828        case IS_VAR:
829        case IS_TMP_VAR:
830        {
831            zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
832
833            opline->opcode = ZEND_FREE;
834            SET_NODE(opline->op1, var);
835            SET_UNUSED(opline->op2);
836        }
837    }
838
839    return 0;
840}
841/* }}} */
842
843static uint32_t zend_add_try_element(uint32_t try_op TSRMLS_DC) /* {{{ */
844{
845    zend_op_array *op_array = CG(active_op_array);
846    uint32_t try_catch_offset = op_array->last_try_catch++;
847    zend_try_catch_element *elem;
848
849    op_array->try_catch_array = safe_erealloc(
850        op_array->try_catch_array, sizeof(zend_try_catch_element), op_array->last_try_catch, 0);
851
852    elem = &op_array->try_catch_array[try_catch_offset];
853    elem->try_op = try_op;
854    elem->catch_op = 0;
855    elem->finally_op = 0;
856    elem->finally_end = 0;
857
858    return try_catch_offset;
859}
860/* }}} */
861
862ZEND_API void function_add_ref(zend_function *function) /* {{{ */
863{
864    if (function->type == ZEND_USER_FUNCTION) {
865        zend_op_array *op_array = &function->op_array;
866
867        (*op_array->refcount)++;
868        if (op_array->static_variables) {
869            HashTable *static_variables = op_array->static_variables;
870
871            ALLOC_HASHTABLE(op_array->static_variables);
872            zend_array_dup(op_array->static_variables, static_variables);
873        }
874        op_array->run_time_cache = NULL;
875    } else if (function->type == ZEND_INTERNAL_FUNCTION) {
876        if (function->common.function_name) {
877            zend_string_addref(function->common.function_name);
878        }
879    }
880}
881/* }}} */
882
883ZEND_API int do_bind_function(const zend_op_array *op_array, const zend_op *opline, HashTable *function_table, zend_bool compile_time TSRMLS_DC) /* {{{ */
884{
885    zend_function *function, *new_function;
886    zval *op1, *op2;
887
888    if (compile_time) {
889        op1 = &CONSTANT_EX(op_array, opline->op1.constant);
890        op2 = &CONSTANT_EX(op_array, opline->op2.constant);
891    } else {
892        op1 = opline->op1.zv;
893        op2 = opline->op2.zv;
894    }
895
896    function = zend_hash_find_ptr(function_table, Z_STR_P(op1));
897    new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
898    memcpy(new_function, function, sizeof(zend_op_array));
899    if (zend_hash_add_ptr(function_table, Z_STR_P(op2), new_function) == NULL) {
900        int error_level = compile_time ? E_COMPILE_ERROR : E_ERROR;
901        zend_function *old_function;
902
903        efree_size(new_function, sizeof(zend_op_array));
904        if ((old_function = zend_hash_find_ptr(function_table, Z_STR_P(op2))) != NULL
905            && old_function->type == ZEND_USER_FUNCTION
906            && old_function->op_array.last > 0) {
907            zend_error(error_level, "Cannot redeclare %s() (previously declared in %s:%d)",
908                        function->common.function_name->val,
909                        old_function->op_array.filename->val,
910                        old_function->op_array.opcodes[0].lineno);
911        } else {
912            zend_error(error_level, "Cannot redeclare %s()", function->common.function_name->val);
913        }
914        return FAILURE;
915    } else {
916        (*function->op_array.refcount)++;
917        function->op_array.static_variables = NULL; /* NULL out the unbound function */
918        return SUCCESS;
919    }
920}
921/* }}} */
922
923ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time TSRMLS_DC) /* {{{ */
924{
925    zend_class_entry *ce;
926    zval *op1, *op2;
927
928    if (compile_time) {
929        op1 = &CONSTANT_EX(op_array, opline->op1.constant);
930        op2 = &CONSTANT_EX(op_array, opline->op2.constant);
931    } else {
932        op1 = opline->op1.zv;
933        op2 = opline->op2.zv;
934    }
935    if ((ce = zend_hash_find_ptr(class_table, Z_STR_P(op1))) == NULL) {
936        zend_error_noreturn(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", Z_STRVAL_P(op1));
937        return NULL;
938    }
939    ce->refcount++;
940    if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) {
941        ce->refcount--;
942        if (!compile_time) {
943            /* If we're in compile time, in practice, it's quite possible
944             * that we'll never reach this class declaration at runtime,
945             * so we shut up about it.  This allows the if (!defined('FOO')) { return; }
946             * approach to work.
947             */
948            zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name->val);
949        }
950        return NULL;
951    } else {
952        if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
953            zend_verify_abstract_class(ce TSRMLS_CC);
954        }
955        return ce;
956    }
957}
958/* }}} */
959
960ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time TSRMLS_DC) /* {{{ */
961{
962    zend_class_entry *ce;
963    zval *op1, *op2;
964
965    if (compile_time) {
966        op1 = &CONSTANT_EX(op_array, opline->op1.constant);
967        op2 = &CONSTANT_EX(op_array, opline->op2.constant);
968    } else {
969        op1 = opline->op1.zv;
970        op2 = opline->op2.zv;
971    }
972
973    ce = zend_hash_find_ptr(class_table, Z_STR_P(op1));
974
975    if (!ce) {
976        if (!compile_time) {
977            /* If we're in compile time, in practice, it's quite possible
978             * that we'll never reach this class declaration at runtime,
979             * so we shut up about it.  This allows the if (!defined('FOO')) { return; }
980             * approach to work.
981             */
982            zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", Z_STRVAL_P(op2));
983        }
984        return NULL;
985    }
986
987    if (parent_ce->ce_flags & ZEND_ACC_INTERFACE) {
988        zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from interface %s", ce->name->val, parent_ce->name->val);
989    } else if ((parent_ce->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
990        zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from trait %s", ce->name->val, parent_ce->name->val);
991    }
992
993    zend_do_inheritance(ce, parent_ce TSRMLS_CC);
994
995    ce->refcount++;
996
997    /* Register the derived class */
998    if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) {
999        zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name->val);
1000    }
1001    return ce;
1002}
1003/* }}} */
1004
1005void zend_do_early_binding(TSRMLS_D) /* {{{ */
1006{
1007    zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
1008    HashTable *table;
1009
1010    while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) {
1011        opline--;
1012    }
1013
1014    switch (opline->opcode) {
1015        case ZEND_DECLARE_FUNCTION:
1016            if (do_bind_function(CG(active_op_array), opline, CG(function_table), 1 TSRMLS_CC) == FAILURE) {
1017                return;
1018            }
1019            table = CG(function_table);
1020            break;
1021        case ZEND_DECLARE_CLASS:
1022            if (do_bind_class(CG(active_op_array), opline, CG(class_table), 1 TSRMLS_CC) == NULL) {
1023                return;
1024            }
1025            table = CG(class_table);
1026            break;
1027        case ZEND_DECLARE_INHERITED_CLASS:
1028            {
1029                zend_op *fetch_class_opline = opline-1;
1030                zval *parent_name;
1031                zend_class_entry *ce;
1032
1033                parent_name = &CONSTANT(fetch_class_opline->op2.constant);
1034                if (((ce = zend_lookup_class(Z_STR_P(parent_name) TSRMLS_CC)) == NULL) ||
1035                    ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) &&
1036                     (ce->type == ZEND_INTERNAL_CLASS))) {
1037                    if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) {
1038                        uint32_t *opline_num = &CG(active_op_array)->early_binding;
1039
1040                        while (*opline_num != -1) {
1041                            opline_num = &CG(active_op_array)->opcodes[*opline_num].result.opline_num;
1042                        }
1043                        *opline_num = opline - CG(active_op_array)->opcodes;
1044                        opline->opcode = ZEND_DECLARE_INHERITED_CLASS_DELAYED;
1045                        opline->result_type = IS_UNUSED;
1046                        opline->result.opline_num = -1;
1047                    }
1048                    return;
1049                }
1050                if (do_bind_inherited_class(CG(active_op_array), opline, CG(class_table), ce, 1 TSRMLS_CC) == NULL) {
1051                    return;
1052                }
1053                /* clear unnecessary ZEND_FETCH_CLASS opcode */
1054                zend_del_literal(CG(active_op_array), fetch_class_opline->op2.constant);
1055                MAKE_NOP(fetch_class_opline);
1056
1057                table = CG(class_table);
1058                break;
1059            }
1060        case ZEND_VERIFY_ABSTRACT_CLASS:
1061        case ZEND_ADD_INTERFACE:
1062        case ZEND_ADD_TRAIT:
1063        case ZEND_BIND_TRAITS:
1064            /* We currently don't early-bind classes that implement interfaces */
1065            /* Classes with traits are handled exactly the same, no early-bind here */
1066            return;
1067        default:
1068            zend_error_noreturn(E_COMPILE_ERROR, "Invalid binding type");
1069            return;
1070    }
1071
1072    zend_hash_del(table, Z_STR(CONSTANT(opline->op1.constant)));
1073    zend_del_literal(CG(active_op_array), opline->op1.constant);
1074    zend_del_literal(CG(active_op_array), opline->op2.constant);
1075    MAKE_NOP(opline);
1076}
1077/* }}} */
1078
1079ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC) /* {{{ */
1080{
1081    if (op_array->early_binding != -1) {
1082        zend_bool orig_in_compilation = CG(in_compilation);
1083        uint32_t opline_num = op_array->early_binding;
1084        zend_class_entry *ce;
1085
1086        CG(in_compilation) = 1;
1087        while (opline_num != -1) {
1088            if ((ce = zend_lookup_class(Z_STR_P(op_array->opcodes[opline_num-1].op2.zv) TSRMLS_CC)) != NULL) {
1089                do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), ce, 0 TSRMLS_CC);
1090            }
1091            opline_num = op_array->opcodes[opline_num].result.opline_num;
1092        }
1093        CG(in_compilation) = orig_in_compilation;
1094    }
1095}
1096/* }}} */
1097
1098ZEND_API zend_string *zend_mangle_property_name(const char *src1, size_t src1_length, const char *src2, size_t src2_length, int internal) /* {{{ */
1099{
1100    size_t prop_name_length = 1 + src1_length + 1 + src2_length;
1101    zend_string *prop_name = zend_string_alloc(prop_name_length, internal);
1102
1103    prop_name->val[0] = '\0';
1104    memcpy(prop_name->val + 1, src1, src1_length+1);
1105    memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1);
1106    return prop_name;
1107}
1108/* }}} */
1109
1110static size_t zend_strnlen(const char* s, size_t maxlen) /* {{{ */
1111{
1112    size_t len = 0;
1113    while (*s++ && maxlen--) len++;
1114    return len;
1115}
1116/* }}} */
1117
1118ZEND_API int zend_unmangle_property_name_ex(const zend_string *name, const char **class_name, const char **prop_name, size_t *prop_len) /* {{{ */
1119{
1120    size_t class_name_len;
1121
1122    *class_name = NULL;
1123
1124    if (name->val[0] != '\0') {
1125        *prop_name = name->val;
1126        if (prop_len) {
1127            *prop_len = name->len;
1128        }
1129        return SUCCESS;
1130    }
1131    if (name->len < 3 || name->val[1] == '\0') {
1132        zend_error(E_NOTICE, "Illegal member variable name");
1133        *prop_name = name->val;
1134        if (prop_len) {
1135            *prop_len = name->len;
1136        }
1137        return FAILURE;
1138    }
1139
1140    class_name_len = zend_strnlen(name->val + 1, name->len - 2);
1141    if (class_name_len >= name->len - 2 || name->val[class_name_len + 1] != '\0') {
1142        zend_error(E_NOTICE, "Corrupt member variable name");
1143        *prop_name = name->val;
1144        if (prop_len) {
1145            *prop_len = name->len;
1146        }
1147        return FAILURE;
1148    }
1149
1150    *class_name = name->val + 1;
1151    *prop_name = name->val + class_name_len + 2;
1152    if (prop_len) {
1153        *prop_len = name->len - class_name_len - 2;
1154    }
1155    return SUCCESS;
1156}
1157/* }}} */
1158
1159static zend_constant *zend_lookup_reserved_const(const char *name, size_t len TSRMLS_DC) /* {{{ */
1160{
1161    zend_constant *c = zend_hash_find_ptr_lc(EG(zend_constants), name, len);
1162    if (c && !(c->flags & CONST_CS) && (c->flags & CONST_CT_SUBST)) {
1163        return c;
1164    }
1165    return NULL;
1166}
1167/* }}} */
1168
1169static zend_bool zend_try_ct_eval_const(zval *zv, zend_string *name, zend_bool is_fully_qualified TSRMLS_DC) /* {{{ */
1170{
1171    zend_constant *c;
1172
1173    if (!(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION)) {
1174        /* Substitute case-sensitive (or lowercase) persistent constants */
1175        c = zend_hash_find_ptr(EG(zend_constants), name);
1176        if (c && (c->flags & CONST_PERSISTENT)) {
1177            ZVAL_DUP(zv, &c->value);
1178            return 1;
1179        }
1180    }
1181
1182    {
1183        /* Substitute true, false and null (including unqualified usage in namespaces) */
1184        const char *lookup_name = name->val;
1185        size_t lookup_len = name->len;
1186
1187        if (!is_fully_qualified) {
1188            zend_get_unqualified_name(name, &lookup_name, &lookup_len);
1189        }
1190
1191        c = zend_lookup_reserved_const(lookup_name, lookup_len TSRMLS_CC);
1192        if (c) {
1193            ZVAL_DUP(zv, &c->value);
1194            return 1;
1195        }
1196    }
1197
1198    return 0;
1199}
1200/* }}} */
1201
1202void zend_init_list(void *result, void *item TSRMLS_DC) /* {{{ */
1203{
1204    void** list = emalloc(sizeof(void*) * 2);
1205
1206    list[0] = item;
1207    list[1] = NULL;
1208
1209    *(void**)result = list;
1210}
1211/* }}} */
1212
1213void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */
1214{
1215    void** list = *(void**)result;
1216    size_t n = 0;
1217
1218    if (list) {
1219        while (list[n]) {
1220            n++;
1221        }
1222    }
1223
1224    list = erealloc(list, sizeof(void*) * (n+2));
1225
1226    list[n]   = item;
1227    list[n+1] = NULL;
1228
1229    *(void**)result = list;
1230}
1231/* }}} */
1232
1233void zend_do_extended_info(TSRMLS_D) /* {{{ */
1234{
1235    zend_op *opline;
1236
1237    if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
1238        return;
1239    }
1240
1241    opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1242
1243    opline->opcode = ZEND_EXT_STMT;
1244    SET_UNUSED(opline->op1);
1245    SET_UNUSED(opline->op2);
1246}
1247/* }}} */
1248
1249void zend_do_extended_fcall_begin(TSRMLS_D) /* {{{ */
1250{
1251    zend_op *opline;
1252
1253    if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
1254        return;
1255    }
1256
1257    opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1258
1259    opline->opcode = ZEND_EXT_FCALL_BEGIN;
1260    SET_UNUSED(opline->op1);
1261    SET_UNUSED(opline->op2);
1262}
1263/* }}} */
1264
1265void zend_do_extended_fcall_end(TSRMLS_D) /* {{{ */
1266{
1267    zend_op *opline;
1268
1269    if (!(CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO)) {
1270        return;
1271    }
1272
1273    opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1274
1275    opline->opcode = ZEND_EXT_FCALL_END;
1276    SET_UNUSED(opline->op1);
1277    SET_UNUSED(opline->op2);
1278}
1279/* }}} */
1280
1281zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC) /* {{{ */
1282{
1283    zend_auto_global *auto_global;
1284
1285    if ((auto_global = zend_hash_find_ptr(CG(auto_globals), name)) != NULL) {
1286        if (auto_global->armed) {
1287            auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
1288        }
1289        return 1;
1290    }
1291    return 0;
1292}
1293/* }}} */
1294
1295int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */
1296{
1297    zend_auto_global auto_global;
1298    int retval;
1299
1300    auto_global.name = zend_new_interned_string(name TSRMLS_CC);
1301    auto_global.auto_global_callback = auto_global_callback;
1302    auto_global.jit = jit;
1303
1304    retval = zend_hash_add_mem(CG(auto_globals), name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE;
1305
1306    zend_string_release(auto_global.name);
1307    return retval;
1308}
1309/* }}} */
1310
1311ZEND_API void zend_activate_auto_globals(TSRMLS_D) /* {{{ */
1312{
1313    zend_auto_global *auto_global;
1314
1315    ZEND_HASH_FOREACH_PTR(CG(auto_globals), auto_global) {
1316        if (auto_global->jit) {
1317            auto_global->armed = 1;
1318        } else if (auto_global->auto_global_callback) {
1319            auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
1320        } else {
1321            auto_global->armed = 0;
1322        }
1323    } ZEND_HASH_FOREACH_END();
1324}
1325/* }}} */
1326
1327int zendlex(zend_parser_stack_elem *elem TSRMLS_DC) /* {{{ */
1328{
1329    zval zv;
1330    int retval;
1331
1332    if (CG(increment_lineno)) {
1333        CG(zend_lineno)++;
1334        CG(increment_lineno) = 0;
1335    }
1336
1337again:
1338    ZVAL_UNDEF(&zv);
1339    retval = lex_scan(&zv TSRMLS_CC);
1340    switch (retval) {
1341        case T_COMMENT:
1342        case T_DOC_COMMENT:
1343        case T_OPEN_TAG:
1344        case T_WHITESPACE:
1345            goto again;
1346
1347        case T_CLOSE_TAG:
1348            if (LANG_SCNG(yy_text)[LANG_SCNG(yy_leng)-1] != '>') {
1349                CG(increment_lineno) = 1;
1350            }
1351            retval = ';'; /* implicit ; */
1352            break;
1353        case T_OPEN_TAG_WITH_ECHO:
1354            retval = T_ECHO;
1355            break;
1356    }
1357    if (Z_TYPE(zv) != IS_UNDEF) {
1358        elem->ast = zend_ast_create_zval(&zv);
1359    }
1360
1361    return retval;
1362}
1363/* }}} */
1364
1365ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC) /* {{{ */
1366{
1367    zend_bool persistent_hashes = (ce->type == ZEND_INTERNAL_CLASS) ? 1 : 0;
1368    dtor_func_t zval_ptr_dtor_func = ((persistent_hashes) ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR);
1369
1370    ce->refcount = 1;
1371    ce->ce_flags = ZEND_ACC_CONSTANTS_UPDATED;
1372
1373    ce->default_properties_table = NULL;
1374    ce->default_static_members_table = NULL;
1375    zend_hash_init_ex(&ce->properties_info, 8, NULL, (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0);
1376    zend_hash_init_ex(&ce->constants_table, 8, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
1377    zend_hash_init_ex(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0);
1378
1379    if (ce->type == ZEND_INTERNAL_CLASS) {
1380#ifdef ZTS
1381        int n = zend_hash_num_elements(CG(class_table));
1382
1383        if (CG(static_members_table) && n >= CG(last_static_member)) {
1384            /* Support for run-time declaration: dl() */
1385            CG(last_static_member) = n+1;
1386            CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval*));
1387            CG(static_members_table)[n] = NULL;
1388        }
1389        ce->static_members_table = (zval*)(zend_intptr_t)n;
1390#else
1391        ce->static_members_table = NULL;
1392#endif
1393    } else {
1394        ce->static_members_table = ce->default_static_members_table;
1395        ce->info.user.doc_comment = NULL;
1396    }
1397
1398    ce->default_properties_count = 0;
1399    ce->default_static_members_count = 0;
1400
1401    if (nullify_handlers) {
1402        ce->constructor = NULL;
1403        ce->destructor = NULL;
1404        ce->clone = NULL;
1405        ce->__get = NULL;
1406        ce->__set = NULL;
1407        ce->__unset = NULL;
1408        ce->__isset = NULL;
1409        ce->__call = NULL;
1410        ce->__callstatic = NULL;
1411        ce->__tostring = NULL;
1412        ce->create_object = NULL;
1413        ce->get_iterator = NULL;
1414        ce->iterator_funcs.funcs = NULL;
1415        ce->interface_gets_implemented = NULL;
1416        ce->get_static_method = NULL;
1417        ce->parent = NULL;
1418        ce->num_interfaces = 0;
1419        ce->interfaces = NULL;
1420        ce->num_traits = 0;
1421        ce->traits = NULL;
1422        ce->trait_aliases = NULL;
1423        ce->trait_precedences = NULL;
1424        ce->serialize = NULL;
1425        ce->unserialize = NULL;
1426        ce->serialize_func = NULL;
1427        ce->unserialize_func = NULL;
1428        ce->__debugInfo = NULL;
1429        if (ce->type == ZEND_INTERNAL_CLASS) {
1430            ce->info.internal.module = NULL;
1431            ce->info.internal.builtin_functions = NULL;
1432        }
1433    }
1434}
1435/* }}} */
1436
1437uint32_t zend_get_class_fetch_type(zend_string *name) /* {{{ */
1438{
1439    if (zend_string_equals_literal_ci(name, "self")) {
1440        return ZEND_FETCH_CLASS_SELF;
1441    } else if (zend_string_equals_literal_ci(name, "parent")) {
1442        return ZEND_FETCH_CLASS_PARENT;
1443    } else if (zend_string_equals_literal_ci(name, "static")) {
1444        return ZEND_FETCH_CLASS_STATIC;
1445    } else {
1446        return ZEND_FETCH_CLASS_DEFAULT;
1447    }
1448}
1449/* }}} */
1450
1451ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, uint32_t var) /* {{{ */
1452{
1453    return op_array->vars[EX_VAR_TO_NUM(var)];
1454}
1455/* }}} */
1456
1457zend_ast *zend_ast_append_str(zend_ast *left_ast, zend_ast *right_ast) /* {{{ */
1458{
1459    zval *left_zv = zend_ast_get_zval(left_ast);
1460    zend_string *left = Z_STR_P(left_zv);
1461    zend_string *right = zend_ast_get_str(right_ast);
1462
1463    zend_string *result;
1464    size_t left_len = left->len;
1465    size_t len = left_len + right->len + 1; /* left\right */
1466
1467    result = zend_string_realloc(left, len, 0);
1468    result->val[left_len] = '\\';
1469    memcpy(&result->val[left_len + 1], right->val, right->len);
1470    result->val[len] = '\0';
1471    zend_string_release(right);
1472
1473    ZVAL_STR(left_zv, result);
1474    return left_ast;
1475}
1476/* }}} */
1477
1478/* A hacky way that is used to store the doc comment for properties */
1479zend_ast *zend_ast_append_doc_comment(zend_ast *list TSRMLS_DC) /* {{{ */
1480{
1481    if (CG(doc_comment)) {
1482        list = zend_ast_list_add(list, zend_ast_create_zval_from_str(CG(doc_comment)));
1483        CG(doc_comment) = NULL;
1484    }
1485
1486    return list;
1487}
1488/* }}} */
1489
1490void zend_verify_namespace(TSRMLS_D) /* {{{ */
1491{
1492    if (CG(has_bracketed_namespaces) && !CG(in_namespace)) {
1493        zend_error_noreturn(E_COMPILE_ERROR, "No code may exist outside of namespace {}");
1494    }
1495}
1496/* }}} */
1497
1498static void zend_reset_import_tables(TSRMLS_D) /* {{{ */
1499{
1500    if (CG(current_import)) {
1501        zend_hash_destroy(CG(current_import));
1502        efree(CG(current_import));
1503        CG(current_import) = NULL;
1504    }
1505
1506    if (CG(current_import_function)) {
1507        zend_hash_destroy(CG(current_import_function));
1508        efree(CG(current_import_function));
1509        CG(current_import_function) = NULL;
1510    }
1511
1512    if (CG(current_import_const)) {
1513        zend_hash_destroy(CG(current_import_const));
1514        efree(CG(current_import_const));
1515        CG(current_import_const) = NULL;
1516    }
1517}
1518/* }}} */
1519
1520static void zend_end_namespace(TSRMLS_D) /* {{{ */ {
1521    CG(in_namespace) = 0;
1522    zend_reset_import_tables(TSRMLS_C);
1523    if (CG(current_namespace)) {
1524        zend_string_release(CG(current_namespace));
1525        CG(current_namespace) = NULL;
1526    }
1527}
1528/* }}} */
1529
1530void zend_do_end_compilation(TSRMLS_D) /* {{{ */
1531{
1532    CG(has_bracketed_namespaces) = 0;
1533    zend_end_namespace(TSRMLS_C);
1534}
1535/* }}} */
1536
1537/* {{{ zend_dirname
1538   Returns directory name component of path */
1539ZEND_API size_t zend_dirname(char *path, size_t len)
1540{
1541    register char *end = path + len - 1;
1542    unsigned int len_adjust = 0;
1543
1544#ifdef PHP_WIN32
1545    /* Note that on Win32 CWD is per drive (heritage from CP/M).
1546     * This means dirname("c:foo") maps to "c:." or "c:" - which means CWD on C: drive.
1547     */
1548    if ((2 <= len) && isalpha((int)((unsigned char *)path)[0]) && (':' == path[1])) {
1549        /* Skip over the drive spec (if any) so as not to change */
1550        path += 2;
1551        len_adjust += 2;
1552        if (2 == len) {
1553            /* Return "c:" on Win32 for dirname("c:").
1554             * It would be more consistent to return "c:."
1555             * but that would require making the string *longer*.
1556             */
1557            return len;
1558        }
1559    }
1560#elif defined(NETWARE)
1561    /*
1562     * Find the first occurrence of : from the left
1563     * move the path pointer to the position just after :
1564     * increment the len_adjust to the length of path till colon character(inclusive)
1565     * If there is no character beyond : simple return len
1566     */
1567    char *colonpos = NULL;
1568    colonpos = strchr(path, ':');
1569    if (colonpos != NULL) {
1570        len_adjust = ((colonpos - path) + 1);
1571        path += len_adjust;
1572        if (len_adjust == len) {
1573            return len;
1574        }
1575    }
1576#endif
1577
1578    if (len == 0) {
1579        /* Illegal use of this function */
1580        return 0;
1581    }
1582
1583    /* Strip trailing slashes */
1584    while (end >= path && IS_SLASH_P(end)) {
1585        end--;
1586    }
1587    if (end < path) {
1588        /* The path only contained slashes */
1589        path[0] = DEFAULT_SLASH;
1590        path[1] = '\0';
1591        return 1 + len_adjust;
1592    }
1593
1594    /* Strip filename */
1595    while (end >= path && !IS_SLASH_P(end)) {
1596        end--;
1597    }
1598    if (end < path) {
1599        /* No slash found, therefore return '.' */
1600#ifdef NETWARE
1601        if (len_adjust == 0) {
1602            path[0] = '.';
1603            path[1] = '\0';
1604            return 1; /* only one character */
1605        } else {
1606            path[0] = '\0';
1607            return len_adjust;
1608        }
1609#else
1610        path[0] = '.';
1611        path[1] = '\0';
1612        return 1 + len_adjust;
1613#endif
1614    }
1615
1616    /* Strip slashes which came before the file name */
1617    while (end >= path && IS_SLASH_P(end)) {
1618        end--;
1619    }
1620    if (end < path) {
1621        path[0] = DEFAULT_SLASH;
1622        path[1] = '\0';
1623        return 1 + len_adjust;
1624    }
1625    *(end+1) = '\0';
1626
1627    return (size_t)(end + 1 - path) + len_adjust;
1628}
1629/* }}} */
1630
1631static inline zend_bool zend_string_equals_str_ci(zend_string *str1, zend_string *str2) /* {{{ */
1632{
1633    return str1->len == str2->len
1634        && !zend_binary_strcasecmp(str1->val, str1->len, str2->val, str2->len);
1635}
1636/* }}} */
1637
1638static void zend_adjust_for_fetch_type(zend_op *opline, uint32_t type) /* {{{ */
1639{
1640    switch (type & BP_VAR_MASK) {
1641        case BP_VAR_R:
1642            return;
1643        case BP_VAR_W:
1644        case BP_VAR_REF:
1645            opline->opcode += 3;
1646            return;
1647        case BP_VAR_RW:
1648            opline->opcode += 6;
1649            return;
1650        case BP_VAR_IS:
1651            opline->opcode += 9;
1652            return;
1653        case BP_VAR_FUNC_ARG:
1654            opline->opcode += 12;
1655            opline->extended_value |= type >> BP_VAR_SHIFT;
1656            return;
1657        case BP_VAR_UNSET:
1658            opline->opcode += 15;
1659            return;
1660        EMPTY_SWITCH_DEFAULT_CASE()
1661    }
1662}
1663/* }}} */
1664
1665static inline void zend_make_var_result(znode *result, zend_op *opline TSRMLS_DC) /* {{{ */
1666{
1667    opline->result_type = IS_VAR;
1668    opline->result.var = get_temporary_variable(CG(active_op_array));
1669    GET_NODE(result, opline->result);
1670}
1671/* }}} */
1672
1673static inline void zend_make_tmp_result(znode *result, zend_op *opline TSRMLS_DC) /* {{{ */
1674{
1675    opline->result_type = IS_TMP_VAR;
1676    opline->result.var = get_temporary_variable(CG(active_op_array));
1677    GET_NODE(result, opline->result);
1678}
1679/* }}} */
1680
1681static zend_op *zend_emit_op(znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
1682{
1683    zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1684    opline->opcode = opcode;
1685
1686    if (op1 == NULL) {
1687        SET_UNUSED(opline->op1);
1688    } else {
1689        SET_NODE(opline->op1, op1);
1690    }
1691
1692    if (op2 == NULL) {
1693        SET_UNUSED(opline->op2);
1694    } else {
1695        SET_NODE(opline->op2, op2);
1696    }
1697
1698    if (result) {
1699        zend_make_var_result(result, opline TSRMLS_CC);
1700    }
1701    return opline;
1702}
1703/* }}} */
1704
1705static zend_op *zend_emit_op_tmp(znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
1706{
1707    zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1708    opline->opcode = opcode;
1709
1710    if (op1 == NULL) {
1711        SET_UNUSED(opline->op1);
1712    } else {
1713        SET_NODE(opline->op1, op1);
1714    }
1715
1716    if (op2 == NULL) {
1717        SET_UNUSED(opline->op2);
1718    } else {
1719        SET_NODE(opline->op2, op2);
1720    }
1721
1722    if (result) {
1723        zend_make_tmp_result(result, opline TSRMLS_CC);
1724    }
1725
1726    return opline;
1727}
1728/* }}} */
1729
1730static void zend_emit_tick(TSRMLS_D) /* {{{ */
1731{
1732    zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1733
1734    opline->opcode = ZEND_TICKS;
1735    SET_UNUSED(opline->op1);
1736    SET_UNUSED(opline->op2);
1737    opline->extended_value = Z_LVAL(CG(declarables).ticks);
1738}
1739/* }}} */
1740
1741static inline zend_op *zend_emit_op_data(znode *value TSRMLS_DC) /* {{{ */
1742{
1743    return zend_emit_op(NULL, ZEND_OP_DATA, value, NULL TSRMLS_CC);
1744}
1745/* }}} */
1746
1747static inline uint32_t zend_emit_jump(uint32_t opnum_target TSRMLS_DC) /* {{{ */
1748{
1749    uint32_t opnum = get_next_op_number(CG(active_op_array));
1750    zend_op *opline = zend_emit_op(NULL, ZEND_JMP, NULL, NULL TSRMLS_CC);
1751    opline->op1.opline_num = opnum_target;
1752    return opnum;
1753}
1754/* }}} */
1755
1756static inline uint32_t zend_emit_cond_jump(zend_uchar opcode, znode *cond, uint32_t opnum_target TSRMLS_DC) /* {{{ */
1757{
1758    uint32_t opnum = get_next_op_number(CG(active_op_array));
1759    zend_op *opline = zend_emit_op(NULL, opcode, cond, NULL TSRMLS_CC);
1760    opline->op2.opline_num = opnum_target;
1761    return opnum;
1762}
1763/* }}} */
1764
1765static inline void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_target TSRMLS_DC) /* {{{ */
1766{
1767    zend_op *opline = &CG(active_op_array)->opcodes[opnum_jump];
1768    switch (opline->opcode) {
1769        case ZEND_JMP:
1770            opline->op1.opline_num = opnum_target;
1771            break;
1772        case ZEND_JMPZ:
1773        case ZEND_JMPNZ:
1774        case ZEND_JMPZ_EX:
1775        case ZEND_JMPNZ_EX:
1776            opline->op2.opline_num = opnum_target;
1777            break;
1778        EMPTY_SWITCH_DEFAULT_CASE()
1779    }
1780}
1781/* }}} */
1782
1783static inline void zend_update_jump_target_to_next(uint32_t opnum_jump TSRMLS_DC) /* {{{ */
1784{
1785    zend_update_jump_target(opnum_jump, get_next_op_number(CG(active_op_array)) TSRMLS_CC);
1786}
1787/* }}} */
1788
1789static inline zend_op *zend_delayed_emit_op(znode *result, zend_uchar opcode, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
1790{
1791    zend_op tmp_opline;
1792    init_op(&tmp_opline TSRMLS_CC);
1793    tmp_opline.opcode = opcode;
1794    SET_NODE(tmp_opline.op1, op1);
1795    SET_NODE(tmp_opline.op2, op2);
1796    if (result) {
1797        zend_make_var_result(result, &tmp_opline TSRMLS_CC);
1798    }
1799
1800    zend_stack_push(&CG(delayed_oplines_stack), &tmp_opline);
1801    return zend_stack_top(&CG(delayed_oplines_stack));
1802}
1803/* }}} */
1804
1805static inline uint32_t zend_delayed_compile_begin(TSRMLS_D) /* {{{ */
1806{
1807    return zend_stack_count(&CG(delayed_oplines_stack));
1808}
1809/* }}} */
1810
1811static zend_op *zend_delayed_compile_end(uint32_t offset TSRMLS_DC) /* {{{ */
1812{
1813    zend_op *opline, *oplines = zend_stack_base(&CG(delayed_oplines_stack));
1814    uint32_t i, count = zend_stack_count(&CG(delayed_oplines_stack));
1815
1816    ZEND_ASSERT(count > offset);
1817    for (i = offset; i < count; ++i) {
1818        opline = get_next_op(CG(active_op_array) TSRMLS_CC);
1819        memcpy(opline, &oplines[i], sizeof(zend_op));
1820    }
1821    CG(delayed_oplines_stack).top = offset;
1822    return opline;
1823}
1824/* }}} */
1825
1826void zend_emit_final_return(zval *zv TSRMLS_DC) /* {{{ */
1827{
1828    znode zn;
1829    zend_bool returns_reference = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
1830
1831    zn.op_type = IS_CONST;
1832    if (zv) {
1833        ZVAL_COPY_VALUE(&zn.u.constant, zv);
1834    } else {
1835        ZVAL_NULL(&zn.u.constant);
1836    }
1837
1838    zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL TSRMLS_CC);
1839}
1840/* }}} */
1841
1842static inline zend_bool zend_is_variable(zend_ast *ast) /* {{{ */
1843{
1844    return ast->kind == ZEND_AST_VAR || ast->kind == ZEND_AST_DIM
1845        || ast->kind == ZEND_AST_PROP || ast->kind == ZEND_AST_STATIC_PROP
1846        || ast->kind == ZEND_AST_CALL || ast->kind == ZEND_AST_METHOD_CALL
1847        || ast->kind == ZEND_AST_STATIC_CALL;
1848}
1849/* }}} */
1850
1851static inline zend_bool zend_is_call(zend_ast *ast) /* {{{ */
1852{
1853    return ast->kind == ZEND_AST_CALL
1854        || ast->kind == ZEND_AST_METHOD_CALL
1855        || ast->kind == ZEND_AST_STATIC_CALL;
1856}
1857/* }}} */
1858
1859static inline zend_bool zend_is_unticked_stmt(zend_ast *ast) /* {{{ */
1860{
1861    return ast->kind == ZEND_AST_STMT_LIST || ast->kind == ZEND_AST_LABEL;
1862}
1863/* }}} */
1864
1865static inline zend_bool zend_can_write_to_variable(zend_ast *ast) /* {{{ */
1866{
1867    while (ast->kind == ZEND_AST_DIM || ast->kind == ZEND_AST_PROP) {
1868        ast = ast->child[0];
1869    }
1870
1871    return zend_is_variable(ast);
1872}
1873/* }}} */
1874
1875static inline zend_bool zend_is_const_default_class_ref(zend_ast *name_ast) /* {{{ */
1876{
1877    zend_string *name;
1878
1879    if (name_ast->kind != ZEND_AST_ZVAL) {
1880        return 0;
1881    }
1882
1883    /* Fully qualified names are always default refs */
1884    if (!name_ast->attr) {
1885        return 1;
1886    }
1887
1888    name = zend_ast_get_str(name_ast);
1889    return ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(name);
1890}
1891/* }}} */
1892
1893static inline void zend_handle_numeric_op(znode *node TSRMLS_DC) /* {{{ */
1894{
1895    if (node->op_type == IS_CONST && Z_TYPE(node->u.constant) == IS_STRING) {
1896        zend_ulong index;
1897
1898        if (ZEND_HANDLE_NUMERIC(Z_STR(node->u.constant), index)) {
1899            zval_ptr_dtor(&node->u.constant);
1900            ZVAL_LONG(&node->u.constant, index);
1901        }
1902    }
1903}
1904/* }}} */
1905
1906static inline void zend_set_class_name_op1(zend_op *opline, znode *class_node TSRMLS_DC) /* {{{ */
1907{
1908    if (class_node->op_type == IS_CONST) {
1909        opline->op1_type = IS_CONST;
1910        opline->op1.constant = zend_add_class_name_literal(
1911            CG(active_op_array), Z_STR(class_node->u.constant) TSRMLS_CC);
1912    } else {
1913        SET_NODE(opline->op1, class_node);
1914    }
1915}
1916/* }}} */
1917
1918static zend_op *zend_compile_class_ref(znode *result, zend_ast *name_ast TSRMLS_DC) /* {{{ */
1919{
1920    zend_op *opline;
1921    znode name_node;
1922    zend_compile_expr(&name_node, name_ast TSRMLS_CC);
1923
1924    if (name_node.op_type == IS_CONST) {
1925        zend_string *name = Z_STR(name_node.u.constant);
1926        uint32_t fetch_type = zend_get_class_fetch_type(name);
1927
1928        opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, NULL TSRMLS_CC);
1929        opline->extended_value = fetch_type;
1930
1931        if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) {
1932            uint32_t type = name_ast->kind == ZEND_AST_ZVAL ? name_ast->attr : ZEND_NAME_FQ;
1933            opline->op2_type = IS_CONST;
1934            opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
1935                zend_resolve_class_name(name, type TSRMLS_CC) TSRMLS_CC);
1936        }
1937
1938        zend_string_release(name);
1939    } else {
1940        opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, &name_node TSRMLS_CC);
1941        opline->extended_value = ZEND_FETCH_CLASS_DEFAULT;
1942    }
1943
1944    return opline;
1945}
1946/* }}} */
1947
1948static int zend_try_compile_cv(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
1949{
1950    zend_ast *name_ast = ast->child[0];
1951    if (name_ast->kind == ZEND_AST_ZVAL) {
1952        zend_string *name = zval_get_string(zend_ast_get_zval(name_ast));
1953
1954        if (zend_is_auto_global(name TSRMLS_CC)) {
1955            zend_string_release(name);
1956            return FAILURE;
1957        }
1958
1959        result->op_type = IS_CV;
1960        result->u.op.var = lookup_cv(CG(active_op_array), name TSRMLS_CC);
1961
1962        if (zend_string_equals_literal(name, "this")) {
1963            CG(active_op_array)->this_var = result->u.op.var;
1964        }
1965        return SUCCESS;
1966    }
1967
1968    return FAILURE;
1969}
1970/* }}} */
1971
1972static zend_op *zend_compile_simple_var_no_cv(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
1973{
1974    zend_ast *name_ast = ast->child[0];
1975    znode name_node;
1976    zend_op *opline;
1977
1978    /* there is a chance someone is accessing $this */
1979    if (ast->kind != ZEND_AST_ZVAL
1980        && CG(active_op_array)->scope && CG(active_op_array)->this_var == -1
1981    ) {
1982        zend_string *key = zend_string_init("this", sizeof("this") - 1, 0);
1983        CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key TSRMLS_CC);
1984    }
1985
1986    zend_compile_expr(&name_node, name_ast TSRMLS_CC);
1987
1988    opline = zend_emit_op(result, ZEND_FETCH_R, &name_node, NULL TSRMLS_CC);
1989
1990    opline->extended_value = ZEND_FETCH_LOCAL;
1991    if (name_node.op_type == IS_CONST) {
1992        if (zend_is_auto_global(Z_STR(name_node.u.constant) TSRMLS_CC)) {
1993            opline->extended_value = ZEND_FETCH_GLOBAL;
1994        }
1995    }
1996
1997    return opline;
1998}
1999/* }}} */
2000
2001static void zend_compile_simple_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2002{
2003    if (zend_try_compile_cv(result, ast TSRMLS_CC) == FAILURE) {
2004        zend_op *opline = zend_compile_simple_var_no_cv(result, ast, type TSRMLS_CC);
2005        zend_adjust_for_fetch_type(opline, type);
2006    }
2007}
2008/* }}} */
2009
2010static void zend_separate_if_call_and_write(znode *node, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2011{
2012    if (type != BP_VAR_R && type != BP_VAR_IS && zend_is_call(ast)) {
2013        if (node->op_type == IS_VAR) {
2014            zend_op *opline = zend_emit_op(NULL, ZEND_SEPARATE, node, NULL TSRMLS_CC);
2015            opline->result_type = IS_VAR;
2016            opline->result.var = opline->op1.var;
2017        } else {
2018            zend_error_noreturn(E_COMPILE_ERROR, "Cannot use result of built-in function in write context");
2019        }
2020    }
2021}
2022/* }}} */
2023
2024void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC);
2025void zend_compile_assign(znode *result, zend_ast *ast TSRMLS_DC);
2026static void zend_compile_list_assign(znode *result, zend_ast *ast, znode *expr_node TSRMLS_DC);
2027
2028static inline void zend_emit_assign_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) /* {{{ */
2029{
2030    znode dummy_node;
2031    if (var_ast->kind == ZEND_AST_LIST) {
2032        zend_compile_list_assign(&dummy_node, var_ast, value_node TSRMLS_CC);
2033    } else {
2034        zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN, var_ast,
2035            zend_ast_create_znode(value_node));
2036        zend_compile_assign(&dummy_node, assign_ast TSRMLS_CC);
2037    }
2038    zend_do_free(&dummy_node TSRMLS_CC);
2039}
2040/* }}} */
2041
2042static zend_op *zend_delayed_compile_dim(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2043{
2044    zend_ast *var_ast = ast->child[0];
2045    zend_ast *dim_ast = ast->child[1];
2046
2047    znode var_node, dim_node;
2048
2049    zend_delayed_compile_var(&var_node, var_ast, type TSRMLS_CC);
2050    zend_separate_if_call_and_write(&var_node, var_ast, type TSRMLS_CC);
2051
2052    if (dim_ast == NULL) {
2053        if (type == BP_VAR_R || type == BP_VAR_IS) {
2054            zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for reading");
2055        }
2056        if (type == BP_VAR_UNSET) {
2057            zend_error_noreturn(E_COMPILE_ERROR, "Cannot use [] for unsetting");
2058        }
2059        dim_node.op_type = IS_UNUSED;
2060    } else {
2061        zend_compile_expr(&dim_node, dim_ast TSRMLS_CC);
2062        zend_handle_numeric_op(&dim_node TSRMLS_CC);
2063    }
2064
2065    return zend_delayed_emit_op(result, ZEND_FETCH_DIM_R, &var_node, &dim_node TSRMLS_CC);
2066}
2067/* }}} */
2068
2069static inline zend_op *zend_compile_dim_common(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2070{
2071    uint32_t offset = zend_delayed_compile_begin(TSRMLS_C);
2072    zend_delayed_compile_dim(result, ast, type TSRMLS_CC);
2073    return zend_delayed_compile_end(offset TSRMLS_CC);
2074}
2075/* }}} */
2076
2077void zend_compile_dim(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2078{
2079    zend_op *opline = zend_compile_dim_common(result, ast, type TSRMLS_CC);
2080    zend_adjust_for_fetch_type(opline, type);
2081}
2082/* }}} */
2083
2084static zend_bool is_this_fetch(zend_ast *ast) /* {{{ */
2085{
2086    if (ast->kind == ZEND_AST_VAR && ast->child[0]->kind == ZEND_AST_ZVAL) {
2087        zval *name = zend_ast_get_zval(ast->child[0]);
2088        return Z_TYPE_P(name) == IS_STRING && zend_string_equals_literal(Z_STR_P(name), "this");
2089    }
2090
2091    return 0;
2092}
2093/* }}} */
2094
2095static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2096{
2097    zend_ast *obj_ast = ast->child[0];
2098    zend_ast *prop_ast = ast->child[1];
2099
2100    znode obj_node, prop_node;
2101    zend_op *opline;
2102
2103    if (is_this_fetch(obj_ast)) {
2104        obj_node.op_type = IS_UNUSED;
2105    } else {
2106        zend_delayed_compile_var(&obj_node, obj_ast, type TSRMLS_CC);
2107        zend_separate_if_call_and_write(&obj_node, obj_ast, type TSRMLS_CC);
2108    }
2109    zend_compile_expr(&prop_node, prop_ast TSRMLS_CC);
2110
2111    opline = zend_delayed_emit_op(result, ZEND_FETCH_OBJ_R, &obj_node, &prop_node TSRMLS_CC);
2112    if (opline->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline->op2.constant)) == IS_STRING) {
2113        zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
2114    }
2115
2116    return opline;
2117}
2118/* }}} */
2119
2120static zend_op *zend_compile_prop_common(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2121{
2122    uint32_t offset = zend_delayed_compile_begin(TSRMLS_C);
2123    zend_delayed_compile_prop(result, ast, type TSRMLS_CC);
2124    return zend_delayed_compile_end(offset TSRMLS_CC);
2125}
2126/* }}} */
2127
2128void zend_compile_prop(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2129{
2130    zend_op *opline = zend_compile_prop_common(result, ast, type TSRMLS_CC);
2131    zend_adjust_for_fetch_type(opline, type);
2132}
2133/* }}} */
2134
2135zend_op *zend_compile_static_prop_common(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2136{
2137    zend_ast *class_ast = ast->child[0];
2138    zend_ast *prop_ast = ast->child[1];
2139
2140    znode class_node, prop_node;
2141    zend_op *opline;
2142
2143    if (zend_is_const_default_class_ref(class_ast)) {
2144        class_node.op_type = IS_CONST;
2145        ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC));
2146    } else {
2147        zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
2148    }
2149
2150    zend_compile_expr(&prop_node, prop_ast TSRMLS_CC);
2151
2152    opline = zend_emit_op(result, ZEND_FETCH_R, &prop_node, NULL TSRMLS_CC);
2153    if (opline->op1_type == IS_CONST) {
2154        zend_alloc_polymorphic_cache_slot(opline->op1.constant TSRMLS_CC);
2155    }
2156    if (class_node.op_type == IS_CONST) {
2157        opline->op2_type = IS_CONST;
2158        opline->op2.constant = zend_add_class_name_literal(
2159            CG(active_op_array), Z_STR(class_node.u.constant) TSRMLS_CC);
2160    } else {
2161        SET_NODE(opline->op2, &class_node);
2162    }
2163    opline->extended_value |= ZEND_FETCH_STATIC_MEMBER;
2164
2165    return opline;
2166}
2167/* }}} */
2168
2169void zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2170{
2171    zend_op *opline = zend_compile_static_prop_common(result, ast, type TSRMLS_CC);
2172    zend_adjust_for_fetch_type(opline, type);
2173}
2174/* }}} */
2175
2176static void zend_compile_list_assign(znode *result, zend_ast *ast, znode *expr_node TSRMLS_DC) /* {{{ */
2177{
2178    zend_ast_list *list = zend_ast_get_list(ast);
2179    uint32_t i;
2180
2181    if (list->children == 1 && !list->child[0]) {
2182        zend_error_noreturn(E_COMPILE_ERROR, "Cannot use empty list");
2183    }
2184
2185    for (i = 0; i < list->children; ++i) {
2186        zend_ast *var_ast = list->child[i];
2187        znode fetch_result, dim_node;
2188
2189        if (var_ast == NULL) {
2190            continue;
2191        }
2192
2193        dim_node.op_type = IS_CONST;
2194        ZVAL_LONG(&dim_node.u.constant, i);
2195
2196        if (expr_node->op_type == IS_CONST) {
2197            Z_TRY_ADDREF(expr_node->u.constant);
2198        }
2199
2200        zend_emit_op(&fetch_result, ZEND_FETCH_LIST, expr_node, &dim_node TSRMLS_CC);
2201        zend_emit_assign_znode(var_ast, &fetch_result TSRMLS_CC);
2202    }
2203    *result = *expr_node;
2204}
2205/* }}} */
2206
2207void zend_ensure_writable_variable(const zend_ast *ast) /* {{{ */
2208{
2209    if (ast->kind == ZEND_AST_CALL) {
2210        zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context");
2211    }
2212    if (ast->kind == ZEND_AST_METHOD_CALL || ast->kind == ZEND_AST_STATIC_CALL) {
2213        zend_error_noreturn(E_COMPILE_ERROR, "Can't use method return value in write context");
2214    }
2215}
2216/* }}} */
2217
2218/* Detects $a... = $a pattern */
2219zend_bool zend_is_assign_to_self(zend_ast *var_ast, zend_ast *expr_ast TSRMLS_DC) /* {{{ */
2220{
2221    if (expr_ast->kind != ZEND_AST_VAR || expr_ast->child[0]->kind != ZEND_AST_ZVAL) {
2222        return 0;
2223    }
2224
2225    while (zend_is_variable(var_ast) && var_ast->kind != ZEND_AST_VAR) {
2226        var_ast = var_ast->child[0];
2227    }
2228
2229    if (var_ast->kind != ZEND_AST_VAR || var_ast->child[0]->kind != ZEND_AST_ZVAL) {
2230        return 0;
2231    }
2232
2233    {
2234        zend_string *name1 = zval_get_string(zend_ast_get_zval(var_ast->child[0]));
2235        zend_string *name2 = zval_get_string(zend_ast_get_zval(expr_ast->child[0]));
2236        zend_bool result = zend_string_equals(name1, name2);
2237        zend_string_release(name1);
2238        zend_string_release(name2);
2239        return result;
2240    }
2241}
2242/* }}} */
2243
2244void zend_compile_assign(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
2245{
2246    zend_ast *var_ast = ast->child[0];
2247    zend_ast *expr_ast = ast->child[1];
2248
2249    znode var_node, expr_node;
2250    zend_op *opline;
2251    uint32_t offset;
2252
2253    if (is_this_fetch(var_ast)) {
2254        zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
2255    }
2256
2257    zend_ensure_writable_variable(var_ast);
2258
2259    switch (var_ast->kind) {
2260        case ZEND_AST_VAR:
2261        case ZEND_AST_STATIC_PROP:
2262            zend_compile_var(&var_node, var_ast, BP_VAR_W TSRMLS_CC);
2263            zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
2264            zend_emit_op(result, ZEND_ASSIGN, &var_node, &expr_node TSRMLS_CC);
2265            return;
2266        case ZEND_AST_DIM:
2267            offset = zend_delayed_compile_begin(TSRMLS_C);
2268            zend_delayed_compile_dim(result, var_ast, BP_VAR_W TSRMLS_CC);
2269
2270            if (zend_is_assign_to_self(var_ast, expr_ast TSRMLS_CC)) {
2271                /* $a[0] = $a should evaluate the right $a first */
2272                zend_compile_simple_var_no_cv(&expr_node, expr_ast, BP_VAR_R TSRMLS_CC);
2273            } else {
2274                zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
2275            }
2276
2277            opline = zend_delayed_compile_end(offset TSRMLS_CC);
2278            opline->opcode = ZEND_ASSIGN_DIM;
2279
2280            opline = zend_emit_op_data(&expr_node TSRMLS_CC);
2281            return;
2282        case ZEND_AST_PROP:
2283            offset = zend_delayed_compile_begin(TSRMLS_C);
2284            zend_delayed_compile_prop(result, var_ast, BP_VAR_W TSRMLS_CC);
2285            zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
2286
2287            opline = zend_delayed_compile_end(offset TSRMLS_CC);
2288            opline->opcode = ZEND_ASSIGN_OBJ;
2289
2290            zend_emit_op_data(&expr_node TSRMLS_CC);
2291            return;
2292        case ZEND_AST_LIST:
2293            zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
2294            zend_compile_list_assign(result, var_ast, &expr_node TSRMLS_CC);
2295            return;
2296        EMPTY_SWITCH_DEFAULT_CASE();
2297    }
2298}
2299/* }}} */
2300
2301void zend_compile_assign_ref(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
2302{
2303    zend_ast *target_ast = ast->child[0];
2304    zend_ast *source_ast = ast->child[1];
2305
2306    znode target_node, source_node;
2307    zend_op *opline;
2308
2309    if (is_this_fetch(target_ast)) {
2310        zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
2311    }
2312    zend_ensure_writable_variable(target_ast);
2313
2314    zend_compile_var(&target_node, target_ast, BP_VAR_W TSRMLS_CC);
2315    zend_compile_var(&source_node, source_ast, BP_VAR_REF TSRMLS_CC);
2316
2317    if (source_node.op_type != IS_VAR && zend_is_call(source_ast)) {
2318        zend_error_noreturn(E_COMPILE_ERROR, "Cannot use result of built-in function in write context");
2319    }
2320
2321    opline = zend_emit_op(result, ZEND_ASSIGN_REF, &target_node, &source_node TSRMLS_CC);
2322    if (!result) {
2323        opline->result_type |= EXT_TYPE_UNUSED;
2324    }
2325
2326    if (zend_is_call(source_ast)) {
2327        opline->extended_value = ZEND_RETURNS_FUNCTION;
2328    } else if (source_ast->kind == ZEND_AST_NEW) {
2329        zend_error(E_DEPRECATED, "Assigning the return value of new by reference is deprecated");
2330        opline->extended_value = ZEND_RETURNS_NEW;
2331    }
2332}
2333/* }}} */
2334
2335static inline void zend_emit_assign_ref_znode(zend_ast *var_ast, znode *value_node TSRMLS_DC) /* {{{ */
2336{
2337    zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN_REF, var_ast,
2338        zend_ast_create_znode(value_node));
2339    zend_compile_assign_ref(NULL, assign_ast TSRMLS_CC);
2340}
2341/* }}} */
2342
2343void zend_compile_compound_assign(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
2344{
2345    zend_ast *var_ast = ast->child[0];
2346    zend_ast *expr_ast = ast->child[1];
2347    uint32_t opcode = ast->attr;
2348
2349    znode var_node, expr_node;
2350    zend_op *opline;
2351    uint32_t offset;
2352
2353    zend_ensure_writable_variable(var_ast);
2354
2355    switch (var_ast->kind) {
2356        case ZEND_AST_VAR:
2357        case ZEND_AST_STATIC_PROP:
2358            zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
2359            zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
2360            zend_emit_op(result, opcode, &var_node, &expr_node TSRMLS_CC);
2361            return;
2362        case ZEND_AST_DIM:
2363            offset = zend_delayed_compile_begin(TSRMLS_C);
2364            zend_delayed_compile_dim(result, var_ast, BP_VAR_RW TSRMLS_CC);
2365            zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
2366
2367            opline = zend_delayed_compile_end(offset TSRMLS_CC);
2368            opline->opcode = opcode;
2369            opline->extended_value = ZEND_ASSIGN_DIM;
2370
2371            opline = zend_emit_op_data(&expr_node TSRMLS_CC);
2372            return;
2373        case ZEND_AST_PROP:
2374            offset = zend_delayed_compile_begin(TSRMLS_C);
2375            zend_delayed_compile_prop(result, var_ast, BP_VAR_RW TSRMLS_CC);
2376            zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
2377
2378            opline = zend_delayed_compile_end(offset TSRMLS_CC);
2379            opline->opcode = opcode;
2380            opline->extended_value = ZEND_ASSIGN_OBJ;
2381
2382            zend_emit_op_data(&expr_node TSRMLS_CC);
2383            return;
2384        EMPTY_SWITCH_DEFAULT_CASE()
2385    }
2386}
2387/* }}} */
2388
2389uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc TSRMLS_DC) /* {{{ */
2390{
2391    /* TODO.AST &var error */
2392    zend_ast_list *args = zend_ast_get_list(ast);
2393    uint32_t i;
2394    zend_bool uses_arg_unpack = 0;
2395    uint32_t arg_count = 0; /* number of arguments not including unpacks */
2396
2397    for (i = 0; i < args->children; ++i) {
2398        zend_ast *arg = args->child[i];
2399        uint32_t arg_num = i + 1;
2400
2401        znode arg_node;
2402        zend_op *opline;
2403        zend_uchar opcode;
2404        zend_ulong flags = 0;
2405
2406        if (arg->kind == ZEND_AST_UNPACK) {
2407            uses_arg_unpack = 1;
2408            fbc = NULL;
2409
2410            zend_compile_expr(&arg_node, arg->child[0] TSRMLS_CC);
2411            opline = zend_emit_op(NULL, ZEND_SEND_UNPACK, &arg_node, NULL TSRMLS_CC);
2412            opline->op2.num = arg_count;
2413            continue;
2414        }
2415
2416        if (uses_arg_unpack) {
2417            zend_error_noreturn(E_COMPILE_ERROR,
2418                "Cannot use positional argument after argument unpacking");
2419        }
2420
2421        arg_count++;
2422        if (zend_is_variable(arg)) {
2423            if (zend_is_call(arg)) {
2424                zend_compile_var(&arg_node, arg, BP_VAR_R TSRMLS_CC);
2425                if (arg_node.op_type & (IS_CONST|IS_TMP_VAR)) {
2426                    /* Function call was converted into builtin instruction */
2427                    opcode = ZEND_SEND_VAL;
2428                } else {
2429                    opcode = ZEND_SEND_VAR_NO_REF;
2430                    flags |= ZEND_ARG_SEND_FUNCTION;
2431                    if (fbc && ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) {
2432                        flags |= ZEND_ARG_SEND_BY_REF;
2433                        if (ARG_MAY_BE_SENT_BY_REF(fbc, arg_num)) {
2434                            flags |= ZEND_ARG_SEND_SILENT;
2435                        }
2436                    }
2437                }
2438            } else if (fbc) {
2439                if (ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) {
2440                    zend_compile_var(&arg_node, arg, BP_VAR_W TSRMLS_CC);
2441                    opcode = ZEND_SEND_REF;
2442                } else {
2443                    zend_compile_var(&arg_node, arg, BP_VAR_R TSRMLS_CC);
2444                    opcode = ZEND_SEND_VAR;
2445                }
2446            } else {
2447                zend_compile_var(&arg_node, arg,
2448                    BP_VAR_FUNC_ARG | (arg_num << BP_VAR_SHIFT) TSRMLS_CC);
2449                opcode = ZEND_SEND_VAR_EX;
2450            }
2451        } else {
2452            zend_compile_expr(&arg_node, arg TSRMLS_CC);
2453            if (arg_node.op_type & (IS_VAR|IS_CV)) {
2454                opcode = ZEND_SEND_VAR_NO_REF;
2455                if (fbc && ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) {
2456                    flags |= ZEND_ARG_SEND_BY_REF;
2457                }
2458            } else {
2459                if (fbc) {
2460                    opcode = ZEND_SEND_VAL;
2461                    if (ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) {
2462                        zend_error_noreturn(E_COMPILE_ERROR, "Only variables can be passed by reference");
2463                    }
2464                } else {
2465                    opcode = ZEND_SEND_VAL_EX;
2466                }
2467            }
2468        }
2469
2470        opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2471        opline->opcode = opcode;
2472        SET_NODE(opline->op1, &arg_node);
2473        SET_UNUSED(opline->op2);
2474        opline->op2.opline_num = arg_num;
2475
2476        if (opcode == ZEND_SEND_VAR_NO_REF) {
2477            if (fbc) {
2478                flags |= ZEND_ARG_COMPILE_TIME_BOUND;
2479            }
2480            opline->extended_value = flags;
2481        } else if (fbc) {
2482            opline->extended_value = ZEND_ARG_COMPILE_TIME_BOUND;
2483        }
2484    }
2485
2486    return arg_count;
2487}
2488/* }}} */
2489
2490void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function *fbc TSRMLS_DC) /* {{{ */
2491{
2492    zend_op *opline;
2493    uint32_t opnum_init = get_next_op_number(CG(active_op_array)) - 1;
2494    uint32_t arg_count;
2495    uint32_t call_flags;
2496
2497    zend_do_extended_fcall_begin(TSRMLS_C);
2498
2499    arg_count = zend_compile_args(args_ast, fbc TSRMLS_CC);
2500
2501    opline = &CG(active_op_array)->opcodes[opnum_init];
2502    opline->extended_value = arg_count;
2503
2504    call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0);
2505    opline = zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
2506    opline->op1.num = call_flags;
2507
2508    zend_do_extended_fcall_end(TSRMLS_C);
2509}
2510/* }}} */
2511
2512zend_bool zend_compile_function_name(znode *name_node, zend_ast *name_ast TSRMLS_DC) /* {{{ */
2513{
2514    zend_string *orig_name = zend_ast_get_str(name_ast);
2515    zend_bool is_fully_qualified;
2516
2517    name_node->op_type = IS_CONST;
2518    ZVAL_STR(&name_node->u.constant, zend_resolve_function_name(
2519        orig_name, name_ast->attr, &is_fully_qualified TSRMLS_CC));
2520
2521    return !is_fully_qualified && CG(current_namespace);
2522}
2523/* }}} */
2524
2525void zend_compile_ns_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) /* {{{ */
2526{
2527    zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2528    opline->opcode = ZEND_INIT_NS_FCALL_BY_NAME;
2529    SET_UNUSED(opline->op1);
2530    opline->op2_type = IS_CONST;
2531    opline->op2.constant = zend_add_ns_func_name_literal(
2532        CG(active_op_array), Z_STR(name_node->u.constant) TSRMLS_CC);
2533    zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
2534
2535    zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
2536}
2537/* }}} */
2538
2539void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *args_ast TSRMLS_DC) /* {{{ */
2540{
2541    zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2542    opline->opcode = ZEND_INIT_FCALL_BY_NAME;
2543    SET_UNUSED(opline->op1);
2544    if (name_node->op_type == IS_CONST && Z_TYPE(name_node->u.constant) == IS_STRING) {
2545        opline->op2_type = IS_CONST;
2546        opline->op2.constant = zend_add_func_name_literal(CG(active_op_array),
2547            Z_STR(name_node->u.constant) TSRMLS_CC);
2548        zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
2549    } else {
2550        SET_NODE(opline->op2, name_node);
2551    }
2552
2553    zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
2554}
2555/* }}} */
2556
2557static zend_bool zend_args_contain_unpack(zend_ast_list *args) /* {{{ */
2558{
2559    uint32_t i;
2560    for (i = 0; i < args->children; ++i) {
2561        if (args->child[i]->kind == ZEND_AST_UNPACK) {
2562            return 1;
2563        }
2564    }
2565    return 0;
2566}
2567/* }}} */
2568
2569int zend_compile_func_strlen(znode *result, zend_ast_list *args TSRMLS_DC) /* {{{ */
2570{
2571    znode arg_node;
2572
2573    if ((CG(compiler_options) & ZEND_COMPILE_NO_BUILTIN_STRLEN)
2574        || args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK
2575    ) {
2576        return FAILURE;
2577    }
2578
2579    zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC);
2580    zend_emit_op_tmp(result, ZEND_STRLEN, &arg_node, NULL TSRMLS_CC);
2581    return SUCCESS;
2582}
2583/* }}} */
2584
2585int zend_compile_func_typecheck(znode *result, zend_ast_list *args, uint32_t type TSRMLS_DC) /* {{{ */
2586{
2587    znode arg_node;
2588    zend_op *opline;
2589
2590    if (args->children != 1 || args->child[0]->kind == ZEND_AST_UNPACK) {
2591        return FAILURE;
2592    }
2593
2594    zend_compile_expr(&arg_node, args->child[0] TSRMLS_CC);
2595    opline = zend_emit_op_tmp(result, ZEND_TYPE_CHECK, &arg_node, NULL TSRMLS_CC);
2596    opline->extended_value = type;
2597    return SUCCESS;
2598}
2599/* }}} */
2600
2601int zend_compile_func_defined(znode *result, zend_ast_list *args TSRMLS_DC) /* {{{ */
2602{
2603    zend_string *name;
2604    zend_op *opline;
2605
2606    if (args->children != 1 || args->child[0]->kind != ZEND_AST_ZVAL) {
2607        return FAILURE;
2608    }
2609
2610    name = zval_get_string(zend_ast_get_zval(args->child[0]));
2611    if (zend_memrchr(name->val, '\\', name->len) || zend_memrchr(name->val, ':', name->len)) {
2612        zend_string_release(name);
2613        return FAILURE;
2614    }
2615
2616    opline = zend_emit_op_tmp(result, ZEND_DEFINED, NULL, NULL TSRMLS_CC);
2617    opline->op1_type = IS_CONST;
2618    LITERAL_STR(opline->op1, name);
2619    zend_alloc_cache_slot(opline->op1.constant TSRMLS_CC);
2620
2621    /* Lowercase constant name in a separate literal */
2622    {
2623        zval c;
2624        zend_string *lcname = zend_string_alloc(name->len, 0);
2625        zend_str_tolower_copy(lcname->val, name->val, name->len);
2626        ZVAL_NEW_STR(&c, lcname);
2627        zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
2628    }
2629    return SUCCESS;
2630}
2631/* }}} */
2632
2633static int zend_try_compile_ct_bound_init_user_func(zend_ast *name_ast, uint32_t num_args TSRMLS_DC) /* {{{ */
2634{
2635    zend_string *name, *lcname;
2636    zend_function *fbc;
2637    zend_op *opline;
2638
2639    if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) {
2640        return FAILURE;
2641    }
2642
2643    name = zend_ast_get_str(name_ast);
2644    lcname = zend_string_alloc(name->len, 0);
2645    zend_str_tolower_copy(lcname->val, name->val, name->len);
2646
2647    fbc = zend_hash_find_ptr(CG(function_table), lcname);
2648    if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION &&
2649        (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
2650    ) {
2651        zend_string_free(lcname);
2652        return FAILURE;
2653    }
2654
2655    opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, NULL TSRMLS_CC);
2656    opline->extended_value = num_args;
2657
2658    opline->op2_type = IS_CONST;
2659    LITERAL_STR(opline->op2, lcname);
2660    zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
2661
2662    return SUCCESS;
2663}
2664/* }}} */
2665
2666static void zend_compile_init_user_func(zend_ast *name_ast, uint32_t num_args, zend_string *orig_func_name TSRMLS_DC) /* {{{ */
2667{
2668    zend_op *opline;
2669    znode name_node;
2670
2671    if (zend_try_compile_ct_bound_init_user_func(name_ast, num_args TSRMLS_CC) == SUCCESS) {
2672        return;
2673    }
2674
2675    zend_compile_expr(&name_node, name_ast TSRMLS_CC);
2676
2677    opline = zend_emit_op(NULL, ZEND_INIT_USER_CALL, NULL, &name_node TSRMLS_CC);
2678    opline->op1_type = IS_CONST;
2679    LITERAL_STR(opline->op1, zend_string_copy(orig_func_name));
2680    opline->extended_value = num_args;
2681}
2682/* }}} */
2683
2684/* cufa = call_user_func_array */
2685int zend_compile_func_cufa(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) /* {{{ */
2686{
2687    znode arg_node;
2688
2689    if (args->children != 2 || zend_args_contain_unpack(args)) {
2690        return FAILURE;
2691    }
2692
2693    zend_compile_init_user_func(args->child[0], 1, lcname TSRMLS_CC);
2694    zend_compile_expr(&arg_node, args->child[1] TSRMLS_CC);
2695    zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, NULL TSRMLS_CC);
2696    zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
2697
2698    return SUCCESS;
2699}
2700/* }}} */
2701
2702/* cuf = call_user_func */
2703int zend_compile_func_cuf(znode *result, zend_ast_list *args, zend_string *lcname TSRMLS_DC) /* {{{ */
2704{
2705    uint32_t i;
2706
2707    if (args->children < 1 || zend_args_contain_unpack(args)) {
2708        return FAILURE;
2709    }
2710
2711    zend_compile_init_user_func(args->child[0], args->children - 1, lcname TSRMLS_CC);
2712    for (i = 1; i < args->children; ++i) {
2713        zend_ast *arg_ast = args->child[i];
2714        znode arg_node;
2715        zend_op *opline;
2716        zend_bool send_user = 0;
2717
2718        if (zend_is_variable(arg_ast) && !zend_is_call(arg_ast)) {
2719            zend_compile_var(&arg_node, arg_ast, BP_VAR_FUNC_ARG | (i << BP_VAR_SHIFT) TSRMLS_CC);
2720            send_user = 1;
2721        } else {
2722            zend_compile_expr(&arg_node, arg_ast TSRMLS_CC);
2723            if (arg_node.op_type & (IS_VAR|IS_CV)) {
2724                send_user = 1;
2725            }
2726        }
2727
2728        if (send_user) {
2729            opline = zend_emit_op(NULL, ZEND_SEND_USER, &arg_node, NULL TSRMLS_CC);
2730        } else {
2731            opline = zend_emit_op(NULL, ZEND_SEND_VAL, &arg_node, NULL TSRMLS_CC);
2732        }
2733
2734        opline->op2.opline_num = i;
2735    }
2736    zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC);
2737
2738    return SUCCESS;
2739}
2740/* }}} */
2741
2742int zend_try_compile_special_func(znode *result, zend_string *lcname, zend_ast_list *args TSRMLS_DC) /* {{{ */
2743{
2744    if (zend_string_equals_literal(lcname, "strlen")) {
2745        return zend_compile_func_strlen(result, args TSRMLS_CC);
2746    } else if (zend_string_equals_literal(lcname, "is_null")) {
2747        return zend_compile_func_typecheck(result, args, IS_NULL TSRMLS_CC);
2748    } else if (zend_string_equals_literal(lcname, "is_bool")) {
2749        return zend_compile_func_typecheck(result, args, _IS_BOOL TSRMLS_CC);
2750    } else if (zend_string_equals_literal(lcname, "is_long")
2751        || zend_string_equals_literal(lcname, "is_int")
2752        || zend_string_equals_literal(lcname, "is_integer")
2753    ) {
2754        return zend_compile_func_typecheck(result, args, IS_LONG TSRMLS_CC);
2755    } else if (zend_string_equals_literal(lcname, "is_float")
2756        || zend_string_equals_literal(lcname, "is_double")
2757        || zend_string_equals_literal(lcname, "is_real")
2758    ) {
2759        return zend_compile_func_typecheck(result, args, IS_DOUBLE TSRMLS_CC);
2760    } else if (zend_string_equals_literal(lcname, "is_string")) {
2761        return zend_compile_func_typecheck(result, args, IS_STRING TSRMLS_CC);
2762    } else if (zend_string_equals_literal(lcname, "is_array")) {
2763        return zend_compile_func_typecheck(result, args, IS_ARRAY TSRMLS_CC);
2764    } else if (zend_string_equals_literal(lcname, "is_object")) {
2765        return zend_compile_func_typecheck(result, args, IS_OBJECT TSRMLS_CC);
2766    } else if (zend_string_equals_literal(lcname, "is_resource")) {
2767        return zend_compile_func_typecheck(result, args, IS_RESOURCE TSRMLS_CC);
2768    } else if (zend_string_equals_literal(lcname, "defined")) {
2769        return zend_compile_func_defined(result, args TSRMLS_CC);
2770    } else if (zend_string_equals_literal(lcname, "call_user_func_array")) {
2771        return zend_compile_func_cufa(result, args, lcname TSRMLS_CC);
2772    } else if (zend_string_equals_literal(lcname, "call_user_func")) {
2773        return zend_compile_func_cuf(result, args, lcname TSRMLS_CC);
2774    } else {
2775        return FAILURE;
2776    }
2777}
2778/* }}} */
2779
2780void zend_compile_call(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2781{
2782    zend_ast *name_ast = ast->child[0];
2783    zend_ast *args_ast = ast->child[1];
2784
2785    znode name_node;
2786
2787    if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) {
2788        zend_compile_expr(&name_node, name_ast TSRMLS_CC);
2789        zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC);
2790        return;
2791    }
2792
2793    {
2794        zend_bool runtime_resolution = zend_compile_function_name(&name_node, name_ast TSRMLS_CC);
2795        if (runtime_resolution) {
2796            zend_compile_ns_call(result, &name_node, args_ast TSRMLS_CC);
2797            return;
2798        }
2799    }
2800
2801    {
2802        zval *name = &name_node.u.constant;
2803        zend_string *lcname = zend_string_alloc(Z_STRLEN_P(name), 0);
2804        zend_function *fbc;
2805        zend_op *opline;
2806
2807        zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
2808
2809        fbc = zend_hash_find_ptr(CG(function_table), lcname);
2810        if (!fbc || (fbc->type == ZEND_INTERNAL_FUNCTION &&
2811            (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
2812        ) {
2813            zend_string_release(lcname);
2814            zend_compile_dynamic_call(result, &name_node, args_ast TSRMLS_CC);
2815            return;
2816        }
2817
2818        if (zend_try_compile_special_func(result, lcname,
2819                zend_ast_get_list(args_ast) TSRMLS_CC) == SUCCESS
2820        ) {
2821            zend_string_release(lcname);
2822            zval_ptr_dtor(&name_node.u.constant);
2823            return;
2824        }
2825
2826        zval_ptr_dtor(&name_node.u.constant);
2827        ZVAL_NEW_STR(&name_node.u.constant, lcname);
2828
2829        opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, &name_node TSRMLS_CC);
2830        zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
2831
2832        zend_compile_call_common(result, args_ast, fbc TSRMLS_CC);
2833    }
2834}
2835/* }}} */
2836
2837void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2838{
2839    zend_ast *obj_ast = ast->child[0];
2840    zend_ast *method_ast = ast->child[1];
2841    zend_ast *args_ast = ast->child[2];
2842
2843    znode obj_node, method_node;
2844    zend_op *opline;
2845
2846    if (is_this_fetch(obj_ast)) {
2847        obj_node.op_type = IS_UNUSED;
2848    } else {
2849        zend_compile_expr(&obj_node, obj_ast TSRMLS_CC);
2850    }
2851
2852    zend_compile_expr(&method_node, method_ast TSRMLS_CC);
2853    opline = zend_emit_op(NULL, ZEND_INIT_METHOD_CALL, &obj_node, NULL TSRMLS_CC);
2854
2855    if (method_node.op_type == IS_CONST) {
2856        if (Z_TYPE(method_node.u.constant) != IS_STRING) {
2857            zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string");
2858        }
2859
2860        opline->op2_type = IS_CONST;
2861        opline->op2.constant = zend_add_func_name_literal(CG(active_op_array),
2862            Z_STR(method_node.u.constant) TSRMLS_CC);
2863        zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
2864    } else {
2865        SET_NODE(opline->op2, &method_node);
2866    }
2867
2868    zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
2869}
2870/* }}} */
2871
2872zend_bool zend_is_constructor(zend_string *name) /* {{{ */
2873{
2874    return zend_string_equals_literal_ci(name, ZEND_CONSTRUCTOR_FUNC_NAME);
2875}
2876/* }}} */
2877
2878void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type TSRMLS_DC) /* {{{ */
2879{
2880    zend_ast *class_ast = ast->child[0];
2881    zend_ast *method_ast = ast->child[1];
2882    zend_ast *args_ast = ast->child[2];
2883
2884    znode class_node, method_node;
2885    zend_op *opline;
2886    zend_ulong extended_value = 0;
2887
2888    if (zend_is_const_default_class_ref(class_ast)) {
2889        class_node.op_type = IS_CONST;
2890        ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC));
2891    } else {
2892        opline = zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
2893        extended_value = opline->extended_value;
2894    }
2895
2896    zend_compile_expr(&method_node, method_ast TSRMLS_CC);
2897    if (method_node.op_type == IS_CONST) {
2898        zval *name = &method_node.u.constant;
2899        if (Z_TYPE_P(name) != IS_STRING) {
2900            zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string");
2901        }
2902        if (zend_is_constructor(Z_STR_P(name))) {
2903            zval_ptr_dtor(name);
2904            method_node.op_type = IS_UNUSED;
2905        }
2906    }
2907
2908    opline = get_next_op(CG(active_op_array) TSRMLS_CC);
2909    opline->opcode = ZEND_INIT_STATIC_METHOD_CALL;
2910    opline->extended_value = extended_value;
2911
2912    zend_set_class_name_op1(opline, &class_node TSRMLS_CC);
2913
2914    if (method_node.op_type == IS_CONST) {
2915        opline->op2_type = IS_CONST;
2916        opline->op2.constant = zend_add_func_name_literal(CG(active_op_array),
2917            Z_STR(method_node.u.constant) TSRMLS_CC);
2918        if (opline->op1_type == IS_CONST) {
2919            zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
2920        } else {
2921            zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC);
2922        }
2923    } else {
2924        SET_NODE(opline->op2, &method_node);
2925    }
2926
2927    zend_compile_call_common(result, args_ast, NULL TSRMLS_CC);
2928}
2929/* }}} */
2930
2931void zend_compile_new(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
2932{
2933    zend_ast *class_ast = ast->child[0];
2934    zend_ast *args_ast = ast->child[1];
2935
2936    znode class_node, ctor_result;
2937    zend_op *opline;
2938    uint32_t opnum;
2939
2940    if (zend_is_const_default_class_ref(class_ast)) {
2941        class_node.op_type = IS_CONST;
2942        ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(class_ast TSRMLS_CC));
2943    } else {
2944        zend_compile_class_ref(&class_node, class_ast TSRMLS_CC);
2945    }
2946
2947    opnum = get_next_op_number(CG(active_op_array));
2948    opline = zend_emit_op(result, ZEND_NEW, NULL, NULL TSRMLS_CC);
2949
2950    if (class_node.op_type == IS_CONST) {
2951        opline->op1_type = IS_CONST;
2952        opline->op1.constant = zend_add_class_name_literal(
2953            CG(active_op_array), Z_STR(class_node.u.constant) TSRMLS_CC);
2954    } else {
2955        SET_NODE(opline->op1, &class_node);
2956    }
2957
2958    zend_compile_call_common(&ctor_result, args_ast, NULL TSRMLS_CC);
2959    zend_do_free(&ctor_result TSRMLS_CC);
2960
2961    /* New jumps over ctor call if ctor does not exist */
2962    opline = &CG(active_op_array)->opcodes[opnum];
2963    opline->op2.opline_num = get_next_op_number(CG(active_op_array));
2964}
2965/* }}} */
2966
2967void zend_compile_clone(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
2968{
2969    zend_ast *obj_ast = ast->child[0];
2970
2971    znode obj_node;
2972    zend_compile_expr(&obj_node, obj_ast TSRMLS_CC);
2973
2974    zend_emit_op(result, ZEND_CLONE, &obj_node, NULL TSRMLS_CC);
2975}
2976/* }}} */
2977
2978void zend_compile_global_var(zend_ast *ast TSRMLS_DC) /* {{{ */
2979{
2980    zend_ast *var_ast = ast->child[0];
2981    zend_ast *name_ast = var_ast->child[0];
2982
2983    znode name_node, result;
2984
2985    zend_compile_expr(&name_node, name_ast TSRMLS_CC);
2986    if (name_node.op_type == IS_CONST) {
2987        if (Z_TYPE(name_node.u.constant) != IS_STRING) {
2988            convert_to_string(&name_node.u.constant);
2989        }
2990    }
2991
2992    if (zend_try_compile_cv(&result, var_ast TSRMLS_CC) == SUCCESS) {
2993        zend_op *opline = zend_emit_op(NULL, ZEND_BIND_GLOBAL, &result, &name_node TSRMLS_CC);
2994        zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC);
2995    } else {
2996        zend_emit_op(&result, ZEND_FETCH_W, &name_node, NULL TSRMLS_CC);
2997
2998        // TODO.AST Avoid double fetch
2999        //opline->extended_value = ZEND_FETCH_GLOBAL_LOCK;
3000
3001        zend_emit_assign_ref_znode(var_ast, &result TSRMLS_CC);
3002    }
3003}
3004/* }}} */
3005
3006static void zend_compile_static_var_common(zend_ast *var_ast, zval *value, zend_bool by_ref TSRMLS_DC) /* {{{ */
3007{
3008    znode var_node, result;
3009    zend_op *opline;
3010
3011    zend_compile_expr(&var_node, var_ast TSRMLS_CC);
3012
3013    if (!CG(active_op_array)->static_variables) {
3014        if (CG(active_op_array)->scope) {
3015            CG(active_op_array)->scope->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
3016        }
3017        ALLOC_HASHTABLE(CG(active_op_array)->static_variables);
3018        zend_hash_init(CG(active_op_array)->static_variables, 8, NULL, ZVAL_PTR_DTOR, 0);
3019    }
3020
3021    zend_hash_update(CG(active_op_array)->static_variables, Z_STR(var_node.u.constant), value);
3022
3023    opline = zend_emit_op(&result, by_ref ? ZEND_FETCH_W : ZEND_FETCH_R, &var_node, NULL TSRMLS_CC);
3024    opline->extended_value = ZEND_FETCH_STATIC;
3025
3026    if (by_ref) {
3027        zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast);
3028        zend_emit_assign_ref_znode(fetch_ast, &result TSRMLS_CC);
3029    } else {
3030        zend_ast *fetch_ast = zend_ast_create(ZEND_AST_VAR, var_ast);
3031        zend_emit_assign_znode(fetch_ast, &result TSRMLS_CC);
3032    }
3033}
3034/* }}} */
3035
3036void zend_compile_static_var(zend_ast *ast TSRMLS_DC) /* {{{ */
3037{
3038    zend_ast *var_ast = ast->child[0];
3039    zend_ast *value_ast = ast->child[1];
3040    zval value_zv;
3041
3042    if (value_ast) {
3043        zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
3044    } else {
3045        ZVAL_NULL(&value_zv);
3046    }
3047
3048    zend_compile_static_var_common(var_ast, &value_zv, 1 TSRMLS_CC);
3049}
3050/* }}} */
3051
3052void zend_compile_unset(zend_ast *ast TSRMLS_DC) /* {{{ */
3053{
3054    zend_ast *var_ast = ast->child[0];
3055
3056    znode var_node;
3057    zend_op *opline;
3058    switch (var_ast->kind) {
3059        case ZEND_AST_VAR:
3060            if (zend_try_compile_cv(&var_node, var_ast TSRMLS_CC) == SUCCESS) {
3061                opline = zend_emit_op(NULL, ZEND_UNSET_VAR, &var_node, NULL TSRMLS_CC);
3062                opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
3063            } else {
3064                opline = zend_compile_simple_var_no_cv(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
3065                opline->opcode = ZEND_UNSET_VAR;
3066            }
3067            return;
3068        case ZEND_AST_DIM:
3069            opline = zend_compile_dim_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
3070            opline->opcode = ZEND_UNSET_DIM;
3071            return;
3072        case ZEND_AST_PROP:
3073            opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
3074            opline->opcode = ZEND_UNSET_OBJ;
3075            return;
3076        case ZEND_AST_STATIC_PROP:
3077            opline = zend_compile_static_prop_common(NULL, var_ast, BP_VAR_UNSET TSRMLS_CC);
3078            opline->opcode = ZEND_UNSET_VAR;
3079            return;
3080        EMPTY_SWITCH_DEFAULT_CASE()
3081    }
3082}
3083/* }}} */
3084
3085static void zend_free_foreach_and_switch_variables(TSRMLS_D) /* {{{ */
3086{
3087    uint32_t opnum_start, opnum_end, i;
3088
3089    opnum_start = get_next_op_number(CG(active_op_array));
3090
3091#ifdef ZTS
3092    zend_stack_apply_with_argument(&CG(loop_var_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_loop_var TSRMLS_CC);
3093#else
3094    zend_stack_apply(&CG(loop_var_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_loop_var);
3095#endif
3096
3097    opnum_end = get_next_op_number(CG(active_op_array));
3098
3099    for (i = opnum_start; i < opnum_end; ++i) {
3100        CG(active_op_array)->opcodes[i].extended_value |= EXT_TYPE_FREE_ON_RETURN;
3101    }
3102}
3103/* }}} */
3104
3105void zend_compile_return(zend_ast *ast TSRMLS_DC) /* {{{ */
3106{
3107    zend_ast *expr_ast = ast->child[0];
3108    zend_bool by_ref = (CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
3109
3110    znode expr_node;
3111    zend_op *opline;
3112
3113    if (!expr_ast) {
3114        expr_node.op_type = IS_CONST;
3115        ZVAL_NULL(&expr_node.u.constant);
3116    } else if (by_ref && zend_is_variable(expr_ast) && !zend_is_call(expr_ast)) {
3117        zend_compile_var(&expr_node, expr_ast, BP_VAR_REF TSRMLS_CC);
3118    } else {
3119        zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
3120    }
3121
3122    zend_free_foreach_and_switch_variables(TSRMLS_C);
3123
3124    if (CG(context).in_finally) {
3125        zend_emit_op(NULL, ZEND_DISCARD_EXCEPTION, NULL, NULL TSRMLS_CC);
3126    }
3127
3128    opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN,
3129        &expr_node, NULL TSRMLS_CC);
3130
3131    if (expr_ast) {
3132        if (zend_is_call(expr_ast)) {
3133            opline->extended_value = ZEND_RETURNS_FUNCTION;
3134        } else if (by_ref && !zend_is_variable(expr_ast)) {
3135            opline->extended_value = ZEND_RETURNS_VALUE;
3136        }
3137    }
3138}
3139/* }}} */
3140
3141void zend_compile_echo(zend_ast *ast TSRMLS_DC) /* {{{ */
3142{
3143    zend_ast *expr_ast = ast->child[0];
3144
3145    znode expr_node;
3146    zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
3147
3148    zend_emit_op(NULL, ZEND_ECHO, &expr_node, NULL TSRMLS_CC);
3149}
3150/* }}} */
3151
3152void zend_compile_throw(zend_ast *ast TSRMLS_DC) /* {{{ */
3153{
3154    zend_ast *expr_ast = ast->child[0];
3155
3156    znode expr_node;
3157    zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
3158
3159    zend_emit_op(NULL, ZEND_THROW, &expr_node, NULL TSRMLS_CC);
3160}
3161/* }}} */
3162
3163void zend_compile_break_continue(zend_ast *ast TSRMLS_DC) /* {{{ */
3164{
3165    zend_ast *depth_ast = ast->child[0];
3166
3167    znode depth_node;
3168    zend_op *opline;
3169
3170    ZEND_ASSERT(ast->kind == ZEND_AST_BREAK || ast->kind == ZEND_AST_CONTINUE);
3171
3172    if (depth_ast) {
3173        if (depth_ast->kind != ZEND_AST_ZVAL) {
3174            zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator with non-constant operand "
3175                "is no longer supported", ast->kind == ZEND_AST_BREAK ? "break" : "continue");
3176        }
3177
3178        zend_compile_expr(&depth_node, depth_ast TSRMLS_CC);
3179
3180        if (Z_TYPE(depth_node.u.constant) != IS_LONG || Z_LVAL(depth_node.u.constant) < 1) {
3181            zend_error_noreturn(E_COMPILE_ERROR, "'%s' operator accepts only positive numbers",
3182                ast->kind == ZEND_AST_BREAK ? "break" : "continue");
3183        }
3184    } else {
3185        depth_node.op_type = IS_CONST;
3186        ZVAL_LONG(&depth_node.u.constant, 1);
3187    }
3188
3189    opline = zend_emit_op(NULL, ast->kind == ZEND_AST_BREAK ? ZEND_BRK : ZEND_CONT,
3190        NULL, &depth_node TSRMLS_CC);
3191    opline->op1.opline_num = CG(context).current_brk_cont;
3192}
3193/* }}} */
3194
3195void zend_compile_goto(zend_ast *ast TSRMLS_DC) /* {{{ */
3196{
3197    zend_ast *label_ast = ast->child[0];
3198    znode label_node;
3199    zend_op *opline;
3200
3201    zend_compile_expr(&label_node, label_ast TSRMLS_CC);
3202    opline = zend_emit_op(NULL, ZEND_GOTO, NULL, &label_node TSRMLS_CC);
3203    opline->extended_value = CG(context).current_brk_cont;
3204    zend_resolve_goto_label(CG(active_op_array), opline, 0 TSRMLS_CC);
3205}
3206/* }}} */
3207
3208void zend_compile_label(zend_ast *ast TSRMLS_DC) /* {{{ */
3209{
3210    zend_string *label = zend_ast_get_str(ast->child[0]);
3211    zend_label dest;
3212
3213    if (!CG(context).labels) {
3214        ALLOC_HASHTABLE(CG(context).labels);
3215        zend_hash_init(CG(context).labels, 8, NULL, ptr_dtor, 0);
3216    }
3217
3218    dest.brk_cont = CG(context).current_brk_cont;
3219    dest.opline_num = get_next_op_number(CG(active_op_array));
3220
3221    if (!zend_hash_add_mem(CG(context).labels, label, &dest, sizeof(zend_label))) {
3222        zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", label->val);
3223    }
3224}
3225/* }}} */
3226
3227void zend_compile_while(zend_ast *ast TSRMLS_DC) /* {{{ */
3228{
3229    zend_ast *cond_ast = ast->child[0];
3230    zend_ast *stmt_ast = ast->child[1];
3231
3232    znode cond_node;
3233    uint32_t opnum_start, opnum_jmpz;
3234
3235    opnum_start = get_next_op_number(CG(active_op_array));
3236    zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
3237
3238    opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC);
3239    zend_begin_loop(TSRMLS_C);
3240
3241    zend_compile_stmt(stmt_ast TSRMLS_CC);
3242
3243    zend_emit_jump(opnum_start TSRMLS_CC);
3244
3245    zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
3246
3247    zend_end_loop(opnum_start, 0 TSRMLS_CC);
3248}
3249/* }}} */
3250
3251void zend_compile_do_while(zend_ast *ast TSRMLS_DC) /* {{{ */
3252{
3253    zend_ast *stmt_ast = ast->child[0];
3254    zend_ast *cond_ast = ast->child[1];
3255
3256    znode cond_node;
3257    uint32_t opnum_start, opnum_cond;
3258
3259    zend_begin_loop(TSRMLS_C);
3260
3261    opnum_start = get_next_op_number(CG(active_op_array));
3262    zend_compile_stmt(stmt_ast TSRMLS_CC);
3263
3264    opnum_cond = get_next_op_number(CG(active_op_array));
3265    zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
3266
3267    zend_emit_cond_jump(ZEND_JMPNZ, &cond_node, opnum_start TSRMLS_CC);
3268
3269    zend_end_loop(opnum_cond, 0 TSRMLS_CC);
3270}
3271/* }}} */
3272
3273void zend_compile_expr_list(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
3274{
3275    zend_ast_list *list;
3276    uint32_t i;
3277
3278    result->op_type = IS_CONST;
3279    ZVAL_TRUE(&result->u.constant);
3280
3281    if (!ast) {
3282        return;
3283    }
3284
3285    list = zend_ast_get_list(ast);
3286    for (i = 0; i < list->children; ++i) {
3287        zend_ast *expr_ast = list->child[i];
3288
3289        zend_do_free(result TSRMLS_CC);
3290        zend_compile_expr(result, expr_ast TSRMLS_CC);
3291    }
3292}
3293/* }}} */
3294
3295void zend_compile_for(zend_ast *ast TSRMLS_DC) /* {{{ */
3296{
3297    zend_ast *init_ast = ast->child[0];
3298    zend_ast *cond_ast = ast->child[1];
3299    zend_ast *loop_ast = ast->child[2];
3300    zend_ast *stmt_ast = ast->child[3];
3301
3302    znode result;
3303    uint32_t opnum_cond, opnum_jmpz, opnum_loop;
3304
3305    zend_compile_expr_list(&result, init_ast TSRMLS_CC);
3306    zend_do_free(&result TSRMLS_CC);
3307
3308    opnum_cond = get_next_op_number(CG(active_op_array));
3309    zend_compile_expr_list(&result, cond_ast TSRMLS_CC);
3310    zend_do_extended_info(TSRMLS_C);
3311
3312    opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &result, 0 TSRMLS_CC);
3313    zend_begin_loop(TSRMLS_C);
3314
3315    zend_compile_stmt(stmt_ast TSRMLS_CC);
3316
3317    opnum_loop = get_next_op_number(CG(active_op_array));
3318    zend_compile_expr_list(&result, loop_ast TSRMLS_CC);
3319    zend_do_free(&result TSRMLS_CC);
3320
3321    zend_emit_jump(opnum_cond TSRMLS_CC);
3322
3323    zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
3324
3325    zend_end_loop(opnum_loop, 0 TSRMLS_CC);
3326}
3327/* }}} */
3328
3329void zend_compile_foreach(zend_ast *ast TSRMLS_DC) /* {{{ */
3330{
3331    zend_ast *expr_ast = ast->child[0];
3332    zend_ast *value_ast = ast->child[1];
3333    zend_ast *key_ast = ast->child[2];
3334    zend_ast *stmt_ast = ast->child[3];
3335    zend_bool by_ref = value_ast->kind == ZEND_AST_REF;
3336    zend_bool is_variable = zend_is_variable(expr_ast) && !zend_is_call(expr_ast)
3337        && zend_can_write_to_variable(expr_ast);
3338
3339    znode expr_node, reset_node, value_node, key_node;
3340    zend_op *opline;
3341    uint32_t opnum_reset, opnum_fetch;
3342
3343    if (key_ast) {
3344        if (key_ast->kind == ZEND_AST_REF) {
3345            zend_error_noreturn(E_COMPILE_ERROR, "Key element cannot be a reference");
3346        }
3347        if (key_ast->kind == ZEND_AST_LIST) {
3348            zend_error_noreturn(E_COMPILE_ERROR, "Cannot use list as key element");
3349        }
3350    }
3351
3352    if (by_ref) {
3353        value_ast = value_ast->child[0];
3354    }
3355
3356    if (by_ref && is_variable) {
3357        zend_compile_var(&expr_node, expr_ast, BP_VAR_W TSRMLS_CC);
3358    } else {
3359        zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
3360    }
3361
3362    if (by_ref) {
3363        zend_separate_if_call_and_write(&expr_node, expr_ast, BP_VAR_W TSRMLS_CC);
3364    }
3365
3366    opnum_reset = get_next_op_number(CG(active_op_array));
3367    opline = zend_emit_op(&reset_node, ZEND_FE_RESET, &expr_node, NULL TSRMLS_CC);
3368    if (by_ref && is_variable) {
3369        opline->extended_value = ZEND_FE_FETCH_BYREF;
3370    }
3371
3372    zend_stack_push(&CG(loop_var_stack), &reset_node);
3373
3374    opnum_fetch = get_next_op_number(CG(active_op_array));
3375    opline = zend_emit_op(&value_node, ZEND_FE_FETCH, &reset_node, NULL TSRMLS_CC);
3376    if (by_ref) {
3377        opline->extended_value |= ZEND_FE_FETCH_BYREF;
3378    }
3379    if (key_ast) {
3380        opline->extended_value |= ZEND_FE_FETCH_WITH_KEY;
3381    }
3382
3383    opline = zend_emit_op(NULL, ZEND_OP_DATA, NULL, NULL TSRMLS_CC);
3384
3385    /* Allocate enough space to keep HashPointer on VM stack */
3386    opline->op1_type = IS_TMP_VAR;
3387    opline->op1.var = get_temporary_variable(CG(active_op_array));
3388    if (sizeof(HashPointer) > sizeof(zval)) {
3389        /* Make sure 1 zval is enough for HashPointer (2 must be enough) */
3390        get_temporary_variable(CG(active_op_array));
3391    }
3392
3393    if (key_ast) {
3394        zend_make_tmp_result(&key_node, opline TSRMLS_CC);
3395    }
3396
3397    if (by_ref) {
3398        zend_emit_assign_ref_znode(value_ast, &value_node TSRMLS_CC);
3399    } else {
3400        zend_emit_assign_znode(value_ast, &value_node TSRMLS_CC);
3401    }
3402
3403    if (key_ast) {
3404        zend_emit_assign_znode(key_ast, &key_node TSRMLS_CC);
3405    }
3406
3407    zend_begin_loop(TSRMLS_C);
3408
3409    zend_compile_stmt(stmt_ast TSRMLS_CC);
3410
3411    zend_emit_jump(opnum_fetch TSRMLS_CC);
3412
3413    opline = &CG(active_op_array)->opcodes[opnum_reset];
3414    opline->op2.opline_num = get_next_op_number(CG(active_op_array));
3415
3416    opline = &CG(active_op_array)->opcodes[opnum_fetch];
3417    opline->op2.opline_num = get_next_op_number(CG(active_op_array));
3418
3419    zend_end_loop(opnum_fetch, 1 TSRMLS_CC);
3420
3421    generate_free_loop_var(&reset_node TSRMLS_CC);
3422    zend_stack_del_top(&CG(loop_var_stack));
3423}
3424/* }}} */
3425
3426void zend_compile_if(zend_ast *ast TSRMLS_DC) /* {{{ */
3427{
3428    zend_ast_list *list = zend_ast_get_list(ast);
3429    uint32_t i;
3430    uint32_t *jmp_opnums;
3431
3432    if (list->children > 1) {
3433        jmp_opnums = safe_emalloc(sizeof(uint32_t), list->children - 1, 0);
3434    }
3435
3436    for (i = 0; i < list->children; ++i) {
3437        zend_ast *elem_ast = list->child[i];
3438        zend_ast *cond_ast = elem_ast->child[0];
3439        zend_ast *stmt_ast = elem_ast->child[1];
3440
3441        znode cond_node;
3442        uint32_t opnum_jmpz;
3443        if (cond_ast) {
3444            zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
3445            opnum_jmpz = zend_emit_cond_jump(ZEND_JMPZ, &cond_node, 0 TSRMLS_CC);
3446        }
3447
3448        zend_compile_stmt(stmt_ast TSRMLS_CC);
3449
3450        if (i != list->children - 1) {
3451            jmp_opnums[i] = zend_emit_jump(0 TSRMLS_CC);
3452        }
3453
3454        if (cond_ast) {
3455            zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
3456        }
3457    }
3458
3459    if (list->children > 1) {
3460        for (i = 0; i < list->children - 1; ++i) {
3461            zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC);
3462        }
3463        efree(jmp_opnums);
3464    }
3465}
3466/* }}} */
3467
3468void zend_compile_switch(zend_ast *ast TSRMLS_DC) /* {{{ */
3469{
3470    zend_ast *expr_ast = ast->child[0];
3471    zend_ast_list *cases = zend_ast_get_list(ast->child[1]);
3472
3473    uint32_t i;
3474    zend_bool has_default_case = 0;
3475
3476    znode expr_node, case_node;
3477    zend_op *opline;
3478    uint32_t *jmpnz_opnums = safe_emalloc(sizeof(uint32_t), cases->children, 0);
3479    uint32_t opnum_default_jmp;
3480
3481    zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
3482
3483    zend_stack_push(&CG(loop_var_stack), &expr_node);
3484
3485    zend_begin_loop(TSRMLS_C);
3486
3487    case_node.op_type = IS_TMP_VAR;
3488    case_node.u.op.var = get_temporary_variable(CG(active_op_array));
3489
3490    for (i = 0; i < cases->children; ++i) {
3491        zend_ast *case_ast = cases->child[i];
3492        zend_ast *cond_ast = case_ast->child[0];
3493        znode cond_node;
3494
3495        if (!cond_ast) {
3496            if (has_default_case) {
3497                CG(zend_lineno) = case_ast->lineno;
3498                zend_error_noreturn(E_COMPILE_ERROR,
3499                    "Switch statements may only contain one default clause");
3500            }
3501            has_default_case = 1;
3502            continue;
3503        }
3504
3505        zend_compile_expr(&cond_node, cond_ast TSRMLS_CC);
3506
3507        opline = zend_emit_op(NULL, ZEND_CASE, &expr_node, &cond_node TSRMLS_CC);
3508        SET_NODE(opline->result, &case_node);
3509        if (opline->op1_type == IS_CONST) {
3510            zval_copy_ctor(&CONSTANT(opline->op1.constant));
3511        }
3512
3513        jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0 TSRMLS_CC);
3514    }
3515
3516    opnum_default_jmp = zend_emit_jump(0 TSRMLS_CC);
3517
3518    for (i = 0; i < cases->children; ++i) {
3519        zend_ast *case_ast = cases->child[i];
3520        zend_ast *cond_ast = case_ast->child[0];
3521        zend_ast *stmt_ast = case_ast->child[1];
3522
3523        if (cond_ast) {
3524            zend_update_jump_target_to_next(jmpnz_opnums[i] TSRMLS_CC);
3525        } else {
3526            zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC);
3527        }
3528
3529        zend_compile_stmt(stmt_ast TSRMLS_CC);
3530    }
3531
3532    if (!has_default_case) {
3533        zend_update_jump_target_to_next(opnum_default_jmp TSRMLS_CC);
3534    }
3535
3536    zend_end_loop(get_next_op_number(CG(active_op_array)), 1 TSRMLS_CC);
3537
3538    if (expr_node.op_type == IS_VAR || expr_node.op_type == IS_TMP_VAR) {
3539        zend_emit_op(NULL, ZEND_FREE,
3540            &expr_node, NULL TSRMLS_CC);
3541    } else if (expr_node.op_type == IS_CONST) {
3542        zval_dtor(&expr_node.u.constant);
3543    }
3544
3545    zend_stack_del_top(&CG(loop_var_stack));
3546    efree(jmpnz_opnums);
3547}
3548/* }}} */
3549
3550void zend_compile_try(zend_ast *ast TSRMLS_DC) /* {{{ */
3551{
3552    zend_ast *try_ast = ast->child[0];
3553    zend_ast_list *catches = zend_ast_get_list(ast->child[1]);
3554    zend_ast *finally_ast = ast->child[2];
3555
3556    uint32_t i;
3557    zend_op *opline;
3558    uint32_t try_catch_offset = zend_add_try_element(
3559        get_next_op_number(CG(active_op_array)) TSRMLS_CC);
3560    uint32_t *jmp_opnums = safe_emalloc(sizeof(uint32_t), catches->children, 0);
3561
3562    if (catches->children == 0 && !finally_ast) {
3563        zend_error_noreturn(E_COMPILE_ERROR, "Cannot use try without catch or finally");
3564    }
3565
3566    zend_compile_stmt(try_ast TSRMLS_CC);
3567
3568    if (catches->children != 0) {
3569        jmp_opnums[0] = zend_emit_jump(0 TSRMLS_CC);
3570    }
3571
3572    for (i = 0; i < catches->children; ++i) {
3573        zend_ast *catch_ast = catches->child[i];
3574        zend_ast *class_ast = catch_ast->child[0];
3575        zend_ast *var_ast = catch_ast->child[1];
3576        zend_ast *stmt_ast = catch_ast->child[2];
3577        zval *var_name = zend_ast_get_zval(var_ast);
3578        zend_bool is_last_catch = (i + 1 == catches->children);
3579
3580        uint32_t opnum_catch;
3581
3582        if (!zend_is_const_default_class_ref(class_ast)) {
3583            zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement");
3584        }
3585
3586        opnum_catch = get_next_op_number(CG(active_op_array));
3587        if (i == 0) {
3588            CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = opnum_catch;
3589        }
3590
3591        CG(zend_lineno) = catch_ast->lineno;
3592
3593        opline = get_next_op(CG(active_op_array) TSRMLS_CC);
3594        opline->opcode = ZEND_CATCH;
3595        opline->op1_type = IS_CONST;
3596        opline->op1.constant = zend_add_class_name_literal(CG(active_op_array),
3597            zend_resolve_class_name_ast(class_ast TSRMLS_CC) TSRMLS_CC);
3598
3599        opline->op2_type = IS_CV;
3600        opline->op2.var = lookup_cv(CG(active_op_array), zend_string_copy(Z_STR_P(var_name)) TSRMLS_CC);
3601        opline->result.num = is_last_catch;
3602
3603        zend_compile_stmt(stmt_ast TSRMLS_CC);
3604
3605        if (!is_last_catch) {
3606            jmp_opnums[i + 1] = zend_emit_jump(0 TSRMLS_CC);
3607        }
3608
3609        opline = &CG(active_op_array)->opcodes[opnum_catch];
3610        opline->extended_value = get_next_op_number(CG(active_op_array));
3611    }
3612
3613    for (i = 0; i < catches->children; ++i) {
3614        zend_update_jump_target_to_next(jmp_opnums[i] TSRMLS_CC);
3615    }
3616
3617    if (finally_ast) {
3618        uint32_t opnum_jmp = get_next_op_number(CG(active_op_array)) + 1;
3619
3620        opline = zend_emit_op(NULL, ZEND_FAST_CALL, NULL, NULL TSRMLS_CC);
3621        opline->op1.opline_num = opnum_jmp + 1;
3622
3623        zend_emit_op(NULL, ZEND_JMP, NULL, NULL TSRMLS_CC);
3624
3625        CG(context).in_finally++;
3626        zend_compile_stmt(finally_ast TSRMLS_CC);
3627        CG(context).in_finally--;
3628
3629        CG(active_op_array)->try_catch_array[try_catch_offset].finally_op = opnum_jmp + 1;
3630        CG(active_op_array)->try_catch_array[try_catch_offset].finally_end
3631            = get_next_op_number(CG(active_op_array));
3632        CG(active_op_array)->fn_flags |= ZEND_ACC_HAS_FINALLY_BLOCK;
3633
3634        zend_emit_op(NULL, ZEND_FAST_RET, NULL, NULL TSRMLS_CC);
3635
3636        zend_update_jump_target_to_next(opnum_jmp TSRMLS_CC);
3637    }
3638
3639    efree(jmp_opnums);
3640}
3641/* }}} */
3642
3643/* Encoding declarations must already be handled during parsing */
3644void zend_handle_encoding_declaration(zend_ast *ast TSRMLS_DC) /* {{{ */
3645{
3646    zend_ast_list *declares = zend_ast_get_list(ast);
3647    uint32_t i;
3648    for (i = 0; i < declares->children; ++i) {
3649        zend_ast *declare_ast = declares->child[i];
3650        zend_ast *name_ast = declare_ast->child[0];
3651        zend_ast *value_ast = declare_ast->child[1];
3652        zend_string *name = zend_ast_get_str(name_ast);
3653
3654        if (zend_string_equals_literal_ci(name, "encoding")) {
3655            if (value_ast->kind != ZEND_AST_ZVAL) {
3656                zend_error_noreturn(E_COMPILE_ERROR, "Encoding must be a literal");
3657            }
3658
3659            if (CG(multibyte)) {
3660                zend_string *encoding_name = zval_get_string(zend_ast_get_zval(value_ast));
3661
3662                const zend_encoding *new_encoding, *old_encoding;
3663                zend_encoding_filter old_input_filter;
3664
3665                CG(encoding_declared) = 1;
3666
3667                new_encoding = zend_multibyte_fetch_encoding(encoding_name->val TSRMLS_CC);
3668                if (!new_encoding) {
3669                    zend_error(E_COMPILE_WARNING, "Unsupported encoding [%s]", encoding_name->val);
3670                } else {
3671                    old_input_filter = LANG_SCNG(input_filter);
3672                    old_encoding = LANG_SCNG(script_encoding);
3673                    zend_multibyte_set_filter(new_encoding TSRMLS_CC);
3674
3675                    /* need to re-scan if input filter changed */
3676                    if (old_input_filter != LANG_SCNG(input_filter) ||
3677                         (old_input_filter && new_encoding != old_encoding)) {
3678                        zend_multibyte_yyinput_again(old_input_filter, old_encoding TSRMLS_CC);
3679                    }
3680                }
3681
3682                zend_string_release(encoding_name);
3683            } else {
3684                zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because "
3685                    "Zend multibyte feature is turned off by settings");
3686            }
3687        }
3688    }
3689}
3690/* }}} */
3691
3692void zend_compile_declare(zend_ast *ast TSRMLS_DC) /* {{{ */
3693{
3694    zend_ast_list *declares = zend_ast_get_list(ast->child[0]);
3695    zend_ast *stmt_ast = ast->child[1];
3696    zend_declarables orig_declarables = CG(declarables);
3697    uint32_t i;
3698
3699    for (i = 0; i < declares->children; ++i) {
3700        zend_ast *declare_ast = declares->child[i];
3701        zend_ast *name_ast = declare_ast->child[0];
3702        zend_ast *value_ast = declare_ast->child[1];
3703
3704        zend_string *name = zend_ast_get_str(name_ast);
3705        if (zend_string_equals_literal_ci(name, "ticks")) {
3706            zval value_zv;
3707            zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
3708            convert_to_long(&value_zv);
3709            ZVAL_COPY_VALUE(&CG(declarables).ticks, &value_zv);
3710            zval_dtor(&value_zv);
3711        } else if (zend_string_equals_literal_ci(name, "encoding")) {
3712            /* Encoding declaration was already handled during parsing. Here we
3713             * only check that it is the first statement in the file. */
3714            uint32_t num = CG(active_op_array)->last;
3715            while (num > 0 &&
3716                   (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
3717                    CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
3718                --num;
3719            }
3720
3721            if (num > 0) {
3722                zend_error_noreturn(E_COMPILE_ERROR, "Encoding declaration pragma must be "
3723                    "the very first statement in the script");
3724            }
3725        } else {
3726            zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", name->val);
3727        }
3728    }
3729
3730    if (stmt_ast) {
3731        zend_compile_stmt(stmt_ast TSRMLS_CC);
3732
3733        CG(declarables) = orig_declarables;
3734    }
3735}
3736/* }}} */
3737
3738void zend_compile_stmt_list(zend_ast *ast TSRMLS_DC) /* {{{ */
3739{
3740    zend_ast_list *list = zend_ast_get_list(ast);
3741    uint32_t i;
3742    for (i = 0; i < list->children; ++i) {
3743        zend_compile_stmt(list->child[i] TSRMLS_CC);
3744    }
3745}
3746/* }}} */
3747
3748void zend_compile_params(zend_ast *ast TSRMLS_DC) /* {{{ */
3749{
3750    zend_ast_list *list = zend_ast_get_list(ast);
3751    uint32_t i;
3752    zend_op_array *op_array = CG(active_op_array);
3753    zend_arg_info *arg_infos;
3754
3755    if (list->children == 0) {
3756        return;
3757    }
3758
3759    arg_infos = safe_emalloc(sizeof(zend_arg_info), list->children, 0);
3760    for (i = 0; i < list->children; ++i) {
3761        zend_ast *param_ast = list->child[i];
3762        zend_ast *type_ast = param_ast->child[0];
3763        zend_ast *var_ast = param_ast->child[1];
3764        zend_ast *default_ast = param_ast->child[2];
3765        zend_string *name = zend_ast_get_str(var_ast);
3766        zend_bool is_ref = (param_ast->attr & ZEND_PARAM_REF) != 0;
3767        zend_bool is_variadic = (param_ast->attr & ZEND_PARAM_VARIADIC) != 0;
3768
3769        znode var_node, default_node;
3770        zend_uchar opcode;
3771        zend_op *opline;
3772        zend_arg_info *arg_info;
3773
3774        if (zend_is_auto_global(name TSRMLS_CC)) {
3775            zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s",
3776                name->val);
3777        }
3778
3779        var_node.op_type = IS_CV;
3780        var_node.u.op.var = lookup_cv(CG(active_op_array), zend_string_copy(name) TSRMLS_CC);
3781
3782        if (EX_VAR_TO_NUM(var_node.u.op.var) != i) {
3783            zend_error_noreturn(E_COMPILE_ERROR, "Redefinition of parameter $%s",
3784                name->val);
3785        } else if (zend_string_equals_literal(name, "this")) {
3786            if (op_array->scope && (op_array->fn_flags & ZEND_ACC_STATIC) == 0) {
3787                zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
3788            }
3789            op_array->this_var = var_node.u.op.var;
3790        }
3791
3792        if (op_array->fn_flags & ZEND_ACC_VARIADIC) {
3793            zend_error_noreturn(E_COMPILE_ERROR, "Only the last parameter can be variadic");
3794        }
3795
3796        if (is_variadic) {
3797            opcode = ZEND_RECV_VARIADIC;
3798            default_node.op_type = IS_UNUSED;
3799            op_array->fn_flags |= ZEND_ACC_VARIADIC;
3800
3801            if (default_ast) {
3802                zend_error_noreturn(E_COMPILE_ERROR,
3803                    "Variadic parameter cannot have a default value");
3804            }
3805        } else if (default_ast) {
3806            opcode = ZEND_RECV_INIT;
3807            default_node.op_type = IS_CONST;
3808            zend_const_expr_to_zval(&default_node.u.constant, default_ast TSRMLS_CC);
3809        } else {
3810            opcode = ZEND_RECV;
3811            default_node.op_type = IS_UNUSED;
3812            op_array->required_num_args = i + 1;
3813        }
3814
3815        opline = zend_emit_op(NULL, opcode, NULL, &default_node TSRMLS_CC);
3816        SET_NODE(opline->result, &var_node);
3817        opline->op1.num = i + 1;
3818
3819        arg_info = &arg_infos[i];
3820        arg_info->name = estrndup(name->val, name->len);
3821        arg_info->name_len = (uint32_t)name->len;
3822        arg_info->pass_by_reference = is_ref;
3823        arg_info->is_variadic = is_variadic;
3824        arg_info->type_hint = 0;
3825        arg_info->allow_null = 1;
3826        arg_info->class_name = NULL;
3827        arg_info->class_name_len = 0;
3828
3829        if (type_ast) {
3830            zend_bool has_null_default = default_ast
3831                && (Z_TYPE(default_node.u.constant) == IS_NULL
3832                    || (Z_TYPE(default_node.u.constant) == IS_CONSTANT
3833                        && strcasecmp(Z_STRVAL(default_node.u.constant), "NULL") == 0)
3834                    || Z_TYPE(default_node.u.constant) == IS_CONSTANT_AST); // ???
3835
3836            op_array->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS;
3837            arg_info->allow_null = has_null_default;
3838
3839            if (type_ast->kind == ZEND_AST_TYPE) {
3840                arg_info->type_hint = type_ast->attr;
3841                if (arg_info->type_hint == IS_ARRAY) {
3842                    if (default_ast && !has_null_default
3843                        && Z_TYPE(default_node.u.constant) != IS_ARRAY
3844                    ) {
3845                        zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
3846                            "with array type hint can only be an array or NULL");
3847                    }
3848                } else if (arg_info->type_hint == IS_CALLABLE && default_ast) {
3849                    if (!has_null_default) {
3850                        zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
3851                            "with callable type hint can only be NULL");
3852                    }
3853                }
3854            } else {
3855                zend_string *class_name = zend_ast_get_str(type_ast);
3856
3857                if (zend_is_const_default_class_ref(type_ast)) {
3858                    class_name = zend_resolve_class_name_ast(type_ast TSRMLS_CC);
3859                } else {
3860                    zend_string_addref(class_name);
3861                }
3862
3863                arg_info->type_hint = IS_OBJECT;
3864                arg_info->class_name = estrndup(class_name->val, class_name->len);
3865                arg_info->class_name_len = (uint32_t)class_name->len;
3866
3867                zend_string_release(class_name);
3868
3869                if (default_ast && !has_null_default) {
3870                        zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
3871                            "with a class type hint can only be NULL");
3872                }
3873            }
3874        }
3875    }
3876
3877    /* These are assigned at the end to avoid unitialized memory in case of an error */
3878    op_array->num_args = list->children;
3879    op_array->arg_info = arg_infos;
3880}
3881/* }}} */
3882
3883void zend_compile_closure_uses(zend_ast *ast TSRMLS_DC) /* {{{ */
3884{
3885    zend_ast_list *list = zend_ast_get_list(ast);
3886    uint32_t i;
3887
3888    for (i = 0; i < list->children; ++i) {
3889        zend_ast *var_ast = list->child[i];
3890        zend_string *name = zend_ast_get_str(var_ast);
3891        zend_bool by_ref = var_ast->attr;
3892        zval zv;
3893
3894        if (zend_string_equals_literal(name, "this")) {
3895            zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as lexical variable");
3896        }
3897
3898        ZVAL_NULL(&zv);
3899        Z_CONST_FLAGS(zv) = by_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
3900
3901        zend_compile_static_var_common(var_ast, &zv, by_ref TSRMLS_CC);
3902    }
3903}
3904/* }}} */
3905
3906void zend_begin_method_decl(zend_op_array *op_array, zend_string *name, zend_bool has_body TSRMLS_DC) /* {{{ */
3907{
3908    zend_class_entry *ce = CG(active_class_entry);
3909    zend_bool in_interface = (ce->ce_flags & ZEND_ACC_INTERFACE) != 0;
3910    zend_bool in_trait = ZEND_CE_IS_TRAIT(ce);
3911    zend_bool is_public = (op_array->fn_flags & ZEND_ACC_PUBLIC) != 0;
3912    zend_bool is_static = (op_array->fn_flags & ZEND_ACC_STATIC) != 0;
3913
3914    zend_string *lcname;
3915
3916    if (in_interface) {
3917        if ((op_array->fn_flags & ZEND_ACC_PPP_MASK) != ZEND_ACC_PUBLIC) {
3918            zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method "
3919                "%s::%s() must be omitted", ce->name->val, name->val);
3920        }
3921        op_array->fn_flags |= ZEND_ACC_ABSTRACT;
3922    } else if (is_static && (op_array->fn_flags & ZEND_ACC_ABSTRACT)) {
3923        zend_error(E_STRICT, "Static function %s::%s() should not be abstract",
3924            ce->name->val, name->val);
3925    }
3926
3927    if (op_array->fn_flags & ZEND_ACC_ABSTRACT) {
3928        if (op_array->fn_flags & ZEND_ACC_PRIVATE) {
3929            zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private",
3930                in_interface ? "Interface" : "Abstract", ce->name->val, name->val);
3931        }
3932
3933        if (has_body) {
3934            zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body",
3935                in_interface ? "Interface" : "Abstract", ce->name->val, name->val);
3936        }
3937
3938        ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
3939    } else if (!has_body) {
3940        zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body",
3941            ce->name->val, name->val);
3942    }
3943
3944    op_array->scope = ce;
3945    op_array->function_name = zend_string_copy(name);
3946
3947    lcname = zend_string_alloc(name->len, 0);
3948    zend_str_tolower_copy(lcname->val, name->val, name->len);
3949    lcname = zend_new_interned_string(lcname TSRMLS_CC);
3950
3951    if (zend_hash_add_ptr(&ce->function_table, lcname, op_array) == NULL) {
3952        zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()",
3953            ce->name->val, name->val);
3954    }
3955
3956    if (in_interface) {
3957        if (zend_string_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) {
3958            if (!is_public || is_static) {
3959                zend_error(E_WARNING, "The magic method __call() must have "
3960                    "public visibility and cannot be static");
3961            }
3962        } else if (zend_string_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) {
3963            if (!is_public || !is_static) {
3964                zend_error(E_WARNING, "The magic method __callStatic() must have "
3965                    "public visibility and be static");
3966            }
3967        } else if (zend_string_equals_literal(lcname, ZEND_GET_FUNC_NAME)) {
3968            if (!is_public || is_static) {
3969                zend_error(E_WARNING, "The magic method __get() must have "
3970                    "public visibility and cannot be static");
3971            }
3972        } else if (zend_string_equals_literal(lcname, ZEND_SET_FUNC_NAME)) {
3973            if (!is_public || is_static) {
3974                zend_error(E_WARNING, "The magic method __set() must have "
3975                    "public visibility and cannot be static");
3976            }
3977        } else if (zend_string_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) {
3978            if (!is_public || is_static) {
3979                zend_error(E_WARNING, "The magic method __unset() must have "
3980                    "public visibility and cannot be static");
3981            }
3982        } else if (zend_string_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) {
3983            if (!is_public || is_static) {
3984                zend_error(E_WARNING, "The magic method __isset() must have "
3985                    "public visibility and cannot be static");
3986            }
3987        } else if (zend_string_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) {
3988            if (!is_public || is_static) {
3989                zend_error(E_WARNING, "The magic method __toString() must have "
3990                    "public visibility and cannot be static");
3991            }
3992        } else if (zend_string_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) {
3993            if (!is_public || is_static) {
3994                zend_error(E_WARNING, "The magic method __invoke() must have "
3995                    "public visibility and cannot be static");
3996            }
3997        } else if (zend_string_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) {
3998            if (!is_public || is_static) {
3999                zend_error(E_WARNING, "The magic method __debugInfo() must have "
4000                    "public visibility and cannot be static");
4001            }
4002        }
4003    } else {
4004        if (!in_trait && zend_string_equals_str_ci(lcname, ce->name)) {
4005            if (!ce->constructor) {
4006                ce->constructor = (zend_function *) op_array;
4007            }
4008        } else if (zend_string_equals_literal(lcname, ZEND_CONSTRUCTOR_FUNC_NAME)) {
4009            if (CG(active_class_entry)->constructor) {
4010                zend_error(E_STRICT, "Redefining already defined constructor for class %s",
4011                    ce->name->val);
4012            }
4013            ce->constructor = (zend_function *) op_array;
4014        } else if (zend_string_equals_literal(lcname, ZEND_DESTRUCTOR_FUNC_NAME)) {
4015            ce->destructor = (zend_function *) op_array;
4016        } else if (zend_string_equals_literal(lcname, ZEND_CLONE_FUNC_NAME)) {
4017            ce->clone = (zend_function *) op_array;
4018        } else if (zend_string_equals_literal(lcname, ZEND_CALL_FUNC_NAME)) {
4019            if (!is_public || is_static) {
4020                zend_error(E_WARNING, "The magic method __call() must have "
4021                    "public visibility and cannot be static");
4022            }
4023            ce->__call = (zend_function *) op_array;
4024        } else if (zend_string_equals_literal(lcname, ZEND_CALLSTATIC_FUNC_NAME)) {
4025            if (!is_public || !is_static) {
4026                zend_error(E_WARNING, "The magic method __callStatic() must have "
4027                    "public visibility and be static");
4028            }
4029            ce->__callstatic = (zend_function *) op_array;
4030        } else if (zend_string_equals_literal(lcname, ZEND_GET_FUNC_NAME)) {
4031            if (!is_public || is_static) {
4032                zend_error(E_WARNING, "The magic method __get() must have "
4033                    "public visibility and cannot be static");
4034            }
4035            ce->__get = (zend_function *) op_array;
4036        } else if (zend_string_equals_literal(lcname, ZEND_SET_FUNC_NAME)) {
4037            if (!is_public || is_static) {
4038                zend_error(E_WARNING, "The magic method __set() must have "
4039                    "public visibility and cannot be static");
4040            }
4041            ce->__set = (zend_function *) op_array;
4042        } else if (zend_string_equals_literal(lcname, ZEND_UNSET_FUNC_NAME)) {
4043            if (!is_public || is_static) {
4044                zend_error(E_WARNING, "The magic method __unset() must have "
4045                    "public visibility and cannot be static");
4046            }
4047            ce->__unset = (zend_function *) op_array;
4048        } else if (zend_string_equals_literal(lcname, ZEND_ISSET_FUNC_NAME)) {
4049            if (!is_public || is_static) {
4050                zend_error(E_WARNING, "The magic method __isset() must have "
4051                    "public visibility and cannot be static");
4052            }
4053            ce->__isset = (zend_function *) op_array;
4054        } else if (zend_string_equals_literal(lcname, ZEND_TOSTRING_FUNC_NAME)) {
4055            if (!is_public || is_static) {
4056                zend_error(E_WARNING, "The magic method __toString() must have "
4057                    "public visibility and cannot be static");
4058            }
4059            ce->__tostring = (zend_function *) op_array;
4060        } else if (zend_string_equals_literal(lcname, ZEND_INVOKE_FUNC_NAME)) {
4061            if (!is_public || is_static) {
4062                zend_error(E_WARNING, "The magic method __invoke() must have "
4063                    "public visibility and cannot be static");
4064            }
4065        } else if (zend_string_equals_literal(lcname, ZEND_DEBUGINFO_FUNC_NAME)) {
4066            if (!is_public || is_static) {
4067                zend_error(E_WARNING, "The magic method __debugInfo() must have "
4068                    "public visibility and cannot be static");
4069            }
4070            ce->__debugInfo = (zend_function *) op_array;
4071        } else if (!is_static) {
4072            op_array->fn_flags |= ZEND_ACC_ALLOW_STATIC;
4073        }
4074    }
4075
4076    zend_string_release(lcname);
4077}
4078/* }}} */
4079
4080static void zend_begin_func_decl(znode *result, zend_op_array *op_array, zend_ast_decl *decl TSRMLS_DC) /* {{{ */
4081{
4082    zend_ast *params_ast = decl->child[0];
4083    zend_string *name = decl->name, *lcname;
4084    zend_op *opline;
4085
4086    op_array->function_name = name = zend_prefix_with_ns(name TSRMLS_CC);
4087
4088    lcname = zend_string_alloc(name->len, 0);
4089    zend_str_tolower_copy(lcname->val, name->val, name->len);
4090
4091    if (CG(current_import_function)) {
4092        zend_string *import_name = zend_hash_find_ptr(CG(current_import_function), lcname);
4093        if (import_name && !zend_string_equals_str_ci(lcname, import_name)) {
4094            zend_error(E_COMPILE_ERROR, "Cannot declare function %s "
4095                "because the name is already in use", name->val);
4096        }
4097    }
4098
4099    if (zend_string_equals_literal(lcname, ZEND_AUTOLOAD_FUNC_NAME)
4100        && zend_ast_get_list(params_ast)->children != 1
4101    ) {
4102        zend_error_noreturn(E_COMPILE_ERROR, "%s() must take exactly 1 argument",
4103            ZEND_AUTOLOAD_FUNC_NAME);
4104    }
4105
4106    if (op_array->fn_flags & ZEND_ACC_CLOSURE) {
4107        opline = zend_emit_op_tmp(result, ZEND_DECLARE_LAMBDA_FUNCTION, NULL, NULL TSRMLS_CC);
4108    } else {
4109        opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4110        opline->opcode = ZEND_DECLARE_FUNCTION;
4111        opline->op2_type = IS_CONST;
4112        LITERAL_STR(opline->op2, zend_string_copy(lcname));
4113    }
4114
4115    {
4116        zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos TSRMLS_CC);
4117
4118        opline->op1_type = IS_CONST;
4119        LITERAL_STR(opline->op1, key);
4120
4121        zend_hash_update_ptr(CG(function_table), key, op_array);
4122    }
4123
4124    zend_string_release(lcname);
4125}
4126/* }}} */
4127
4128void zend_compile_func_decl(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
4129{
4130    zend_ast_decl *decl = (zend_ast_decl *) ast;
4131    zend_ast *params_ast = decl->child[0];
4132    zend_ast *uses_ast = decl->child[1];
4133    zend_ast *stmt_ast = decl->child[2];
4134    zend_bool is_method = decl->kind == ZEND_AST_METHOD;
4135
4136    zend_op_array *orig_op_array = CG(active_op_array);
4137    zend_op_array *op_array = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
4138
4139    // TODO.AST interactive (not just here - also bpc etc!)
4140
4141    init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
4142
4143    op_array->fn_flags |= decl->flags;
4144    op_array->line_start = decl->start_lineno;
4145    op_array->line_end = decl->end_lineno;
4146    if (decl->doc_comment) {
4147        op_array->doc_comment = zend_string_copy(decl->doc_comment);
4148    }
4149    if (decl->kind == ZEND_AST_CLOSURE) {
4150        op_array->fn_flags |= ZEND_ACC_CLOSURE;
4151    }
4152
4153    if (is_method) {
4154        zend_bool has_body = stmt_ast != NULL;
4155        zend_begin_method_decl(op_array, decl->name, has_body TSRMLS_CC);
4156    } else {
4157        zend_begin_func_decl(result, op_array, decl TSRMLS_CC);
4158    }
4159
4160    CG(active_op_array) = op_array;
4161    zend_stack_push(&CG(context_stack), (void *) &CG(context));
4162    zend_init_compiler_context(TSRMLS_C);
4163
4164    if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
4165        zend_op *opline_ext = zend_emit_op(NULL, ZEND_EXT_NOP, NULL, NULL TSRMLS_CC);
4166        opline_ext->lineno = decl->start_lineno;
4167    }
4168
4169    {
4170        /* Push a separator to the loop variable stack */
4171        znode dummy_var;
4172        dummy_var.op_type = IS_UNUSED;
4173
4174        zend_stack_push(&CG(loop_var_stack), (void *) &dummy_var);
4175    }
4176
4177    zend_compile_params(params_ast TSRMLS_CC);
4178    if (uses_ast) {
4179        zend_compile_closure_uses(uses_ast TSRMLS_CC);
4180    }
4181    zend_compile_stmt(stmt_ast TSRMLS_CC);
4182
4183    if (is_method) {
4184        zend_check_magic_method_implementation(
4185            CG(active_class_entry), (zend_function *) op_array, E_COMPILE_ERROR TSRMLS_CC);
4186    }
4187
4188    zend_do_extended_info(TSRMLS_C);
4189    zend_emit_final_return(NULL TSRMLS_CC);
4190
4191    pass_two(CG(active_op_array) TSRMLS_CC);
4192    zend_release_labels(0 TSRMLS_CC);
4193
4194    /* Pop the loop variable stack separator */
4195    zend_stack_del_top(&CG(loop_var_stack));
4196
4197    CG(active_op_array) = orig_op_array;
4198}
4199/* }}} */
4200
4201void zend_compile_prop_decl(zend_ast *ast TSRMLS_DC) /* {{{ */
4202{
4203    zend_ast_list *list = zend_ast_get_list(ast);
4204    uint32_t flags = list->attr;
4205    zend_class_entry *ce = CG(active_class_entry);
4206    uint32_t i, children = list->children;
4207    zend_string *doc_comment = NULL;
4208
4209    if (ce->ce_flags & ZEND_ACC_INTERFACE) {
4210        zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables");
4211    }
4212
4213    if (flags & ZEND_ACC_ABSTRACT) {
4214        zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract");
4215    }
4216
4217    /* Doc comment has been appended as last element in property list */
4218    if (list->child[children - 1]->kind == ZEND_AST_ZVAL) {
4219        doc_comment = zend_string_copy(zend_ast_get_str(list->child[children - 1]));
4220        children -= 1;
4221    }
4222
4223    for (i = 0; i < children; ++i) {
4224        zend_ast *prop_ast = list->child[i];
4225        zend_ast *name_ast = prop_ast->child[0];
4226        zend_ast *value_ast = prop_ast->child[1];
4227        zend_string *name = zend_ast_get_str(name_ast);
4228        zval value_zv;
4229
4230        if (flags & ZEND_ACC_FINAL) {
4231            zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, "
4232                "the final modifier is allowed only for methods and classes",
4233                ce->name->val, name->val);
4234        }
4235
4236        if (zend_hash_exists(&ce->properties_info, name)) {
4237            zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s",
4238                ce->name->val, name->val);
4239        }
4240
4241        if (value_ast) {
4242            zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
4243        } else {
4244            ZVAL_NULL(&value_zv);
4245        }
4246
4247        name = zend_new_interned_string_safe(name TSRMLS_CC);
4248        zend_declare_property_ex(ce, name, &value_zv, flags, doc_comment TSRMLS_CC);
4249
4250        /* Doc comment is only assigned to first property */
4251        doc_comment = NULL;
4252    }
4253}
4254/* }}} */
4255
4256void zend_compile_class_const_decl(zend_ast *ast TSRMLS_DC) /* {{{ */
4257{
4258    zend_ast_list *list = zend_ast_get_list(ast);
4259    zend_class_entry *ce = CG(active_class_entry);
4260    uint32_t i;
4261
4262    for (i = 0; i < list->children; ++i) {
4263        zend_ast *const_ast = list->child[i];
4264        zend_ast *name_ast = const_ast->child[0];
4265        zend_ast *value_ast = const_ast->child[1];
4266        zend_string *name = zend_ast_get_str(name_ast);
4267        zval value_zv;
4268
4269        if (ZEND_CE_IS_TRAIT(ce)) {
4270            zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants");
4271            return;
4272        }
4273
4274        zend_const_expr_to_zval(&value_zv, value_ast TSRMLS_CC);
4275
4276        name = zend_new_interned_string_safe(name TSRMLS_CC);
4277        if (zend_hash_add(&ce->constants_table, name, &value_zv) == NULL) {
4278            zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s",
4279                ce->name->val, name->val);
4280        }
4281
4282        if (Z_CONSTANT(value_zv)) {
4283            ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
4284        }
4285    }
4286}
4287/* }}} */
4288
4289static zend_trait_method_reference *zend_compile_method_ref(zend_ast *ast TSRMLS_DC) /* {{{ */
4290{
4291    zend_ast *class_ast = ast->child[0];
4292    zend_ast *method_ast = ast->child[1];
4293
4294    zend_trait_method_reference *method_ref = emalloc(sizeof(zend_trait_method_reference));
4295    method_ref->ce = NULL;
4296    method_ref->method_name = zend_string_copy(zend_ast_get_str(method_ast));
4297
4298    if (class_ast) {
4299        method_ref->class_name = zend_resolve_class_name_ast(class_ast TSRMLS_CC);
4300    } else {
4301        method_ref->class_name = NULL;
4302    }
4303
4304    return method_ref;
4305}
4306/* }}} */
4307
4308static zend_string **zend_compile_name_list(zend_ast *ast TSRMLS_DC) /* {{{ */
4309{
4310    zend_ast_list *list = zend_ast_get_list(ast);
4311    zend_string **names = safe_emalloc(sizeof(zend_string *), list->children + 1, 0);
4312    uint32_t i;
4313
4314    for (i = 0; i < list->children; ++i) {
4315        zend_ast *name_ast = list->child[i];
4316        names[i] = zend_resolve_class_name_ast(name_ast TSRMLS_CC);
4317    }
4318
4319    names[list->children] = NULL;
4320
4321    return names;
4322}
4323/* }}} */
4324
4325static void zend_compile_trait_precedence(zend_ast *ast TSRMLS_DC) /* {{{ */
4326{
4327    zend_ast *method_ref_ast = ast->child[0];
4328    zend_ast *insteadof_ast = ast->child[1];
4329
4330    zend_trait_precedence *precedence = emalloc(sizeof(zend_trait_precedence));
4331    precedence->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC);
4332    precedence->exclude_from_classes
4333        = (void *) zend_compile_name_list(insteadof_ast TSRMLS_CC);
4334
4335    zend_add_to_list(&CG(active_class_entry)->trait_precedences, precedence TSRMLS_CC);
4336}
4337/* }}} */
4338
4339static void zend_compile_trait_alias(zend_ast *ast TSRMLS_DC) /* {{{ */
4340{
4341    zend_ast *method_ref_ast = ast->child[0];
4342    zend_ast *alias_ast = ast->child[1];
4343    uint32_t modifiers = ast->attr;
4344
4345    zend_trait_alias *alias;
4346
4347    if (modifiers == ZEND_ACC_STATIC) {
4348        zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'static' as method modifier");
4349    } else if (modifiers == ZEND_ACC_ABSTRACT) {
4350        zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'abstract' as method modifier");
4351    } else if (modifiers == ZEND_ACC_FINAL) {
4352        zend_error_noreturn(E_COMPILE_ERROR, "Cannot use 'final' as method modifier");
4353    }
4354
4355    alias = emalloc(sizeof(zend_trait_alias));
4356    alias->trait_method = zend_compile_method_ref(method_ref_ast TSRMLS_CC);
4357    alias->modifiers = modifiers;
4358
4359    if (alias_ast) {
4360        alias->alias = zend_string_copy(zend_ast_get_str(alias_ast));
4361    } else {
4362        alias->alias = NULL;
4363    }
4364
4365    zend_add_to_list(&CG(active_class_entry)->trait_aliases, alias TSRMLS_CC);
4366}
4367/* }}} */
4368
4369void zend_compile_use_trait(zend_ast *ast TSRMLS_DC) /* {{{ */
4370{
4371    zend_ast_list *traits = zend_ast_get_list(ast->child[0]);
4372    zend_ast_list *adaptations = ast->child[1] ? zend_ast_get_list(ast->child[1]) : NULL;
4373    zend_class_entry *ce = CG(active_class_entry);
4374    zend_op *opline;
4375    uint32_t i;
4376
4377    for (i = 0; i < traits->children; ++i) {
4378        zend_ast *trait_ast = traits->child[i];
4379        zend_string *name = zend_ast_get_str(trait_ast);
4380
4381        if (ce->ce_flags & ZEND_ACC_INTERFACE) {
4382            zend_error_noreturn(E_COMPILE_ERROR, "Cannot use traits inside of interfaces. "
4383                "%s is used in %s", name->val, ce->name->val);
4384        }
4385
4386        switch (zend_get_class_fetch_type(name)) {
4387            case ZEND_FETCH_CLASS_SELF:
4388            case ZEND_FETCH_CLASS_PARENT:
4389            case ZEND_FETCH_CLASS_STATIC:
4390                zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as trait name "
4391                    "as it is reserved", name->val);
4392                break;
4393        }
4394
4395        opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4396        opline->opcode = ZEND_ADD_TRAIT;
4397        SET_NODE(opline->op1, &CG(implementing_class));
4398        opline->op2_type = IS_CONST;
4399        opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
4400            zend_resolve_class_name_ast(trait_ast TSRMLS_CC) TSRMLS_CC);
4401
4402        ce->num_traits++;
4403    }
4404
4405    if (!adaptations) {
4406        return;
4407    }
4408
4409    for (i = 0; i < adaptations->children; ++i) {
4410        zend_ast *adaptation_ast = adaptations->child[i];
4411        switch (adaptation_ast->kind) {
4412            case ZEND_AST_TRAIT_PRECEDENCE:
4413                zend_compile_trait_precedence(adaptation_ast TSRMLS_CC);
4414                break;
4415            case ZEND_AST_TRAIT_ALIAS:
4416                zend_compile_trait_alias(adaptation_ast TSRMLS_CC);
4417                break;
4418            EMPTY_SWITCH_DEFAULT_CASE()
4419        }
4420    }
4421}
4422/* }}} */
4423
4424void zend_compile_implements(znode *class_node, zend_ast *ast TSRMLS_DC) /* {{{ */
4425{
4426    zend_ast_list *list = zend_ast_get_list(ast);
4427    uint32_t i;
4428    for (i = 0; i < list->children; ++i) {
4429        zend_ast *class_ast = list->child[i];
4430        zend_string *name = zend_ast_get_str(class_ast);
4431
4432        zend_op *opline;
4433
4434        /* Traits can not implement interfaces */
4435        if (ZEND_CE_IS_TRAIT(CG(active_class_entry))) {
4436            zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' "
4437                "since it is a Trait", name->val, CG(active_class_entry)->name->val);
4438        }
4439
4440        if (!zend_is_const_default_class_ref(class_ast)) {
4441            zend_error_noreturn(E_COMPILE_ERROR,
4442                "Cannot use '%s' as interface name as it is reserved", name->val);
4443        }
4444
4445        opline = zend_emit_op(NULL, ZEND_ADD_INTERFACE, class_node, NULL TSRMLS_CC);
4446        opline->op2_type = IS_CONST;
4447        opline->op2.constant = zend_add_class_name_literal(CG(active_op_array),
4448            zend_resolve_class_name_ast(class_ast TSRMLS_CC) TSRMLS_CC);
4449
4450        CG(active_class_entry)->num_interfaces++;
4451    }
4452}
4453/* }}} */
4454
4455void zend_compile_class_decl(zend_ast *ast TSRMLS_DC) /* {{{ */
4456{
4457    zend_ast_decl *decl = (zend_ast_decl *) ast;
4458    zend_ast *extends_ast = decl->child[0];
4459    zend_ast *implements_ast = decl->child[1];
4460    zend_ast *stmt_ast = decl->child[2];
4461
4462    zend_string *name = decl->name, *lcname, *import_name = NULL;
4463    zend_class_entry *ce = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry));
4464    zend_op *opline;
4465    znode declare_node, extends_node;
4466
4467    if (CG(active_class_entry)) {
4468        zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested");
4469        return;
4470    }
4471
4472    if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
4473        zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved",
4474            name->val);
4475    }
4476
4477    lcname = zend_string_alloc(name->len, 0);
4478    zend_str_tolower_copy(lcname->val, name->val, name->len);
4479
4480    if (CG(current_import)) {
4481        import_name = zend_hash_find_ptr(CG(current_import), lcname);
4482    }
4483
4484    if (CG(current_namespace)) {
4485        name = zend_prefix_with_ns(name TSRMLS_CC);
4486
4487        zend_string_release(lcname);
4488        lcname = zend_string_alloc(name->len, 0);
4489        zend_str_tolower_copy(lcname->val, name->val, name->len);
4490    } else {
4491        zend_string_addref(name);
4492    }
4493
4494    if (import_name && !zend_string_equals_str_ci(lcname, import_name)) {
4495        zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s "
4496            "because the name is already in use", name->val);
4497    }
4498
4499    name = zend_new_interned_string(name TSRMLS_CC);
4500    lcname = zend_new_interned_string(lcname TSRMLS_CC);
4501
4502    ce->type = ZEND_USER_CLASS;
4503    ce->name = name;
4504    zend_initialize_class_data(ce, 1 TSRMLS_CC);
4505
4506    ce->ce_flags |= decl->flags;
4507    ce->info.user.filename = zend_get_compiled_filename(TSRMLS_C);
4508    ce->info.user.line_start = decl->start_lineno;
4509    ce->info.user.line_end = decl->end_lineno;
4510    if (decl->doc_comment) {
4511        ce->info.user.doc_comment = zend_string_copy(decl->doc_comment);
4512    }
4513
4514    if (extends_ast) {
4515        if (ZEND_CE_IS_TRAIT(ce)) {
4516            zend_error_noreturn(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. "
4517                "Traits can only be composed from other traits with the 'use' keyword. Error",
4518                name->val);
4519        }
4520
4521        if (!zend_is_const_default_class_ref(extends_ast)) {
4522            zend_string *extends_name = zend_ast_get_str(extends_ast);
4523            zend_error_noreturn(E_COMPILE_ERROR,
4524                "Cannot use '%s' as class name as it is reserved", extends_name->val);
4525        }
4526
4527        zend_compile_class_ref(&extends_node, extends_ast TSRMLS_CC);
4528    }
4529
4530    opline = get_next_op(CG(active_op_array) TSRMLS_CC);
4531    zend_make_var_result(&declare_node, opline TSRMLS_CC);
4532
4533    // TODO.AST drop this
4534    GET_NODE(&CG(implementing_class), opline->result);
4535
4536    opline->op2_type = IS_CONST;
4537    LITERAL_STR(opline->op2, lcname);
4538
4539    if (extends_ast) {
4540        opline->opcode = ZEND_DECLARE_INHERITED_CLASS;
4541        opline->extended_value = extends_node.u.op.var;
4542    } else {
4543        opline->opcode = ZEND_DECLARE_CLASS;
4544    }
4545
4546    {
4547        zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos TSRMLS_CC);
4548
4549        opline->op1_type = IS_CONST;
4550        LITERAL_STR(opline->op1, key);
4551
4552        zend_hash_update_ptr(CG(class_table), key, ce);
4553    }
4554
4555    CG(active_class_entry) = ce;
4556
4557    if (implements_ast) {
4558        zend_compile_implements(&declare_node, implements_ast TSRMLS_CC);
4559    }
4560
4561    zend_compile_stmt(stmt_ast TSRMLS_CC);
4562
4563    if (ce->constructor) {
4564        ce->constructor->common.fn_flags |= ZEND_ACC_CTOR;
4565        if (ce->constructor->common.fn_flags & ZEND_ACC_STATIC) {
4566            zend_error_noreturn(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static",
4567                ce->name->val, ce->constructor->common.function_name->val);
4568        }
4569    }
4570    if (ce->destructor) {
4571        ce->destructor->common.fn_flags |= ZEND_ACC_DTOR;
4572        if (ce->destructor->common.fn_flags & ZEND_ACC_STATIC) {
4573            zend_error_noreturn(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static",
4574                ce->name->val, ce->destructor->common.function_name->val);
4575        }
4576    }
4577    if (ce->clone) {
4578        ce->clone->common.fn_flags |= ZEND_ACC_CLONE;
4579        if (ce->clone->common.fn_flags & ZEND_ACC_STATIC) {
4580            zend_error_noreturn(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static",
4581                ce->name->val, ce->clone->common.function_name->val);
4582        }
4583    }
4584
4585    /* Check for traits and proceed like with interfaces.
4586     * The only difference will be a combined handling of them in the end.
4587     * Thus, we need another opcode here. */
4588    if (ce->num_traits > 0) {
4589        ce->traits = NULL;
4590        ce->num_traits = 0;
4591        ce->ce_flags |= ZEND_ACC_IMPLEMENT_TRAITS;
4592
4593        zend_emit_op(NULL, ZEND_BIND_TRAITS, &declare_node, NULL TSRMLS_CC);
4594    }
4595
4596    if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))
4597        && (extends_ast || ce->num_interfaces > 0)
4598    ) {
4599        zend_verify_abstract_class(ce TSRMLS_CC);
4600        if (ce->num_interfaces && !(ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS)) {
4601            zend_emit_op(NULL, ZEND_VERIFY_ABSTRACT_CLASS, &declare_node, NULL TSRMLS_CC);
4602        }
4603    }
4604
4605    /* Inherit interfaces; reset number to zero, we need it for above check and
4606     * will restore it during actual implementation.
4607     * The ZEND_ACC_IMPLEMENT_INTERFACES flag disables double call to
4608     * zend_verify_abstract_class() */
4609    if (ce->num_interfaces > 0) {
4610        ce->interfaces = NULL;
4611        ce->num_interfaces = 0;
4612        ce->ce_flags |= ZEND_ACC_IMPLEMENT_INTERFACES;
4613    }
4614
4615    CG(active_class_entry) = NULL;
4616}
4617/* }}} */
4618
4619static HashTable *zend_get_import_ht(uint32_t type TSRMLS_DC) /* {{{ */
4620{
4621    switch (type) {
4622        case T_CLASS:
4623            if (!CG(current_import)) {
4624                CG(current_import) = emalloc(sizeof(HashTable));
4625                zend_hash_init(CG(current_import), 8, NULL, str_dtor, 0);
4626            }
4627            return CG(current_import);
4628        case T_FUNCTION:
4629            if (!CG(current_import_function)) {
4630                CG(current_import_function) = emalloc(sizeof(HashTable));
4631                zend_hash_init(CG(current_import_function), 8, NULL, str_dtor, 0);
4632            }
4633            return CG(current_import_function);
4634        case T_CONST:
4635            if (!CG(current_import_const)) {
4636                CG(current_import_const) = emalloc(sizeof(HashTable));
4637                zend_hash_init(CG(current_import_const), 8, NULL, str_dtor, 0);
4638            }
4639            return CG(current_import_const);
4640        EMPTY_SWITCH_DEFAULT_CASE()
4641    }
4642}
4643/* }}} */
4644
4645static char *zend_get_use_type_str(uint32_t type) /* {{{ */
4646{
4647    switch (type) {
4648        case T_CLASS:
4649            return "";
4650        case T_FUNCTION:
4651            return " function";
4652        case T_CONST:
4653            return " const";
4654        EMPTY_SWITCH_DEFAULT_CASE()
4655    }
4656}
4657/* }}} */
4658
4659static void zend_check_already_in_use(uint32_t type, zend_string *old_name, zend_string *new_name, zend_string *check_name) /* {{{ */
4660{
4661    if (zend_string_equals_str_ci(old_name, check_name)) {
4662        return;
4663    }
4664
4665    zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name "
4666        "is already in use", zend_get_use_type_str(type), old_name->val, new_name->val);
4667}
4668/* }}} */
4669
4670void zend_compile_use(zend_ast *ast TSRMLS_DC) /* {{{ */
4671{
4672    zend_ast_list *list = zend_ast_get_list(ast);
4673    uint32_t i;
4674    zend_string *current_ns = CG(current_namespace);
4675    uint32_t type = ast->attr;
4676    HashTable *current_import = zend_get_import_ht(type TSRMLS_CC);
4677    zend_bool case_sensitive = type == T_CONST;
4678
4679    for (i = 0; i < list->children; ++i) {
4680        zend_ast *use_ast = list->child[i];
4681        zend_ast *old_name_ast = use_ast->child[0];
4682        zend_ast *new_name_ast = use_ast->child[1];
4683        zend_string *old_name = zend_ast_get_str(old_name_ast);
4684        zend_string *new_name, *lookup_name;
4685
4686        if (new_name_ast) {
4687            new_name = zend_string_copy(zend_ast_get_str(new_name_ast));
4688        } else {
4689            const char *unqualified_name;
4690            size_t unqualified_name_len;
4691            if (zend_get_unqualified_name(old_name, &unqualified_name, &unqualified_name_len)) {
4692                /* The form "use A\B" is eqivalent to "use A\B as B" */
4693                new_name = zend_string_init(unqualified_name, unqualified_name_len, 0);
4694            } else {
4695                new_name = zend_string_copy(old_name);
4696
4697                if (!current_ns) {
4698                    if (type == T_CLASS && zend_string_equals_literal(new_name, "strict")) {
4699                        zend_error_noreturn(E_COMPILE_ERROR,
4700                            "You seem to be trying to use a different language...");
4701                    }
4702
4703                    zend_error(E_WARNING, "The use statement with non-compound name '%s' "
4704                        "has no effect", new_name->val);
4705                }
4706            }
4707        }
4708
4709        if (case_sensitive) {
4710            lookup_name = zend_string_copy(new_name);
4711        } else {
4712            lookup_name = zend_string_alloc(new_name->len, 0);
4713            zend_str_tolower_copy(lookup_name->val, new_name->val, new_name->len);
4714        }
4715
4716        if (type == T_CLASS && (zend_string_equals_literal(lookup_name, "self")
4717            || zend_string_equals_literal(lookup_name, "parent"))
4718        ) {
4719            zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' "
4720                "is a special class name", old_name->val, new_name->val, new_name->val);
4721        }
4722
4723        if (current_ns) {
4724            zend_string *ns_name = zend_string_alloc(current_ns->len + 1 + new_name->len, 0);
4725            zend_str_tolower_copy(ns_name->val, current_ns->val, current_ns->len);
4726            ns_name->val[current_ns->len] = '\\';
4727            memcpy(ns_name->val + current_ns->len + 1, lookup_name->val, lookup_name->len);
4728
4729            if (zend_hash_exists(CG(class_table), ns_name)) {
4730                zend_check_already_in_use(type, old_name, new_name, ns_name);
4731            }
4732
4733            zend_string_free(ns_name);
4734        } else {
4735            switch (type) {
4736                case T_CLASS:
4737                {
4738                    zend_class_entry *ce = zend_hash_find_ptr(CG(class_table), lookup_name);
4739                    if (ce && ce->type == ZEND_USER_CLASS
4740                        && ce->info.user.filename == CG(compiled_filename)
4741                    ) {
4742                        zend_check_already_in_use(type, old_name, new_name, lookup_name);
4743                    }
4744                    break;
4745                }
4746                case T_FUNCTION:
4747                {
4748                    zend_function *fn = zend_hash_find_ptr(CG(function_table), lookup_name);
4749                    if (fn && fn->type == ZEND_USER_FUNCTION
4750                        && fn->op_array.filename == CG(compiled_filename)
4751                    ) {
4752                        zend_check_already_in_use(type, old_name, new_name, lookup_name);
4753                    }
4754                    break;
4755                }
4756                case T_CONST:
4757                {
4758                    zend_string *filename = zend_hash_find_ptr(&CG(const_filenames), lookup_name);
4759                    if (filename && filename == CG(compiled_filename)) {
4760                        zend_check_already_in_use(type, old_name, new_name, lookup_name);
4761                    }
4762                    break;
4763                }
4764                EMPTY_SWITCH_DEFAULT_CASE()
4765            }
4766        }
4767
4768        zend_string_addref(old_name);
4769        if (!zend_hash_add_ptr(current_import, lookup_name, old_name)) {
4770            zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name "
4771                "is already in use", zend_get_use_type_str(type), old_name->val, new_name->val);
4772        }
4773
4774        zend_string_release(lookup_name);
4775        zend_string_release(new_name);
4776    }
4777}
4778/* }}} */
4779
4780void zend_compile_const_decl(zend_ast *ast TSRMLS_DC) /* {{{ */
4781{
4782    zend_ast_list *list = zend_ast_get_list(ast);
4783    uint32_t i;
4784    for (i = 0; i < list->children; ++i) {
4785        zend_ast *const_ast = list->child[i];
4786        zend_ast *name_ast = const_ast->child[0];
4787        zend_ast *value_ast = const_ast->child[1];
4788        zend_string *name = zend_ast_get_str(name_ast);
4789
4790        zend_string *import_name;
4791        znode name_node, value_node;
4792        zval *value_zv = &value_node.u.constant;
4793
4794        value_node.op_type = IS_CONST;
4795        zend_const_expr_to_zval(value_zv, value_ast TSRMLS_CC);
4796
4797        if (zend_lookup_reserved_const(name->val, name->len TSRMLS_CC)) {
4798            zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", name->val);
4799        }
4800
4801        name = zend_prefix_with_ns(name TSRMLS_CC);
4802        name = zend_new_interned_string(name TSRMLS_CC);
4803
4804        if (CG(current_import_const)
4805            && (import_name = zend_hash_find_ptr(CG(current_import_const), name))
4806        ) {
4807            if (!zend_string_equals(import_name, name)) {
4808                zend_error(E_COMPILE_ERROR, "Cannot declare const %s because "
4809                    "the name is already in use", name->val);
4810            }
4811        }
4812
4813        name_node.op_type = IS_CONST;
4814        ZVAL_STR(&name_node.u.constant, name);
4815
4816        zend_emit_op(NULL, ZEND_DECLARE_CONST, &name_node, &value_node TSRMLS_CC);
4817
4818        zend_hash_add_ptr(&CG(const_filenames), name, CG(compiled_filename));
4819    }
4820}
4821/* }}}*/
4822
4823void zend_compile_namespace(zend_ast *ast TSRMLS_DC) /* {{{ */
4824{
4825    zend_ast *name_ast = ast->child[0];
4826    zend_ast *stmt_ast = ast->child[1];
4827    zend_string *name;
4828    zend_bool with_bracket = stmt_ast != NULL;
4829
4830    /* handle mixed syntax declaration or nested namespaces */
4831    if (!CG(has_bracketed_namespaces)) {
4832        if (CG(current_namespace)) {
4833            /* previous namespace declarations were unbracketed */
4834            if (with_bracket) {
4835                zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations "
4836                    "with unbracketed namespace declarations");
4837            }
4838        }
4839    } else {
4840        /* previous namespace declarations were bracketed */
4841        if (!with_bracket) {
4842            zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations "
4843                "with unbracketed namespace declarations");
4844        } else if (CG(current_namespace) || CG(in_namespace)) {
4845            zend_error_noreturn(E_COMPILE_ERROR, "Namespace declarations cannot be nested");
4846        }
4847    }
4848
4849    if (((!with_bracket && !CG(current_namespace))
4850         || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0
4851    ) {
4852        /* ignore ZEND_EXT_STMT and ZEND_TICKS */
4853        uint32_t num = CG(active_op_array)->last;
4854        while (num > 0 &&
4855               (CG(active_op_array)->opcodes[num-1].opcode == ZEND_EXT_STMT ||
4856                CG(active_op_array)->opcodes[num-1].opcode == ZEND_TICKS)) {
4857            --num;
4858        }
4859        if (num > 0) {
4860            zend_error_noreturn(E_COMPILE_ERROR, "Namespace declaration statement has to be "
4861                "the very first statement in the script");
4862        }
4863    }
4864
4865    if (CG(current_namespace)) {
4866        zend_string_release(CG(current_namespace));
4867    }
4868
4869    if (name_ast) {
4870        name = zend_ast_get_str(name_ast);
4871
4872        if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(name)) {
4873            zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as namespace name", name->val);
4874        }
4875
4876        CG(current_namespace) = zend_string_copy(name);
4877    } else {
4878        CG(current_namespace) = NULL;
4879    }
4880
4881    zend_reset_import_tables(TSRMLS_C);
4882
4883    CG(in_namespace) = 1;
4884    if (with_bracket) {
4885        CG(has_bracketed_namespaces) = 1;
4886    }
4887
4888    if (stmt_ast) {
4889        zend_compile_top_stmt(stmt_ast TSRMLS_CC);
4890        zend_end_namespace(TSRMLS_C);
4891    }
4892}
4893/* }}} */
4894
4895void zend_compile_halt_compiler(zend_ast *ast TSRMLS_DC) /* {{{ */
4896{
4897    zend_ast *offset_ast = ast->child[0];
4898    zend_long offset = Z_LVAL_P(zend_ast_get_zval(offset_ast));
4899
4900    zend_string *filename, *name;
4901    const char const_name[] = "__COMPILER_HALT_OFFSET__";
4902
4903    if (CG(has_bracketed_namespaces) && CG(in_namespace)) {
4904        zend_error_noreturn(E_COMPILE_ERROR,
4905            "__HALT_COMPILER() can only be used from the outermost scope");
4906    }
4907
4908    filename = zend_get_compiled_filename(TSRMLS_C);
4909    name = zend_mangle_property_name(const_name, sizeof(const_name) - 1,
4910        filename->val, filename->len, 0);
4911
4912    zend_register_long_constant(name->val, name->len, offset, CONST_CS, 0 TSRMLS_CC);
4913    zend_string_release(name);
4914}
4915/* }}} */
4916
4917static zend_bool zend_try_ct_eval_magic_const(zval *zv, zend_ast *ast TSRMLS_DC) /* {{{ */
4918{
4919    zend_op_array *op_array = CG(active_op_array);
4920    zend_class_entry *ce = CG(active_class_entry);
4921
4922    switch (ast->attr) {
4923        case T_LINE:
4924            ZVAL_LONG(zv, ast->lineno);
4925            break;
4926        case T_FILE:
4927            ZVAL_STR_COPY(zv, CG(compiled_filename));
4928            break;
4929        case T_DIR:
4930        {
4931            zend_string *filename = CG(compiled_filename);
4932            zend_string *dirname = zend_string_init(filename->val, filename->len, 0);
4933            zend_dirname(dirname->val, dirname->len);
4934
4935            if (strcmp(dirname->val, ".") == 0) {
4936                dirname = zend_string_realloc(dirname, MAXPATHLEN, 0);
4937#if HAVE_GETCWD
4938                VCWD_GETCWD(dirname->val, MAXPATHLEN);
4939#elif HAVE_GETWD
4940                VCWD_GETWD(dirname->val);
4941#endif
4942            }
4943
4944            dirname->len = strlen(dirname->val);
4945            ZVAL_STR(zv, dirname);
4946            break;
4947        }
4948        case T_FUNC_C:
4949            if (op_array && op_array->function_name) {
4950                ZVAL_STR_COPY(zv, op_array->function_name);
4951            } else {
4952                ZVAL_EMPTY_STRING(zv);
4953            }
4954            break;
4955        case T_METHOD_C:
4956            if (ce) {
4957                if (op_array && op_array->function_name) {
4958                    ZVAL_NEW_STR(zv, zend_concat3(ce->name->val, ce->name->len, "::", 2,
4959                        op_array->function_name->val, op_array->function_name->len));
4960                } else {
4961                    ZVAL_STR_COPY(zv, ce->name);
4962                }
4963            } else if (op_array && op_array->function_name) {
4964                ZVAL_STR_COPY(zv, op_array->function_name);
4965            } else {
4966                ZVAL_EMPTY_STRING(zv);
4967            }
4968            break;
4969        case T_CLASS_C:
4970            if (ce) {
4971                if (ZEND_CE_IS_TRAIT(ce)) {
4972                    return 0;
4973                } else {
4974                    ZVAL_STR_COPY(zv, ce->name);
4975                }
4976            } else {
4977                ZVAL_EMPTY_STRING(zv);
4978            }
4979            break;
4980        case T_TRAIT_C:
4981            if (ce && ZEND_CE_IS_TRAIT(ce)) {
4982                ZVAL_STR_COPY(zv, ce->name);
4983            } else {
4984                ZVAL_EMPTY_STRING(zv);
4985            }
4986            break;
4987        case T_NS_C:
4988            if (CG(current_namespace)) {
4989                ZVAL_STR_COPY(zv, CG(current_namespace));
4990            } else {
4991                ZVAL_EMPTY_STRING(zv);
4992            }
4993            break;
4994        EMPTY_SWITCH_DEFAULT_CASE()
4995    }
4996
4997    return 1;
4998}
4999/* }}} */
5000
5001static inline void zend_ct_eval_binary_op(zval *result, uint32_t opcode, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
5002{
5003    binary_op_type fn = get_binary_op(opcode);
5004    fn(result, op1, op2 TSRMLS_CC);
5005}
5006/* }}} */
5007
5008static inline void zend_ct_eval_unary_pm(zval *result, zend_ast_kind kind, zval *op TSRMLS_DC) /* {{{ */
5009{
5010    binary_op_type fn = kind == ZEND_AST_UNARY_PLUS
5011        ? add_function : sub_function;
5012
5013    zval left;
5014    ZVAL_LONG(&left, 0);
5015    fn(result, &left, op TSRMLS_CC);
5016}
5017/* }}} */
5018
5019static inline void zend_ct_eval_greater(zval *result, zend_ast_kind kind, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
5020{
5021    binary_op_type fn = kind == ZEND_AST_GREATER
5022        ? is_smaller_function : is_smaller_or_equal_function;
5023    fn(result, op2, op1 TSRMLS_CC);
5024}
5025/* }}} */
5026
5027static zend_bool zend_try_ct_eval_array(zval *result, zend_ast *ast TSRMLS_DC) /* {{{ */
5028{
5029    zend_ast_list *list = zend_ast_get_list(ast);
5030    uint32_t i;
5031
5032    /* First ensure that *all* child nodes are constant and by-val */
5033    for (i = 0; i < list->children; ++i) {
5034        zend_ast *elem_ast = list->child[i];
5035        zend_bool by_ref = elem_ast->attr;
5036        zend_eval_const_expr(&elem_ast->child[0] TSRMLS_CC);
5037        zend_eval_const_expr(&elem_ast->child[1] TSRMLS_CC);
5038
5039        if (by_ref || elem_ast->child[0]->kind != ZEND_AST_ZVAL
5040            || (elem_ast->child[1] && elem_ast->child[1]->kind != ZEND_AST_ZVAL)
5041        ) {
5042            return 0;
5043        }
5044    }
5045
5046    array_init_size(result, list->children);
5047    for (i = 0; i < list->children; ++i) {
5048        zend_ast *elem_ast = list->child[i];
5049        zend_ast *value_ast = elem_ast->child[0];
5050        zend_ast *key_ast = elem_ast->child[1];
5051
5052        zval *value = zend_ast_get_zval(value_ast);
5053        if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
5054
5055        if (key_ast) {
5056            zval *key = zend_ast_get_zval(key_ast);
5057            switch (Z_TYPE_P(key)) {
5058                case IS_LONG:
5059                    zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(key), value);
5060                    break;
5061                case IS_STRING:
5062                    zend_symtable_update(Z_ARRVAL_P(result), Z_STR_P(key), value);
5063                    break;
5064                case IS_DOUBLE:
5065                    zend_hash_index_update(Z_ARRVAL_P(result),
5066                        zend_dval_to_lval(Z_DVAL_P(key)), value);
5067                    break;
5068                case IS_FALSE:
5069                    zend_hash_index_update(Z_ARRVAL_P(result), 0, value);
5070                    break;
5071                case IS_TRUE:
5072                    zend_hash_index_update(Z_ARRVAL_P(result), 1, value);
5073                    break;
5074                case IS_NULL:
5075                    zend_hash_update(Z_ARRVAL_P(result), STR_EMPTY_ALLOC(), value);
5076                    break;
5077                default:
5078                    zend_error(E_COMPILE_ERROR, "Illegal offset type");
5079                    break;
5080            }
5081        } else {
5082            zend_hash_next_index_insert(Z_ARRVAL_P(result), value);
5083        }
5084    }
5085
5086    return 1;
5087}
5088/* }}} */
5089
5090void zend_compile_binary_op(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
5091{
5092    zend_ast *left_ast = ast->child[0];
5093    zend_ast *right_ast = ast->child[1];
5094    uint32_t opcode = ast->attr;
5095
5096    znode left_node, right_node;
5097    zend_compile_expr(&left_node, left_ast TSRMLS_CC);
5098    zend_compile_expr(&right_node, right_ast TSRMLS_CC);
5099
5100    if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) {
5101        result->op_type = IS_CONST;
5102        zend_ct_eval_binary_op(&result->u.constant, opcode,
5103            &left_node.u.constant, &right_node.u.constant TSRMLS_CC);
5104        zval_ptr_dtor(&left_node.u.constant);
5105        zval_ptr_dtor(&right_node.u.constant);
5106        return;
5107    }
5108
5109    zend_emit_op_tmp(result, opcode, &left_node, &right_node TSRMLS_CC);
5110}
5111/* }}} */
5112
5113/* We do not use zend_compile_binary_op for this because we want to retain the left-to-right
5114 * evaluation order. */
5115void zend_compile_greater(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
5116{
5117    zend_ast *left_ast = ast->child[0];
5118    zend_ast *right_ast = ast->child[1];
5119    znode left_node, right_node;
5120
5121    ZEND_ASSERT(ast->kind == ZEND_AST_GREATER || ast->kind == ZEND_AST_GREATER_EQUAL);
5122
5123    zend_compile_expr(&left_node, left_ast TSRMLS_CC);
5124    zend_compile_expr(&right_node, right_ast TSRMLS_CC);
5125
5126    if (left_node.op_type == IS_CONST && right_node.op_type == IS_CONST) {
5127        result->op_type = IS_CONST;
5128        zend_ct_eval_greater(&result->u.constant, ast->kind,
5129            &left_node.u.constant, &right_node.u.constant TSRMLS_CC);
5130        zval_ptr_dtor(&left_node.u.constant);
5131        zval_ptr_dtor(&right_node.u.constant);
5132        return;
5133    }
5134
5135    zend_emit_op_tmp(result,
5136        ast->kind == ZEND_AST_GREATER ? ZEND_IS_SMALLER : ZEND_IS_SMALLER_OR_EQUAL,
5137        &right_node, &left_node TSRMLS_CC);
5138}
5139/* }}} */
5140
5141void zend_compile_unary_op(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
5142{
5143    zend_ast *expr_ast = ast->child[0];
5144    uint32_t opcode = ast->attr;
5145
5146    znode expr_node;
5147    zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
5148
5149    zend_emit_op_tmp(result, opcode, &expr_node, NULL TSRMLS_CC);
5150}
5151/* }}} */
5152
5153void zend_compile_unary_pm(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
5154{
5155    zend_ast *expr_ast = ast->child[0];
5156    znode zero_node, expr_node;
5157
5158    ZEND_ASSERT(ast->kind == ZEND_AST_UNARY_PLUS || ast->kind == ZEND_AST_UNARY_MINUS);
5159
5160    zend_compile_expr(&expr_node, expr_ast TSRMLS_CC);
5161
5162    if (expr_node.op_type == IS_CONST) {
5163        result->op_type = IS_CONST;
5164        zend_ct_eval_unary_pm(&result->u.constant, ast->kind, &expr_node.u.constant TSRMLS_CC);
5165        zval_ptr_dtor(&expr_node.u.constant);
5166        return;
5167    }
5168
5169    zero_node.op_type = IS_CONST;
5170    ZVAL_LONG(&zero_node.u.constant, 0);
5171
5172    zend_emit_op_tmp(result, ast->kind == ZEND_AST_UNARY_PLUS ? ZEND_ADD : ZEND_SUB,
5173        &zero_node, &expr_node TSRMLS_CC);
5174}
5175/* }}} */
5176
5177void zend_compile_short_circuiting(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
5178{
5179    zend_ast *left_ast = ast->child[0];
5180    zend_ast *right_ast = ast->child[1];
5181
5182    znode left_node, right_node;
5183    zend_op *opline_jmpz, *opline_bool;
5184    uint32_t opnum_jmpz;
5185
5186    ZEND_ASSERT(ast->kind == ZEND_AST_AND || ast->kind == ZEND_AST_OR);
5187
5188    zend_compile_expr(&left_node, left_ast TSRMLS_CC);
5189
5190    opnum_jmpz = get_next_op_number(CG(active_op_array));
5191    opline_jmpz = zend_emit_op(NULL, ast->kind == ZEND_AST_AND ? ZEND_JMPZ_EX : ZEND_JMPNZ_EX,
5192        &left_node, NULL TSRMLS_CC);
5193
5194    if (left_node.op_type == IS_TMP_VAR) {
5195        SET_NODE(opline_jmpz->result, &left_node);
5196    } else {
5197        opline_jmpz->result.var = get_temporary_variable(CG(active_op_array));
5198        opline_jmpz->result_type = IS_TMP_VAR;
5199    }
5200    GET_NODE(result, opline_jmpz->result);
5201
5202    zend_compile_expr(&right_node, right_ast TSRMLS_CC);
5203
5204    opline_bool = zend_emit_op(NULL, ZEND_BOOL, &right_node, NULL TSRMLS_CC);
5205    SET_NODE(opline_bool->result, result);
5206
5207    zend_update_jump_target_to_next(opnum_jmpz TSRMLS_CC);
5208}
5209/* }}} */
5210
5211void zend_compile_post_incdec(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
5212{
5213    zend_ast *var_ast = ast->child[0];
5214    ZEND_ASSERT(ast->kind == ZEND_AST_POST_INC || ast->kind == ZEND_AST_POST_DEC);
5215
5216    if (var_ast->kind == ZEND_AST_PROP) {
5217        zend_op *opline = zend_compile_prop_common(NULL, var_ast, BP_VAR_RW TSRMLS_CC);
5218        opline->opcode = ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC_OBJ : ZEND_POST_DEC_OBJ;
5219        zend_make_tmp_result(result, opline TSRMLS_CC);
5220    } else {
5221        znode var_node;
5222        zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
5223        zend_emit_op_tmp(result, ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC : ZEND_POST_DEC,
5224            &var_node, NULL TSRMLS_CC);
5225    }
5226}
5227/* }}} */
5228
5229void zend_compile_pre_incdec(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
5230{
5231    zend_ast *var_ast = ast->child[0];
5232    ZEND_ASSERT(ast->kind == ZEND_AST_PRE_INC || ast->kind == ZEND_AST_PRE_DEC);
5233
5234    if (var_ast->kind == ZEND_AST_PROP) {
5235        zend_op *opline = zend_compile_prop_common(result, var_ast, BP_VAR_RW TSRMLS_CC);
5236        opline->opcode = ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC_OBJ : ZEND_PRE_DEC_OBJ;
5237    } else {
5238        znode var_node;
5239        zend_compile_var(&var_node, var_ast, BP_VAR_RW TSRMLS_CC);
5240